-
Notifications
You must be signed in to change notification settings - Fork 71
/
ember-app.js
328 lines (281 loc) · 9.88 KB
/
ember-app.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
'use strict';
const fs = require('fs');
const path = require('path');
const RSVP = require('rsvp');
const najax = require('najax');
const SimpleDOM = require('simple-dom');
const existsSync = require('exists-sync');
const debug = require('debug')('fastboot:ember-app');
const FastBootInfo = require('./fastboot-info');
const Result = require('./result');
/**
* @private
*
* The `EmberApp` class serves as a non-sandboxed wrapper around a sandboxed
* `Ember.Application`. This bridge allows the FastBoot to quickly spin up new
* `ApplicationInstances` initialized at a particular route, then destroy them
* once the route has finished rendering.
*/
class EmberApp {
/**
* Create a new EmberApp.
* @param {Object} options
* @param {string} options.distPath - path to the built Ember application
* @param {Sandbox} [options.sandbox=VMSandbox] - sandbox to use
*/
constructor(options) {
let distPath = path.resolve(options.distPath);
let config = this.readPackageJSON(distPath);
this.appFilePath = config.appFile;
this.vendorFilePath = config.vendorFile;
this.moduleWhitelist = config.moduleWhitelist;
this.hostWhitelist = config.hostWhitelist;
this.appConfig = config.appConfig;
if (process.env.APP_CONFIG) {
this.appConfig = JSON.parse(process.env.APP_CONFIG);
}
this.html = fs.readFileSync(config.htmlFile, 'utf8');
this.sandbox = this.buildSandbox(distPath, options.sandbox);
this.app = this.retrieveSandboxedApp();
}
/**
* @private
*
* Builds and initializes a new sandbox to run the Ember application in.
*
* @param {string} distPath path to the built Ember app to load
* @param {Sandbox} [sandboxClass=VMSandbox] sandbox class to use
*/
buildSandbox(distPath, sandboxClass) {
let Sandbox = sandboxClass || require('./vm-sandbox');
let sandboxRequire = this.buildWhitelistedRequire(this.moduleWhitelist, distPath);
let config = this.appConfig;
function appConfig() {
return { default: config };
}
return new Sandbox({
globals: {
najax: najax,
FastBoot: {
require: sandboxRequire,
config: appConfig
}
}
});
}
/**
* @private
*
* The Ember app runs inside a sandbox that doesn't have access to the normal
* Node.js environment, including the `require` function. Instead, we provide
* our own `require` method that only allows whitelisted packages to be
* requested.
*
* This method takes an array of whitelisted package names and the path to the
* built Ember app and constructs this "fake" `require` function that gets made
* available globally inside the sandbox.
*
* @param {string[]} whitelist array of whitelisted package names
* @param {string} distPath path to the built Ember app
*/
buildWhitelistedRequire(whitelist, distPath) {
whitelist.forEach(function(whitelistedModule) {
debug("module whitelisted; module=%s", whitelistedModule);
});
return function(moduleName) {
if (whitelist.indexOf(moduleName) > -1) {
let nodeModulesPath = path.join(distPath, 'node_modules', moduleName);
if (existsSync(nodeModulesPath)) {
return require(nodeModulesPath);
} else {
// If it's not on disk, assume it's a built-in node package
return require(moduleName);
}
} else {
throw new Error("Unable to require module '" + moduleName + "' because it was not in the whitelist.");
}
};
}
/**
* @private
*
* Initializes the sandbox by evaluating the Ember app's JavaScript
* code, then retrieves the application factory from the sandbox and creates a new
* `Ember.Application`.
*
* @returns {Ember.Application} the Ember application from the sandbox
*/
retrieveSandboxedApp() {
let sandbox = this.sandbox;
let appFilePath = this.appFilePath;
let vendorFilePath = this.vendorFilePath;
sandbox.eval('sourceMapSupport.install(Error);');
let appFile = fs.readFileSync(appFilePath, 'utf8');
let vendorFile = fs.readFileSync(vendorFilePath, 'utf8');
debug("evaluating app; app=%s; vendor=%s", appFilePath, vendorFilePath);
sandbox.eval(vendorFile, vendorFilePath);
debug("vendor file evaluated");
sandbox.eval(appFile, appFilePath);
debug("app file evaluated");
// Retrieve the application factory from within the sandbox
let AppFactory = sandbox.run(function(ctx) {
return ctx.require('~fastboot/app-factory');
});
// If the application factory couldn't be found, throw an error
if (!AppFactory || typeof AppFactory['default'] !== 'function') {
throw new Error('Failed to load Ember app from ' + appFilePath + ', make sure it was built for FastBoot with the `ember fastboot:build` command.');
}
// Otherwise, return a new `Ember.Application` instance
return AppFactory['default']();
}
/**
* Destroys the app and its sandbox.
*/
destroy() {
if (this.app) {
this.app.destroy();
}
this.sandbox = null;
}
/**
* @private
*
* Creates a new `ApplicationInstance` from the sandboxed `Application`.
*
* @returns {Promise<Ember.ApplicationInstance>} instance
*/
buildAppInstance() {
return this.app.boot().then(function(app) {
debug('building instance');
return app.buildInstance();
});
}
/**
* Creates a new application instance and renders the instance at a specific
* URL, returning a promise that resolves to a {@link Result}. The `Result`
* givesg you access to the rendered HTML as well as metadata about the
* request such as the HTTP status code.
*
* If this call to `visit()` is to service an incoming HTTP request, you may
* provide Node's `ClientRequest` and `ServerResponse` objects as options
* (e.g., the `res` and `req` arguments passed to Express middleware). These
* are provided to the Ember application via the FastBoot service.
*
* @param {string} path the URL path to render, like `/photos/1`
* @param {Object} options
* @param {string} [options.html] the HTML document to insert the rendered app into
* @param {ClientRequest}
* @returns {Promise<Result>} result
*/
visit(path, options) {
let req = options.request;
let res = options.response;
let html = options.html || this.html;
let bootOptions = buildBootOptions();
let fastbootInfo = new FastBootInfo(req, res, this.hostWhitelist);
let doc = bootOptions.document;
let instance;
let result = new Result({
doc: doc,
html: html,
fastbootInfo: fastbootInfo
});
return this.buildAppInstance()
.then(appInstance => {
instance = appInstance;
result.instance = instance;
registerFastBootInfo(fastbootInfo, instance);
return instance.boot(bootOptions);
})
.then(() => instance.visit(path, bootOptions))
.then(() => waitForApp(instance))
.then(() => createShoebox(doc, fastbootInfo))
.catch(error => result.error = error)
.then(() => result._finalize())
.finally(() => instance.destroy());
}
/**
* Given the path to a built Ember app, reads the FastBoot manifest
* information from its `package.json` file.
*/
readPackageJSON(distPath) {
let pkgPath = path.join(distPath, 'package.json');
let file;
try {
file = fs.readFileSync(pkgPath);
} catch (e) {
throw new Error(`Couldn't find ${pkgPath}. You may need to update your version of ember-cli-fastboot.`);
}
let manifest;
let pkg;
try {
pkg = JSON.parse(file);
manifest = pkg.fastboot.manifest;
} catch (e) {
throw new Error(`${pkgPath} was malformed or did not contain a manifest. Ensure that you have a compatible version of ember-cli-fastboot.`);
}
return {
appFile: path.join(distPath, manifest.appFile),
vendorFile: path.join(distPath, manifest.vendorFile),
htmlFile: path.join(distPath, manifest.htmlFile),
moduleWhitelist: pkg.fastboot.moduleWhitelist,
hostWhitelist: pkg.fastboot.hostWhitelist,
appConfig: pkg.fastboot.appConfig
};
}
}
/*
* Builds an object with the options required to boot an ApplicationInstance in
* FastBoot mode.
*/
function buildBootOptions() {
let doc = new SimpleDOM.Document();
let rootElement = doc.body;
return {
isBrowser: false,
document: doc,
rootElement: rootElement
};
}
/*
* Ember apps can manually defer rendering in FastBoot mode if they're waiting
* on something async the router doesn't know about. This function fetches
* that promise for deferred rendering from the app.
*/
function waitForApp(instance) {
let fastbootInfo = instance.lookup('info:-fastboot');
return fastbootInfo.deferredPromise.then(function() {
return instance;
});
}
/*
* Writes the shoebox into the DOM for the browser rendered app to consume.
* Uses a script tag with custom type so that the browser will treat as plain
* text, and not expend effort trying to parse contents of the script tag.
* Each key is written separately so that the browser rendered app can
* parse the specific item at the time it is needed instead of everything
* all at once.
*/
function createShoebox(doc, fastbootInfo) {
let shoebox = fastbootInfo.shoebox;
if (!shoebox) { return RSVP.resolve(); }
for (let key in shoebox) {
if (!shoebox.hasOwnProperty(key)) { continue; }
let value = shoebox[key];
let scriptText = doc.createTextNode(JSON.stringify(value));
let scriptEl = doc.createElement('script');
scriptEl.setAttribute('type', 'fastboot/shoebox');
scriptEl.setAttribute('id', `shoebox-${key}`);
scriptEl.appendChild(scriptText);
doc.body.appendChild(scriptEl);
}
return RSVP.resolve();
}
/*
* Builds a new FastBootInfo instance with the request and response and injects
* it into the application instance.
*/
function registerFastBootInfo(info, instance) {
info.register(instance);
}
module.exports = EmberApp;