@shuvi/service 0.0.1-pre.1

package/lib/bundler/config.js

@@ -0,0 +1,85 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+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 config_1 = require("@shuvi/toolpack/lib/webpack/config");
+const constants_1 = require("../constants");
+function createWebpackConfig({ mode, assetPublicPath, paths, config }, _a) {
+    var { webpackHelpers } = _a, opts = __rest(_a, ["webpackHelpers"]);
+    const dev = mode === 'development';
+    let chain;
+    const srcDirs = [paths.appDir, paths.srcDir, ...(opts.srcDirs || [])];
+    if (opts.node) {
+        chain = config_1.createNodeWebpackChain({
+            buildManifestFilename: constants_1.BUILD_MANIFEST_PATH,
+            dev,
+            env: config.env,
+            mediaFilename: constants_1.BUILD_MEDIA_PATH,
+            name: opts.name,
+            projectRoot: paths.rootDir,
+            srcDirs,
+            publicPath: assetPublicPath,
+            webpackHelpers
+        });
+        chain.output.path(`${paths.buildDir}/${opts.outputDir}`);
+    }
+    else {
+        chain = config_1.createBrowserWebpackChain({
+            analyze: config.analyze,
+            buildManifestFilename: constants_1.BUILD_MANIFEST_PATH,
+            dev,
+            env: config.env,
+            mediaFilename: constants_1.BUILD_MEDIA_PATH,
+            name: opts.name,
+            projectRoot: paths.rootDir,
+            srcDirs,
+            publicPath: assetPublicPath,
+            webpackHelpers
+        });
+        chain.output.path(`${paths.buildDir}/${opts.outputDir}`);
+        chain.optimization.runtimeChunk({ name: constants_1.BUILD_CLIENT_RUNTIME_WEBPACK });
+    }
+    chain.name(opts.name);
+    chain.merge({
+        entry: opts.entry
+    });
+    chain.resolve.alias.set('@shuvi/app', paths.appDir);
+    chain.resolve.alias.set('@shuvi/user', paths.srcDir);
+    chain.resolve.alias.set('@shuvi/services', path_1.default.join(paths.appDir, 'services'));
+    chain.resolve.alias.set('@shuvi/platform-core', path_1.default.dirname(require.resolve('@shuvi/platform-core/package.json')));
+    chain.output.set('filename', ({ chunk }) => {
+        // Use `[name]-[contenthash].js` in production
+        if (!dev) {
+            return `[name]-[contenthash].js`;
+        }
+        return '[name].js';
+    });
+    return chain;
+}
+exports.createWebpackConfig = createWebpackConfig;
+function getClientEntry(_api) {
+    return {
+        [constants_1.BUILD_CLIENT_RUNTIME_MAIN]: ['@shuvi/app/entry.client-wrapper'],
+        [constants_1.BUILD_CLIENT_RUNTIME_POLYFILL]: ['@shuvi/app/core/polyfill']
+    };
+}
+exports.getClientEntry = getClientEntry;
+function getServerEntry(_api) {
+    return {
+        [constants_1.BUILD_SERVER_FILE_SERVER]: ['@shuvi/app/entry.server']
+    };
+}
+exports.getServerEntry = getServerEntry;

package/lib/bundler/index.d.ts

@@ -0,0 +1,2 @@
+export { BundlerResult } from './runCompiler';
+export { getBundler } from './bundler';

package/lib/bundler/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var bundler_1 = require("./bundler");
+exports.getBundler = bundler_1.getBundler;

package/lib/bundler/runCompiler.d.ts

@@ -0,0 +1,7 @@
+import { Compiler, MultiCompiler } from 'webpack';
+import type webpack from 'webpack';
+export declare type BundlerResult = {
+    errors: webpack.StatsError[];
+    warnings: webpack.StatsError[];
+};
+export declare function runCompiler(compiler: Compiler | MultiCompiler): Promise<BundlerResult>;

package/lib/bundler/runCompiler.js

@@ -0,0 +1,43 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function generateStats(result, stat) {
+    const { errors, warnings } = stat.toJson({
+        all: false,
+        warnings: true,
+        errors: true
+    });
+    if (errors && errors.length > 0) {
+        result.errors.push(...errors);
+    }
+    if (warnings && warnings.length > 0) {
+        result.warnings.push(...warnings);
+    }
+    return result;
+}
+function runCompiler(compiler) {
+    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        compiler.run((err, statsOrMultiStats) => {
+            compiler.close(() => {
+                if (err) {
+                    return reject(err);
+                }
+                if (statsOrMultiStats.stats) {
+                    const result = statsOrMultiStats.stats.reduce(generateStats, { errors: [], warnings: [] });
+                    return resolve(result);
+                }
+                const result = generateStats({ errors: [], warnings: [] }, statsOrMultiStats);
+                return resolve(result);
+            });
+        });
+    }));
+}
+exports.runCompiler = runCompiler;

