vona 1.0.0 → 5.0.7

package/dist/lib/utils/util.js

@@ -0,0 +1,445 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppUtil = void 0;
+const ModuleInfo = __importStar(require("@cabloy/module-info"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const is_type_of_1 = __importDefault(require("is-type-of"));
+const security = __importStar(require("egg-security"));
+const index_js_1 = require("../../types/index.js");
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+const resource_js_1 = require("../core/resource.js");
+const compose_1 = require("@cabloy/compose");
+const __EnvTests = ['unittest', 'test'];
+class AppUtil extends beanSimple_js_1.BeanSimple {
+    instanceStarted(subdomain) {
+        return this.app.meta.appReadyInstances && this.app.meta.appReadyInstances[subdomain];
+    }
+    combineFetchPath(moduleName, arg) {
+        if (arg.substr(0, 2) === '//')
+            return arg.substr(1);
+        if (arg.charAt(0) === '/')
+            return `/api${arg}`;
+        const moduleInfo = typeof moduleName === 'string' ? ModuleInfo.parseInfo(moduleName) : moduleName;
+        if (!moduleInfo)
+            throw new Error('invalid url');
+        return `/api/${moduleInfo.url}/${arg}`;
+    }
+    combineApiPath(moduleName, arg) {
+        if (arg.charAt(0) === '/')
+            return arg;
+        const moduleInfo = typeof moduleName === 'string' ? ModuleInfo.parseInfo(moduleName) : moduleName;
+        if (!moduleInfo)
+            throw new Error('invalid url');
+        return `/${moduleInfo.url}/${arg}`;
+    }
+    combineQueries(url, queries) {
+        //
+        if (!queries)
+            return url;
+        //
+        let str = '';
+        for (const key of Object.keys(queries)) {
+            str += `${key}=${encodeURIComponent(queries[key])}&`;
+        }
+        if (str) {
+            str = str.substr(0, str.length - 1);
+        }
+        if (!str)
+            return url;
+        //
+        if (!url)
+            return '?' + str;
+        //
+        const pos = url.indexOf('?');
+        if (pos === -1)
+            return `${url}?${str}`;
+        if (pos === url.length - 1)
+            return `${url}${str}`;
+        return `${url}&${str}`;
+    }
+    createError(data, returnObject) {
+        const error = returnObject ? {} : new Error();
+        error.code = data.code !== undefined ? data.code : 500;
+        if (data.message && typeof data.message === 'object') {
+            error.message = JSON.stringify(data.message, null, 2);
+        }
+        else {
+            error.message = data.message;
+        }
+        if (data.stack)
+            error.stack = data.stack;
+        if (data.name)
+            error.name = data.name;
+        if (data.errno)
+            error.errno = data.errno;
+        if (data.sqlMessage)
+            error.sqlMessage = data.sqlMessage;
+        if (data.sqlState)
+            error.sqlState = data.sqlState;
+        if (data.index)
+            error.index = data.index;
+        if (data.sql)
+            error.sql = data.sql;
+        return error;
+    }
+    async monkeyModule(ebAppMonkey, ebModulesMonkey, monkeyName, moduleTarget, ...monkeyData) {
+        // self: main
+        if (moduleTarget && moduleTarget.mainInstance && moduleTarget.mainInstance[monkeyName]) {
+            await moduleTarget.mainInstance[monkeyName](...monkeyData);
+        }
+        // module monkey
+        for (const key in ebModulesMonkey) {
+            const moduleMonkey = ebModulesMonkey[key];
+            if (moduleMonkey.monkeyInstance && moduleMonkey.monkeyInstance[monkeyName]) {
+                if (moduleTarget === undefined) {
+                    // @ts-ignore ignore
+                    await moduleMonkey.monkeyInstance[monkeyName](...monkeyData);
+                }
+                else {
+                    // @ts-ignore ignore
+                    await moduleMonkey.monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
+                }
+            }
+        }
+        // app monkey
+        if (ebAppMonkey && ebAppMonkey[monkeyName]) {
+            if (moduleTarget === undefined) {
+                await ebAppMonkey[monkeyName](...monkeyData);
+            }
+            else {
+                await ebAppMonkey[monkeyName](moduleTarget, ...monkeyData);
+            }
+        }
+    }
+    getWhiteListCors(ctx) {
+        let whiteListCors;
+        const _config = ctx.config.module('a-base');
+        const _whiteList = (_config && _config.cors && _config.cors.whiteList) || [];
+        if (!Array.isArray(_whiteList)) {
+            whiteListCors = _whiteList.split(',');
+        }
+        else {
+            whiteListCors = _whiteList.concat();
+        }
+        // inherits from jsonp
+        let _whiteListJsonp = _config && _config.jsonp && _config.jsonp.whiteList;
+        if (_whiteListJsonp) {
+            if (!Array.isArray(_whiteListJsonp)) {
+                _whiteListJsonp = _whiteListJsonp.split(',');
+            }
+            whiteListCors = whiteListCors.concat(_whiteListJsonp);
+        }
+        // hostSelf
+        const hostSelf = ctx.bean.base.getAbsoluteUrl();
+        if (hostSelf) {
+            whiteListCors.push(hostSelf);
+        }
+        // ok
+        return whiteListCors;
+    }
+    isSafeDomain(ctx, origin) {
+        // origin is {protocol}{hostname}{port}...
+        if (!origin || origin === 'null' || origin === null)
+            return true;
+        let parsedUrl;
+        try {
+            parsedUrl = new url_1.URL(origin);
+        }
+        catch (_) {
+            return false;
+        }
+        // whiteList
+        const whiteListCors = this.getWhiteListCors(ctx);
+        if (security.utils.isSafeDomain(parsedUrl.hostname, whiteListCors) ||
+            security.utils.isSafeDomain(origin, whiteListCors)) {
+            return true;
+        }
+        return false;
+    }
+    isNullOrEmptyString(str) {
+        return str === undefined || str === null || str === '';
+    }
+    compose(chains, adapter) {
+        return (0, compose_1.compose)(chains, adapter);
+    }
+    composeAsync(chains, adapter) {
+        return (0, compose_1.composeAsync)(chains, adapter);
+    }
+    async createAnonymousContext({ locale, subdomain, module, instance }) {
+        // url
+        const url = module ? this.combineFetchPath(module, '') : '/api/a/base/';
+        // ctx
+        const ctx = this.app.createAnonymousContext({
+            method: 'post',
+            url,
+        });
+        ctx.req.ctx = ctx;
+        // locale
+        Object.defineProperty(ctx, 'locale', {
+            get() {
+                return locale || this.app.config.i18n.defaultLocale;
+            },
+        });
+        // subdomain
+        Object.defineProperty(ctx, 'subdomain', {
+            get() {
+                return subdomain;
+            },
+        });
+        // instance
+        if (subdomain !== undefined && subdomain !== null) {
+            ctx.instance = await ctx.bean.instance.get({ subdomain });
+            // start instance
+            if (instance) {
+                await ctx.bean.instance.checkAppReadyInstance();
+            }
+        }
+        // ok
+        return ctx;
+    }
+    async executeBean({ locale, subdomain, beanModule, beanFullName, context, fn, transaction, ctxCaller, ctxParent, instance, }) {
+        // ctxModule
+        let ctxModule = beanModule;
+        if (!ctxModule && beanFullName) {
+            const beanOptions = resource_js_1.appResource.getBean(beanFullName);
+            ctxModule = beanOptions?.module;
+        }
+        if (!ctxModule) {
+            ctxModule = ctxCaller?.module?.info?.relativeName || ctxParent?.module?.info?.relativeName;
+        }
+        // ctx
+        const ctx = await this.createAnonymousContext({ locale, subdomain, module: ctxModule, instance });
+        // innerAccess
+        ctx.innerAccess = true;
+        // ctxCaller
+        if (ctxCaller) {
+            // multipart
+            ctx.multipart = function (options) {
+                return ctxCaller.multipart(options);
+            };
+            // delegateProperties
+            delegateProperties(ctx, ctxCaller);
+            // ctxCaller
+            ctx.ctxCaller = ctxCaller;
+        }
+        // ctxParent
+        if (ctxParent) {
+            // delegateProperties
+            delegateProperties(ctx, ctxParent);
+            // dbLevel
+            ctx.dbLevel = (ctxParent.dbLevel || 0) + 1;
+        }
+        // dbLevel
+        if (!ctxCaller && !ctxParent) {
+            ctx.dbLevel = 1;
+        }
+        // bean
+        const bean = beanFullName ? ctx.bean._getBean(beanFullName) : null;
+        if (!bean && beanFullName && !is_type_of_1.default.function(fn)) {
+            throw new Error(`bean not found: ${beanFullName}`);
+        }
+        // execute
+        let res;
+        if (transaction) {
+            res = await (0, index_js_1.Cast)(ctx).transaction.begin(async () => {
+                return await this._executeBeanFn({ fn, ctx, bean, context });
+            });
+        }
+        else {
+            res = await this._executeBeanFn({ fn, ctx, bean, context });
+        }
+        // tail done
+        await ctx.tailDone();
+        // ok
+        return res;
+    }
+    async _executeBeanFn({ fn, ctx, bean, context }) {
+        let res;
+        if (is_type_of_1.default.function(fn)) {
+            res = await fn({ ctx, bean, context });
+        }
+        else {
+            fn = fn || 'execute';
+            if (!bean[fn]) {
+                throw new Error(`bean method not found: ${bean.__beanFullName__}:${fn}`);
+            }
+            res = await bean[fn](context);
+        }
+        return res;
+    }
+    async lock({ subdomain, resource, fn, options, redlock, }) {
+        // resource
+        const _lockResource = `redlock_${this.app.name}:${this.subdomainDesp(subdomain)}:${resource}`;
+        // options
+        const _lockOptions = Object.assign({}, this.app.config.queue.redlock.options, options);
+        // redlock
+        if (!redlock) {
+            redlock = this.app.meta.redlock.create(_lockOptions);
+        }
+        let _lock = await redlock.lock(_lockResource, _lockOptions.lockTTL);
+        // timer
+        let _lockTimer = null;
+        const _lockDone = () => {
+            if (_lockTimer) {
+                clearInterval(_lockTimer);
+                _lockTimer = null;
+            }
+        };
+        _lockTimer = setInterval(() => {
+            _lock
+                .extend(_lockOptions.lockTTL)
+                .then(lock => {
+                _lock = lock;
+            })
+                .catch(err => {
+                this.app.logger.error(err);
+                _lockDone();
+            });
+        }, _lockOptions.lockTTL / 2);
+        try {
+            const res = await fn();
+            _lockDone();
+            await _lock.unlock();
+            return res;
+        }
+        catch (err) {
+            _lockDone();
+            await _lock.unlock();
+            throw err;
+        }
+    }
+    subdomainDesp(subdomain) {
+        if (subdomain === undefined || subdomain === null)
+            return '~';
+        return subdomain || '-';
+    }
+    deprecated(oldUsage, newUsage) {
+        const message = '`'
+            .concat(oldUsage, '` is deprecated and will be removed in a later version. Use `')
+            .concat(newUsage, '` instead');
+        return console.warn(message);
+    }
+    checkGate(gate) {
+        // check none
+        if (!gate)
+            return true;
+        // check env
+        if (!this._checkGateEnv(gate.env))
+            return false;
+        // default
+        return true;
+    }
+    _checkGateEnv(env) {
+        // check none
+        if (!env)
+            return true;
+        if (!Array.isArray(env))
+            env = env.split(',');
+        const bingo = env.some(item => {
+            if (this.app.config.env === item)
+                return true;
+            if (__EnvTests.includes(this.app.config.env) && __EnvTests.includes(item))
+                return true;
+            return false;
+        });
+        if (!bingo)
+            return false;
+        return true;
+    }
+    requireDynamic(file) {
+        if (!file)
+            throw new Error('file should not empty');
+        let instance = require(file);
+        const mtime = this._requireDynamic_getFileTime(file);
+        if (instance.__requireDynamic_mtime === undefined) {
+            instance.__requireDynamic_mtime = mtime;
+        }
+        else if (instance.__requireDynamic_mtime !== mtime) {
+            delete require.cache[require.resolve(file)];
+            instance = require(file);
+            instance.__requireDynamic_mtime = mtime;
+        }
+        return instance;
+    }
+    _requireDynamic_getFileTime(file) {
+        if (!path_1.default.isAbsolute(file))
+            return null;
+        const exists = fs_extra_1.default.pathExistsSync(file);
+        if (!exists)
+            return null;
+        // stat
+        const stat = fs_extra_1.default.statSync(file);
+        return stat.mtime.valueOf();
+    }
+}
+exports.AppUtil = AppUtil;
+function delegateProperties(ctx, ctxCaller) {
+    const req = ctx.req;
+    for (const property of ['cookies', 'session', 'user', 'state']) {
+        delegateProperty(ctx, ctxCaller, property);
+    }
+    for (const property of ['query', 'params', 'headers', 'body']) {
+        delegateProperty(ctx.request, ctxCaller.request, property);
+        if (ctx.request[property])
+            req[property] = ctx.request[property];
+    }
+    if (ctx.session)
+        req.session = ctx.session;
+    // if (ctx.query) req.query = ctx.query;
+    // if (ctx.request.body) req.body = ctx.request.body;
+}
+function delegateProperty(ctx, ctxCaller, property) {
+    const keyMock = `__executeBean__mock__${property}__`;
+    const keyOriginal = `__executeBean__mock__${property}__original__`;
+    if (['cookies', 'session', 'headers'].includes(property)) {
+        ctx[keyOriginal] = ctx[property];
+    }
+    Object.defineProperty(ctx, property, {
+        get() {
+            const value = ctxCaller && ctxCaller[property];
+            if (value)
+                return value;
+            //
+            if (['user', 'body'].includes(property))
+                return value;
+            //
+            if (['cookies', 'session', 'headers'].includes(property)) {
+                return ctx[keyOriginal];
+            }
+            //
+            if (!ctx[keyMock]) {
+                ctx[keyMock] = {};
+            }
+            return ctx[keyMock];
+        },
+    });
+}
+//# sourceMappingURL=util.js.map

package/dist/lib/utils/utilCtx.d.ts

@@ -0,0 +1,34 @@
+import { BeanSimple } from '../bean/beanSimple.js';
+import { VonaContext, PowerPartial } from '../../types/index.js';
+import { IExecuteBeanCallback } from './util.js';
+export declare class CtxUtil extends BeanSimple {
+    runInBackground(scope: any): void;
+    lock({ subdomain, resource, fn, options, redlock }: any): Promise<any>;
+    broadcastEmit({ locale, subdomain, module, broadcastName, data }: any): void;
+    queuePush(info: any): void;
+    queuePushAsync(info: any): Promise<unknown>;
+    _queuePushInfoPrepare(info: any): any;
+    executeBean({ locale, subdomain, beanModule, beanFullName, context, fn, transaction, instance, }: {
+        locale?: string;
+        subdomain?: string;
+        beanModule?: string;
+        beanFullName?: string;
+        context?: any;
+        fn?: IExecuteBeanCallback | string;
+        transaction?: boolean;
+        instance?: boolean;
+    }): Promise<any>;
+    executeBeanIsolate({ locale, subdomain, beanModule, beanFullName, context, fn, transaction, ctxParent, instance, }: {
+        locale?: string;
+        subdomain?: string | null;
+        beanModule?: string;
+        beanFullName?: string;
+        context?: any;
+        fn?: IExecuteBeanCallback | string;
+        transaction?: boolean;
+        ctxParent?: PowerPartial<VonaContext>;
+        instance?: boolean;
+    }): Promise<any>;
+    performAction({ innerAccess, method, url, query, params, headers, body }: any): Promise<any>;
+}
+//# sourceMappingURL=utilCtx.d.ts.map

package/dist/lib/utils/utilCtx.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CtxUtil = void 0;
+const performAction_js_1 = __importDefault(require("./performAction.js"));
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+class CtxUtil extends beanSimple_js_1.BeanSimple {
+    runInBackground(scope) {
+        const ctx = this.ctx;
+        ctx.runInBackground(async () => {
+            await ctx.meta.util.executeBeanIsolate({
+                fn: async ({ ctx }) => {
+                    await scope({ ctx });
+                },
+            });
+        });
+    }
+    async lock({ subdomain, resource, fn, options, redlock }) {
+        const ctx = this.ctx;
+        if (subdomain === undefined)
+            subdomain = ctx.subdomain;
+        return await ctx.app.meta.util.lock({ subdomain, resource, fn, options, redlock });
+    }
+    broadcastEmit({ locale, subdomain, module, broadcastName, data }) {
+        const ctx = this.ctx;
+        ctx.app.meta.broadcast.emit({
+            locale: locale === undefined ? ctx.locale : locale,
+            subdomain: subdomain === undefined ? ctx.subdomain : subdomain,
+            module,
+            broadcastName,
+            data,
+        });
+    }
+    queuePush(info) {
+        const ctx = this.ctx;
+        ctx.app.meta.queue.push(this._queuePushInfoPrepare(info));
+    }
+    async queuePushAsync(info) {
+        const ctx = this.ctx;
+        return await ctx.app.meta.queue.pushAsync(this._queuePushInfoPrepare(info));
+    }
+    _queuePushInfoPrepare(info) {
+        const ctx = this.ctx;
+        const dbLevel = !info.dbLevel ? ctx.dbLevel + 1 : info.dbLevel;
+        const locale = info.locale === undefined ? ctx.locale : info.locale;
+        const subdomain = info.subdomain === undefined ? ctx.subdomain : info.subdomain;
+        // new info
+        info = {
+            ...info,
+            dbLevel,
+            locale,
+            subdomain,
+        };
+        if (!info.ctxParent)
+            info.ctxParent = {};
+        if (!info.ctxParent.request)
+            info.ctxParent.request = {};
+        if (!info.ctxParent.request.headers)
+            info.ctxParent.request.headers = {};
+        // headers
+        const headers = info.ctxParent.request.headers;
+        for (const key of ['x-clientid', 'x-scene']) {
+            if (!headers[key]) {
+                const value = key === 'x-clientid' ? ctx.bean.util.getFrontClientId() : ctx.bean.util.getFrontScene();
+                if (value) {
+                    headers[key] = value;
+                }
+            }
+        }
+        for (const key of ['host', 'origin', 'referer', 'user-agent']) {
+            if (!headers[key]) {
+                const value = ctx.request.headers[key];
+                if (value) {
+                    headers[key] = value;
+                }
+            }
+        }
+        // ok
+        return info;
+    }
+    async executeBean({ locale, subdomain, beanModule, beanFullName, context, fn, transaction, instance, }) {
+        const ctx = this.ctx;
+        return await ctx.app.meta.util.executeBean({
+            locale: locale === undefined ? ctx.locale : locale,
+            subdomain: subdomain === undefined ? ctx.subdomain : subdomain,
+            context,
+            beanModule,
+            beanFullName,
+            transaction,
+            fn,
+            ctxCaller: ctx,
+            instance,
+        });
+    }
+    async executeBeanIsolate({ locale, subdomain, beanModule, beanFullName, context, fn, transaction, ctxParent, instance, }) {
+        const ctx = this.ctx;
+        if (ctxParent) {
+            if (ctxParent.dbLevel === undefined) {
+                ctxParent = {
+                    ...ctxParent,
+                    dbLevel: ctx.dbLevel,
+                };
+            }
+        }
+        else {
+            ctxParent = ctx;
+        }
+        return await ctx.app.meta.util.executeBean({
+            locale: locale === undefined ? ctx.locale : locale,
+            subdomain: subdomain === undefined ? ctx.subdomain : subdomain,
+            context,
+            beanModule,
+            beanFullName,
+            transaction,
+            fn,
+            ctxParent,
+            instance,
+        });
+    }
+    async performAction({ innerAccess, method, url, query, params, headers, body }) {
+        const ctx = this.ctx;
+        return await (0, performAction_js_1.default)({
+            ctxCaller: ctx,
+            innerAccess,
+            method,
+            url,
+            query,
+            params,
+            headers,
+            body,
+        });
+    }
+}
+exports.CtxUtil = CtxUtil;
+//# sourceMappingURL=utilCtx.js.map

package/dist/types/application/app.d.ts

@@ -0,0 +1,21 @@
+import { Application as EggApplication, EggLoaderOptions, Singleton } from 'egg';
+import { EggPassport } from '@zhennann/egg-passport';
+import { BeanContainer } from '../../lib/bean/beanContainer.js';
+import { AppMeta } from '../../lib/core/meta.js';
+import { Server as SocketServer } from 'socket.io';
+import { Redis } from 'ioredis';
+import { VonaConfig } from '../config/config.js';
+export * as IORedis from 'ioredis';
+export interface VonaApplication extends EggApplication {
+    options: EggLoaderOptions & {
+        flavor: any;
+    };
+    meta: AppMeta;
+    bean: BeanContainer;
+    redis: Singleton<Redis>;
+    io: SocketServer;
+    mysql: any;
+    passport: EggPassport;
+    config: VonaConfig;
+}
+//# sourceMappingURL=app.d.ts.map

package/dist/types/application/app.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedis = void 0;
+exports.IORedis = __importStar(require("ioredis"));
+//# sourceMappingURL=app.js.map

package/dist/types/application/index.d.ts

@@ -0,0 +1,2 @@
+export * from './app.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/application/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./app.js"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/config/appInfo.d.ts

@@ -0,0 +1,4 @@
+import { EggAppInfo } from 'egg';
+export interface VonaAppInfo extends EggAppInfo {
+}
+//# sourceMappingURL=appInfo.d.ts.map