@shuvi/service 0.0.1-pre.1

package/lib/api/api.d.ts

@@ -0,0 +1,75 @@
+import { IApiConfig, IConfig, IApi, IApiRouteConfig, IUserRouteConfig, IPaths, IShuviMode, IPhase } from './types';
+import { Bundler } from '../types/bundler';
+import * as Runtime from '../types/runtime';
+import { UserModule, TargetModule, FileOptions } from '../project';
+import { Hookable } from '@shuvi/hook';
+import { IBuiltResource } from './types';
+import { Server } from '../server';
+import { PluginApi } from './pluginApi';
+interface IApiOPtions {
+    cwd?: string;
+    mode?: IShuviMode;
+    config?: IConfig;
+    configFile?: string;
+    phase?: IPhase;
+}
+declare class Api extends Hookable implements IApi {
+    private _cwd;
+    private _mode;
+    private _userConfig?;
+    private _config;
+    private _configFile?;
+    private _paths;
+    private _projectBuilder;
+    private _server;
+    private _resources;
+    private _routes;
+    private _presetPlugins;
+    private _plugins;
+    private _presets;
+    private _pluginApi;
+    private _phase;
+    private _platform;
+    helpers: IApi['helpers'];
+    constructor({ cwd, mode, config, configFile, phase }: IApiOPtions);
+    get mode(): IShuviMode;
+    get phase(): IPhase;
+    get config(): IApiConfig;
+    get paths(): IPaths;
+    get platform(): Runtime.IRuntime<unknown>;
+    initConfig(): void;
+    init(): Promise<void>;
+    get server(): Server;
+    get assetPublicPath(): string;
+    get resources(): IBuiltResource;
+    get clientManifest(): Bundler.IManifest;
+    setRuntimeConfigContent(content: string | null): void;
+    setUserModule(userModule: Partial<UserModule>): void;
+    setPlatformModule(module: string): void;
+    setRoutes(routes: IUserRouteConfig[]): Promise<void>;
+    getRoutes(): IUserRouteConfig[];
+    setApiRoutes(apiRoutes: IApiRouteConfig[]): Promise<void>;
+    removeBuiltFiles(): void;
+    buildApp(): Promise<void>;
+    addResoure(identifier: string, loader: () => any): void;
+    addEntryCode(content: string): void;
+    setEntryWrapperContent(content: string): void;
+    addAppFile(options: FileOptions): void;
+    addAppExport(source: string, exported: string): void;
+    addAppService(source: string, exported: string, filepath: string): void;
+    addAppPolyfill(file: string): void;
+    setClientModule(module: TargetModule): void;
+    setServerModule(module: TargetModule): void;
+    addRuntimePlugin(name: string, runtimePlugin: string): void;
+    getAssetPublicUrl(...paths: string[]): string;
+    resolveAppFile(...paths: string[]): string;
+    resolveUserFile(...paths: string[]): string;
+    resolveBuildFile(...paths: string[]): string;
+    resolvePublicFile(...paths: string[]): string;
+    destory(): Promise<void>;
+    getPluginApi(): PluginApi;
+    private _initPresetsAndPlugins;
+    private _initPreset;
+}
+export { Api };
+export declare function getApi({ cwd, mode, config, configFile, phase }: IApiOPtions): Promise<Api>;

package/lib/api/api.js