package/lib/cli/build.d.ts

@@ -0,0 +1,8 @@
+import { IConfig } from '../api';
+export interface IBuildOptions {
+    cwd?: string;
+    config?: IConfig;
+    configFile?: string;
+    target?: 'spa' | 'ssr';
+}
+export declare function build(options: IBuildOptions): Promise<void>;

package/lib/cli/build.js

@@ -0,0 +1,90 @@
+"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 fs_extra_1 = __importDefault(require("fs-extra"));
+const formatWebpackMessages_1 = __importDefault(require("@shuvi/toolpack/lib/utils/formatWebpackMessages"));
+const api_1 = require("../api");
+const bundler_1 = require("../bundler/bundler");
+const constants_1 = require("../constants");
+const renderToHTML_1 = require("../lib/renderToHTML");
+const defaultBuildOptions = {
+    target: 'ssr'
+};
+function bundle({ api }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const bundler = bundler_1.getBundler(api);
+        const result = yield bundler.build();
+        const messages = formatWebpackMessages_1.default(result);
+        // If errors exist, only show errors.
+        if (messages.errors.length) {
+            // Only keep the first error. Others are often indicative
+            // of the same problem, but confuse the reader with noise.
+            throw new Error(messages.errors[0]);
+        }
+        // Show warnings if no errors were found.
+        if (messages.warnings.length) {
+            console.log('Compiled with warnings.\n');
+            console.log(messages.warnings.join('\n\n'));
+        }
+    });
+}
+function copyPublicFolder(api) {
+    if (!fs_extra_1.default.existsSync(api.paths.publicDir)) {
+        return;
+    }
+    fs_extra_1.default.copySync(api.paths.publicDir, path_1.default.join(api.paths.buildDir, constants_1.BUILD_CLIENT_DIR), {
+        dereference: true
+    });
+}
+function buildHtml({ api, pathname, filename }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { html } = yield renderToHTML_1.renderToHTML({
+            req: {
+                url: pathname,
+                headers: {}
+            },
+            api
+        });
+        if (html) {
+            yield fs_extra_1.default.writeFile(path_1.default.resolve(api.paths.buildDir, constants_1.BUILD_CLIENT_DIR, filename), html);
+        }
+    });
+}
+function build(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const opts = Object.assign(Object.assign({}, defaultBuildOptions), options);
+        const api = yield api_1.getApi({
+            cwd: opts.cwd,
+            mode: 'production',
+            config: opts.config,
+            configFile: opts.configFile,
+            phase: 'PHASE_PRODUCTION_BUILD'
+        });
+        // generate application
+        yield api.buildApp();
+        // Remove all content but keep the directory so that
+        // if you're in it, you don't end up in Trash
+        fs_extra_1.default.emptyDirSync(api.paths.buildDir);
+        // Merge with the public folder
+        copyPublicFolder(api);
+        // transpile the application
+        yield bundle({ api });
+        if (opts.target === 'spa') {
+            yield buildHtml({ api, pathname: '/', filename: 'index.html' });
+        }
+        api.emitEvent('afterBuild');
+    });
+}
+exports.build = build;

package/lib/config/index.d.ts

@@ -0,0 +1,8 @@
+import { IConfig, IApiConfig } from '../api';
+export interface LoadConfigOptions {
+    rootDir?: string;
+    configFile?: string;
+    overrides?: IConfig;
+}
+export declare const createDefaultConfig: () => IApiConfig;
+export declare function loadConfig({ rootDir, configFile, overrides }?: LoadConfigOptions): IConfig;

package/lib/config/index.js

@@ -0,0 +1,50 @@
+"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 constants_1 = require("../constants");
+const loadDotenvConfig_1 = require("./loadDotenvConfig");
+const deepmerge_1 = require("@shuvi/utils/lib/deepmerge");
+exports.createDefaultConfig = () => ({
+    ssr: true,
+    env: {},
+    rootDir: process.cwd(),
+    outputPath: 'dist',
+    platform: {
+        name: 'web',
+        framework: 'react',
+        target: 'ssr'
+    },
+    publicDir: 'public',
+    publicPath: constants_1.PUBLIC_PATH,
+    router: {
+        history: 'auto'
+    },
+    apiConfig: {
+        prefix: '/api',
+        bodyParser: true
+    }
+});
+function loadConfig({ rootDir = '.', configFile = constants_1.CONFIG_FILE, overrides = {} } = {}) {
+    rootDir = path_1.default.resolve(rootDir);
+    configFile = path_1.default.resolve(rootDir, configFile);
+    // read dotenv so we can get env in shuvi.config.js
+    loadDotenvConfig_1.loadDotenvConfig(rootDir);
+    let fileConfig = {};
+    try {
+        fileConfig = require(configFile);
+        fileConfig = fileConfig.default || fileConfig;
+    }
+    catch (err) {
+        if (err.message.indexOf(`Cannot find module '${configFile}'`) < 0) {
+            throw err;
+        }
+        else if (configFile !== path_1.default.resolve(rootDir, constants_1.CONFIG_FILE)) {
+            console.warn('Config file not found: ' + configFile);
+        }
+    }
+    return deepmerge_1.deepmerge({ rootDir }, fileConfig, overrides);
+}
+exports.loadConfig = loadConfig;

package/lib/config/loadDotenvConfig.d.ts

@@ -0,0 +1 @@
+export declare const loadDotenvConfig: (dir: string) => void;

package/lib/config/loadDotenvConfig.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+const dotenv_expand_1 = __importDefault(require("dotenv-expand"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.loadDotenvConfig = (dir) => {
+    const mode = process.env.NODE_ENV;
+    // Priority top to bottom
+    const dotenvFiles = [
+        `.env.${mode}.local`,
+        `.env.local`,
+        `.env.${mode}`,
+        '.env'
+    ];
+    let envsFromDotEnv = {};
+    for (const envFile of dotenvFiles) {
+        const dotEnvPath = path_1.default.join(dir, envFile);
+        try {
+            const stats = fs_1.default.statSync(dotEnvPath);
+            if (!stats.isFile()) {
+                continue;
+            }
+            const contents = fs_1.default.readFileSync(dotEnvPath, 'utf8');
+            try {
+                let result = {};
+                result.parsed = dotenv_1.default.parse(contents);
+                // dotenvExpand will not replace env that is already saved in process.env
+                // https://github.com/motdotla/dotenv-expand/blob/de9e5cb0215495452f475f5be4dea1580b8217cd/lib/main.js#L22
+                result = dotenv_expand_1.default(result);
+                if (result.parsed) {
+                    console.log(`Loaded env from ${path_1.default.join(dir, envFile)}`);
+                    envsFromDotEnv = Object.assign(Object.assign({}, envsFromDotEnv), result.parsed);
+                }
+            }
+            catch (err) {
+                console.error(`Failed to load env from ${path_1.default.join(dir, envFile)}`, err);
+            }
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw new Error(`Failed to load env from ${envFile}\n${err}`);
+            }
+        }
+    }
+    Object.assign(process.env, envsFromDotEnv);
+};

package/lib/constants.d.ts

@@ -0,0 +1,14 @@
+export * from '@shuvi/shared/lib/constants';
+export declare const PUBLIC_PATH: string;
+export declare const BUILD_MANIFEST_PATH = "build-manifest.json";
+export declare const BUILD_MEDIA_PATH = "static/media/[name].[hash:8].[ext]";
+export declare const BUILD_CLIENT_DIR = "client";
+export declare const BUILD_CLIENT_RUNTIME_MAIN = "static/runtime/main";
+export declare const BUILD_CLIENT_RUNTIME_WEBPACK = "static/runtime/webpack";
+export declare const BUILD_CLIENT_RUNTIME_POLYFILL = "static/runtime/polyfill";
+export declare const BUILD_SERVER_DIR = "server";
+export declare const BUILD_SERVER_FILE_SERVER = "server";
+export declare const PHASE_PRODUCTION_BUILD = "PHASE_PRODUCTION_BUILD";
+export declare const PHASE_PRODUCTION_SERVER = "PHASE_PRODUCTION_SERVER";
+export declare const PHASE_DEVELOPMENT_SERVER = "PHASE_DEVELOPMENT_SERVER";
+export declare const PHASE_INSPECT_WEBPACK = "PHASE_INSPECT_WEBPACK";

package/lib/constants.js

@@ -0,0 +1,20 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("@shuvi/shared/lib/constants");
+__export(require("@shuvi/shared/lib/constants"));
+exports.PUBLIC_PATH = `${constants_1.PATH_PREFIX}/`;
+exports.BUILD_MANIFEST_PATH = 'build-manifest.json';
+exports.BUILD_MEDIA_PATH = 'static/media/[name].[hash:8].[ext]';
+exports.BUILD_CLIENT_DIR = 'client';
+exports.BUILD_CLIENT_RUNTIME_MAIN = `static/runtime/main`;
+exports.BUILD_CLIENT_RUNTIME_WEBPACK = `static/runtime/webpack`;
+exports.BUILD_CLIENT_RUNTIME_POLYFILL = `static/runtime/polyfill`;
+exports.BUILD_SERVER_DIR = 'server';
+exports.BUILD_SERVER_FILE_SERVER = `server`;
+exports.PHASE_PRODUCTION_BUILD = 'PHASE_PRODUCTION_BUILD';
+exports.PHASE_PRODUCTION_SERVER = 'PHASE_PRODUCTION_SERVER';
+exports.PHASE_DEVELOPMENT_SERVER = 'PHASE_DEVELOPMENT_SERVER';
+exports.PHASE_INSPECT_WEBPACK = 'PHASE_INSPECT_WEBPACK';

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export { shuvi, Shuvi } from './shuvi';
+export { IApi, Api, getApi, PluginApi, IApiConfig, IConfig } from './api';
+export { ProjectBuilder } from './project';
+export * from './types';
+export { BUNDLER_TARGET_CLIENT, BUNDLER_TARGET_SERVER, IDENTITY_RUNTIME_PUBLICPATH, PHASE_PRODUCTION_BUILD, PHASE_PRODUCTION_SERVER, PHASE_DEVELOPMENT_SERVER, PHASE_INSPECT_WEBPACK } from './constants';

package/lib/index.js

@@ -0,0 +1,21 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var shuvi_1 = require("./shuvi");
+exports.shuvi = shuvi_1.shuvi;
+exports.Shuvi = shuvi_1.Shuvi;
+var api_1 = require("./api");
+exports.getApi = api_1.getApi;
+var project_1 = require("./project");
+exports.ProjectBuilder = project_1.ProjectBuilder;
+__export(require("./types"));
+var constants_1 = require("./constants");
+exports.BUNDLER_TARGET_CLIENT = constants_1.BUNDLER_TARGET_CLIENT;
+exports.BUNDLER_TARGET_SERVER = constants_1.BUNDLER_TARGET_SERVER;
+exports.IDENTITY_RUNTIME_PUBLICPATH = constants_1.IDENTITY_RUNTIME_PUBLICPATH;
+exports.PHASE_PRODUCTION_BUILD = constants_1.PHASE_PRODUCTION_BUILD;
+exports.PHASE_PRODUCTION_SERVER = constants_1.PHASE_PRODUCTION_SERVER;
+exports.PHASE_DEVELOPMENT_SERVER = constants_1.PHASE_DEVELOPMENT_SERVER;
+exports.PHASE_INSPECT_WEBPACK = constants_1.PHASE_INSPECT_WEBPACK;

package/lib/lib/apiRouteHandler.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="node" />
+import { IncomingMessage, ServerResponse } from 'http';
+import { IParams, ParsedQuery } from '@shuvi/router';
+export interface IResponse extends ServerResponse {
+}
+export interface IRequest extends IncomingMessage {
+    url: string;
+    pathname: string;
+    query: ParsedQuery;
+    params: IParams;
+}
+export interface IApiReq {
+    pathname: string;
+    query: ParsedQuery;
+    params: IParams;
+    cookies: {
+        [key: string]: string;
+    };
+    body?: {
+        [key: string]: any;
+    };
+}
+export declare type IApiRequest = IRequest & IApiReq;
+declare type Send<T> = (body: T) => void;
+declare type IApiRes<T = any> = {
+    send: Send<T>;
+    json: Send<T>;
+    status: (statusCode: number) => IResponse;
+    redirect(url: string): IResponse;
+    redirect(status: number, url: string): IResponse;
+};
+export declare type IApiResponse<T = any> = ServerResponse & IApiRes<T>;
+export declare type IApiRequestHandler<T = any> = (req: IApiRequest, res: IApiResponse<T>) => void | Promise<void>;
+export declare function apiRouteHandler(req: IRequest, res: IResponse, resolver: IApiRequestHandler, apiRoutesConfig: any): Promise<void>;
+/**
+ * Parse incoming message like `json` or `urlencoded`
+ * @param req request object
+ */
+export declare function parseBody(req: IRequest, limit: string | number): Promise<any>;
+/**
+ * Parse cookies from `req` header
+ * @param req request object
+ */
+export declare function getCookieParser(req: IncomingMessage): {
+    [key: string]: string;
+};
+/**
+ *
+ * @param res response object
+ * @param statusCode `HTTP` status code of response
+ */
+export declare function sendStatusCode(res: IResponse, statusCode: number): IResponse;
+/**
+ *
+ * @param res response object
+ * @param [statusOrUrl] `HTTP` status code of redirect
+ * @param url URL of redirect
+ */
+export declare function redirect(res: IResponse, statusOrUrl: string | number, url?: string): IResponse;
+/**
+ * Send `any` body to response
+ * @param req request object
+ * @param res response object
+ * @param body of response
+ */
+export declare function sendData(req: IRequest, res: IResponse, body: any): void;
+/**
+ * Send `JSON` object
+ * @param res response object
+ * @param jsonBody of data
+ */
+export declare function sendJson(req: IRequest, res: IResponse, jsonBody: any): void;
+/**
+ * Custom error class
+ */
+export declare class ApiError extends Error {
+    readonly statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+export {};