@@ -0,0 +1,370 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const project_1 = require("../project");
+const string_1 = require("@shuvi/utils/lib/string");
+const deepmerge_1 = require("@shuvi/utils/lib/deepmerge");
+const invariant_1 = __importDefault(require("@shuvi/utils/lib/invariant"));
+const hook_1 = require("@shuvi/hook");
+const runtimeConfig_1 = require("../lib/runtimeConfig");
+const routes_1 = require("../lib/routes");
+const apiRoutes_1 = require("../lib/apiRoutes");
+const constants_1 = require("../constants");
+const config_1 = require("../config");
+const server_1 = require("../server");
+const setupApp_1 = require("./setupApp");
+const initCoreResource_1 = require("./initCoreResource");
+const plugin_1 = require("./plugin");
+const pluginApi_1 = require("./pluginApi");
+const paths_1 = require("./paths");
+const rimraf_1 = __importDefault(require("rimraf"));
+const getPlatform_1 = __importDefault(require("../lib/getPlatform"));
+const ServiceModes = ['development', 'production'];
+class Api extends hook_1.Hookable {
+    constructor({ cwd, mode, config, configFile, phase }) {
+        super();
+        this._resources = {};
+        this._routes = [];
+        this._presetPlugins = [];
+        if (mode) {
+            this._mode = mode;
+        }
+        else if (ServiceModes.includes(process.env.NODE_ENV)) {
+            this._mode = process.env.NODE_ENV;
+        }
+        else {
+            this._mode = 'production';
+        }
+        this._cwd = path_1.default.resolve(cwd || '.');
+        this._configFile = configFile;
+        this._userConfig = config;
+        this.helpers = { fileSnippets: project_1.fileSnippets };
+        if (phase) {
+            this._phase = phase;
+        }
+        else {
+            if (this._mode === 'development') {
+                this._phase = 'PHASE_DEVELOPMENT_SERVER';
+            }
+            else {
+                this._phase = 'PHASE_PRODUCTION_SERVER';
+            }
+        }
+        this.initConfig();
+        this._platform = getPlatform_1.default(this.config.platform.name);
+    }
+    get mode() {
+        return this._mode;
+    }
+    get phase() {
+        return this._phase;
+    }
+    get config() {
+        return this._config;
+    }
+    get paths() {
+        return this._paths;
+    }
+    get platform() {
+        return this._platform;
+    }
+    initConfig() {
+        const configFromFile = config_1.loadConfig({
+            rootDir: this._cwd,
+            configFile: this._configFile,
+            overrides: this._userConfig
+        });
+        this._config = deepmerge_1.deepmerge(config_1.createDefaultConfig(), configFromFile);
+        const { ssr, router: { history } } = this._config;
+        // ensure apiRouteConfigPrefix starts with '/'
+        const apiRouteConfigPrefix = this._config.apiConfig.prefix;
+        if (apiRouteConfigPrefix) {
+            this._config.apiConfig.prefix = path_1.default.resolve('/', apiRouteConfigPrefix);
+        }
+        // set history to a specific value
+        if (history === 'auto') {
+            this._config.router.history = ssr ? 'browser' : 'hash';
+        }
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._projectBuilder = new project_1.ProjectBuilder({
+                static: this.mode === 'production'
+            });
+            yield this._initPresetsAndPlugins();
+            initCoreResource_1.initCoreResource(this);
+            // TODO?: move into application
+            if (typeof this._config.runtimeConfig === 'object') {
+                runtimeConfig_1.setRuntimeConfig(this._config.runtimeConfig);
+            }
+        });
+    }
+    get server() {
+        if (!this._server) {
+            this._server = new server_1.Server();
+        }
+        return this._server;
+    }
+    get assetPublicPath() {
+        let prefix = this.mode === 'development'
+            ? constants_1.PUBLIC_PATH
+            : this.config.publicPath || constants_1.PUBLIC_PATH;
+        if (!prefix.endsWith('/')) {
+            prefix += '/';
+        }
+        return prefix;
+    }
+    get resources() {
+        return this._resources;
+    }
+    get clientManifest() {
+        return this._resources.clientManifest;
+    }
+    setRuntimeConfigContent(content) {
+        this._projectBuilder.setRuntimeConfigContent(content);
+    }
+    setUserModule(userModule) {
+        this._projectBuilder.setUserModule(userModule);
+    }
+    setPlatformModule(module) {
+        this._projectBuilder.setPlatformModule(module);
+    }
+    setRoutes(routes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            routes = yield this.callHook({
+                name: 'app:routes',
+                initialValue: routes
+            });
+            routes = routes_1.normalizeRoutes(routes, {
+                componentDir: this.paths.pagesDir
+            });
+            routes.push({
+                path: ':other(.*)',
+                component: this.resolveAppFile('core', '404'),
+                name: constants_1.ROUTE_NOT_FOUND_NAME
+            });
+            this._routes = routes;
+            const serialized = routes_1.serializeRoutes(routes);
+            const RoutesContent = `export default ${serialized}`;
+            this._projectBuilder.setRoutesContent(RoutesContent);
+        });
+    }
+    getRoutes() {
+        return this._routes;
+    }
+    setApiRoutes(apiRoutes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            apiRoutes = apiRoutes_1.normalizeApiRoutes(apiRoutes, {
+                apisDir: this.paths.apisDir
+            });
+            const { prefix } = this.config.apiConfig || {};
+            const serialized = apiRoutes_1.serializeApiRoutes(apiRoutes, prefix);
+            let content = `export default ${serialized}`;
+            this._projectBuilder.setApiRoutesContent(content);
+        });
+    }
+    removeBuiltFiles() {
+        rimraf_1.default.sync(this.paths.appDir);
+        rimraf_1.default.sync(this.paths.buildDir);
+    }
+    buildApp() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield setupApp_1.setupApp(this);
+            this.removeBuiltFiles();
+            this._projectBuilder.validateCompleteness('api');
+            yield this._projectBuilder.build(this.paths.appDir);
+            this.emitEvent('app:ready');
+        });
+    }
+    addResoure(identifier, loader) {
+        const cacheable = this.mode === 'production';
+        const api = this;
+        // TODO: warn exitsed identifier
+        if (cacheable) {
+            Object.defineProperty(api._resources, identifier, {
+                get() {
+                    const value = loader();
+                    Object.defineProperty(api._resources, identifier, {
+                        value,
+                        enumerable: true,
+                        configurable: false,
+                        writable: false
+                    });
+                    return value;
+                },
+                enumerable: true,
+                configurable: true
+            });
+        }
+        else {
+            Object.defineProperty(this._resources, identifier, {
+                get() {
+                    return loader();
+                },
+                enumerable: true,
+                configurable: false
+            });
+        }
+    }
+    addEntryCode(content) {
+        this._projectBuilder.addEntryCode(content);
+    }
+    setEntryWrapperContent(content) {
+        this._projectBuilder.setEntryWrapperContent(content);
+    }
+    addAppFile(options) {
+        // make addAppFile root as files/
+        options.name = path_1.default.join('files', path_1.default.resolve('/', options.name));
+        this._projectBuilder.addFile(options);
+    }
+    addAppExport(source, exported) {
+        this._projectBuilder.addExport(source, exported);
+    }
+    addAppService(source, exported, filepath) {
+        // make addAppService root as services/
+        const targetPath = path_1.default.join('services', path_1.default.resolve('/', filepath));
+        this._projectBuilder.addService(source, exported, targetPath);
+    }
+    addAppPolyfill(file) {
+        this._projectBuilder.addPolyfill(file);
+    }
+    setClientModule(module) {
+        this._projectBuilder.setClientModule(module);
+    }
+    setServerModule(module) {
+        this._projectBuilder.setServerModule(module);
+    }
+    addRuntimePlugin(name, runtimePlugin) {
+        this._projectBuilder.addRuntimePlugin(name, runtimePlugin);
+    }
+    getAssetPublicUrl(...paths) {
+        return string_1.joinPath(this.assetPublicPath, ...paths);
+    }
+    resolveAppFile(...paths) {
+        return string_1.joinPath(this.paths.appDir, ...paths);
+    }
+    resolveUserFile(...paths) {
+        return string_1.joinPath(this.paths.srcDir, ...paths);
+    }
+    resolveBuildFile(...paths) {
+        return string_1.joinPath(this.paths.buildDir, ...paths);
+    }
+    resolvePublicFile(...paths) {
+        return string_1.joinPath(this.paths.publicDir, ...paths);
+    }
+    destory() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._server) {
+                yield this._server.close();
+            }
+            yield this._projectBuilder.stopBuild();
+            yield this.callHook('destroy');
+        });
+    }
+    getPluginApi() {
+        if (!this._pluginApi) {
+            this._pluginApi = pluginApi_1.createPluginApi(this);
+        }
+        return this._pluginApi;
+    }
+    _initPresetsAndPlugins() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { phase, _config: config } = this;
+            // init presets
+            this._presets = plugin_1.resolvePresets(config.presets || [], {
+                dir: config.rootDir
+            });
+            for (const preset of this._presets) {
+                this._initPreset(preset);
+            }
+            // init plugins
+            this._plugins = plugin_1.resolvePlugins(this._config.plugins || [], {
+                dir: this._config.rootDir
+            });
+            const allPlugins = this._presetPlugins.concat(this._plugins);
+            let runPlugins = function runNext(next, cur = () => void 0) {
+                if (next) {
+                    return (n) => runNext(n, () => {
+                        cur();
+                        next();
+                    });
+                }
+                return cur();
+            };
+            for (const plugin of allPlugins) {
+                const pluginInst = plugin.get();
+                if (typeof pluginInst.modifyConfig === 'function') {
+                    this.tap('getConfig', {
+                        name: 'pluginModifyConfig',
+                        fn(config) {
+                            pluginInst.modifyConfig(config, phase);
+                            return config;
+                        }
+                    });
+                }
+                runPlugins = runPlugins(() => {
+                    pluginInst.apply(this.getPluginApi());
+                });
+            }
+            // prepare all properties befofre run plugins, so plugin can use all api of Api
+            this._config = yield this.callHook({
+                name: 'getConfig',
+                initialValue: config
+            });
+            // do not allow to modify config
+            Object.freeze(this._config);
+            this._paths = paths_1.getPaths({
+                rootDir: this._config.rootDir,
+                outputPath: this._config.outputPath,
+                publicDir: this._config.publicDir
+            });
+            // do not allow to modify paths
+            Object.freeze(this._paths);
+            // Runtime installation need to be executed before initializing presets and plugins
+            // to make sure shuvi entry file at the top.
+            //this.runtime.install(this);
+            this.platform.install(this);
+            runPlugins();
+        });
+    }
+    _initPreset(preset) {
+        const { id, get: getPreset } = preset;
+        const { presets, plugins } = getPreset()(this.getPluginApi());
+        if (presets) {
+            invariant_1.default(Array.isArray(presets), `presets returned from preset ${id} must be Array.`);
+            const resolvedPresets = plugin_1.resolvePresets(presets, {
+                dir: this._config.rootDir
+            });
+            for (const preset of resolvedPresets) {
+                this._initPreset(preset);
+            }
+        }
+        if (plugins) {
+            invariant_1.default(Array.isArray(plugins), `presets returned from preset ${id} must be Array.`);
+            this._presetPlugins.push(...plugin_1.resolvePlugins(plugins, {
+                dir: this._config.rootDir
+            }));
+        }
+    }
+}
+exports.Api = Api;
+function getApi({ cwd, mode, config, configFile, phase }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const api = new Api({ cwd, mode, config, configFile, phase });
+        yield api.init();
+        return api;
+    });
+}
+exports.getApi = getApi;

package/lib/api/index.d.ts

@@ -0,0 +1,6 @@
+import type { Api } from './api';
+import { getApi } from './api';
+import { PluginApi } from './pluginApi';
+export type { Api };
+export { getApi, PluginApi };
+export * from './types';

package/lib/api/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("./api");
+exports.getApi = api_1.getApi;

package/lib/api/initCoreResource.d.ts

@@ -0,0 +1,2 @@
+import { Api } from './api';
+export declare function initCoreResource(api: Api): void;

package/lib/api/initCoreResource.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const viewTemplate_1 = require("../lib/viewTemplate");
+const constants_1 = require("../constants");
+function resolveServerDist(api, name) {
+    const manifest = api.resources.serverManifest;
+    return path_1.default.join(api.paths.buildDir, constants_1.BUILD_SERVER_DIR, manifest.bundles[name]);
+}
+function resolveDocument(api) {
+    const customDoc = api.resolveUserFile('document.ejs');
+    if (fs_extra_1.default.existsSync(customDoc)) {
+        return customDoc;
+    }
+    return require.resolve('@shuvi/platform-core/template/document.ejs');
+}
+function initCoreResource(api) {
+    api.addResoure('clientManifest', () => require(path_1.default.join(api.paths.buildDir, constants_1.BUILD_CLIENT_DIR, constants_1.BUILD_MANIFEST_PATH)));
+    api.addResoure('serverManifest', () => require(path_1.default.join(api.paths.buildDir, constants_1.BUILD_SERVER_DIR, constants_1.BUILD_MANIFEST_PATH)));
+    api.addResoure('server', () => require(resolveServerDist(api, constants_1.BUILD_SERVER_FILE_SERVER)));
+    api.addResoure('documentTemplate', () => viewTemplate_1.parseTemplateFile(resolveDocument(api)));
+}
+exports.initCoreResource = initCoreResource;

package/lib/api/paths.d.ts

@@ -0,0 +1,8 @@
+import { IPaths } from '.';
+interface IPathsOpts {
+    rootDir: string;
+    outputPath: string;
+    publicDir: string;
+}
+export declare function getPaths(opts: IPathsOpts): IPaths;
+export {};

package/lib/api/paths.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const constants_1 = require("@shuvi/shared/lib/constants");
+function getPaths(opts) {
+    const { rootDir, outputPath, publicDir } = opts;
+    const toAbsolute = (p) => (path_1.isAbsolute(p) ? p : path_1.join(rootDir, p));
+    const srcDir = toAbsolute('src');
+    const srcChildDir = (p) => path_1.join(srcDir, p);
+    return {
+        rootDir,
+        srcDir,
+        pagesDir: srcChildDir('pages'),
+        apisDir: srcChildDir('apis'),
+        appDir: toAbsolute(`.${constants_1.NAME}/app`),
+        buildDir: toAbsolute(outputPath),
+        publicDir: toAbsolute(publicDir)
+    };
+}
+exports.getPaths = getPaths;

package/lib/api/plugin.d.ts

@@ -0,0 +1,6 @@
+import { IPluginConfig, IPresetConfig, IPlugin, IPreset } from '.';
+export interface ResolvePluginOptions {
+    dir: string;
+}
+export declare function resolvePlugins(plugins: IPluginConfig[], options: ResolvePluginOptions): IPlugin[];
+export declare function resolvePresets(presets: IPresetConfig[], options: ResolvePluginOptions): IPreset[];

package/lib/api/plugin.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const resolve_1 = __importDefault(require("@shuvi/utils/lib/resolve"));
+let uid = 0;
+function resolvePlugin(pluginConfig, resolveOptions) {
+    let pluginPath;
+    let name;
+    let options;
+    if (Array.isArray(pluginConfig)) {
+        if (pluginConfig.length === 2) {
+            pluginPath = pluginConfig[0];
+            const nameOrOption = pluginConfig[1];
+            if (typeof nameOrOption === 'string') {
+                name = nameOrOption;
+                options = {};
+            }
+            else {
+                options = nameOrOption;
+                name = '';
+            }
+        }
+        else {
+            [pluginPath, options = {}, name = ''] = pluginConfig;
+        }
+    }
+    else if (typeof pluginConfig === 'string') {
+        pluginPath = pluginConfig;
+        name = '';
+        options = {};
+    }
+    else if (typeof pluginConfig === 'function') {
+        return {
+            id: `InlinePlugin${uid++}`,
+            get: () => ({
+                apply(api) {
+                    pluginConfig(api);
+                }
+            })
+        };
+    }
+    else {
+        throw new Error(`Plugin must be one of type [string, array, function]`);
+    }
+    pluginPath = resolve_1.default.sync(pluginPath, { basedir: resolveOptions.dir });
+    const id = name ? `${pluginPath}@${name}` : pluginPath;
+    let pluginInst;
+    let plugin = require(pluginPath);
+    plugin = plugin.default || plugin;
+    if (plugin.prototype && typeof plugin.prototype.apply === 'function') {
+        // class plugin
+        pluginInst = new plugin(options);
+    }
+    else {
+        // function plugin
+        pluginInst = {
+            apply(...args) {
+                plugin(...args);
+            }
+        };
+    }
+    return {
+        id,
+        get: () => pluginInst
+    };
+}
+function resolvePreset(presetConfig, resolveOptions) {
+    let presetPath;
+    let options;
+    if (Array.isArray(presetConfig)) {
+        presetPath = presetConfig[0];
+        const nameOrOption = presetConfig[1];
+        if (typeof nameOrOption === 'string') {
+            options = {};
+        }
+        else {
+            options = nameOrOption;
+        }
+    }
+    else if (typeof presetConfig === 'string') {
+        presetPath = presetConfig;
+        options = {};
+    }
+    else {
+        throw new Error(`Plugin must be one of type [string, array, function]`);
+    }
+    presetPath = resolve_1.default.sync(presetPath, { basedir: resolveOptions.dir });
+    const id = presetPath;
+    let preset = require(presetPath);
+    preset = preset.default || preset;
+    const presetFn = (api) => {
+        return preset(api, options);
+    };
+    return {
+        id,
+        get: () => presetFn
+    };
+}
+function resolvePlugins(plugins, options) {
+    return plugins.map(plugin => resolvePlugin(plugin, options));
+}
+exports.resolvePlugins = resolvePlugins;
+function resolvePresets(presets, options) {
+    return presets.map(preset => resolvePreset(preset, options));
+}
+exports.resolvePresets = resolvePresets;

package/lib/api/pluginApi.d.ts

@@ -0,0 +1,29 @@
+import { Api, IApi } from '.';
+declare class PluginApi implements IApi {
+    mode: any;
+    paths: any;
+    config: any;
+    phase: any;
+    helpers: any;
+    clientManifest: any;
+    tap: any;
+    callHook: any;
+    on: any;
+    emitEvent: any;
+    addEntryCode: any;
+    addAppFile: any;
+    addAppExport: any;
+    addAppService: any;
+    addAppPolyfill: any;
+    addRuntimePlugin: any;
+    setPlatformModule: any;
+    setClientModule: any;
+    setServerModule: any;
+    resolveAppFile: any;
+    resolveUserFile: any;
+    resolveBuildFile: any;
+    resolvePublicFile: any;
+    getAssetPublicUrl: any;
+}
+export type { PluginApi };
+export declare function createPluginApi(api: Api): PluginApi;