vona 1.0.0 → 5.0.4

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

@@ -0,0 +1,11 @@
+import { BeanSimple } from '../bean/beanSimple.js';
+export declare class AppMockUtil extends BeanSimple {
+    parseUrlFromModuleInfo(moduleInfo: any, apiPrefix?: string | boolean): string | null;
+    mockUrl(moduleInfo: any, url: any, apiPrefix?: string | boolean): string;
+    mockCtx(options?: {
+        locale?: string;
+        subdomain?: string | null;
+        module?: string;
+    }): Promise<import("../../index.js").VonaContext>;
+}
+//# sourceMappingURL=mockUtil.d.ts.map

package/dist/lib/utils/mockUtil.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppMockUtil = void 0;
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+class AppMockUtil extends beanSimple_js_1.BeanSimple {
+    parseUrlFromModuleInfo(moduleInfo, apiPrefix = true) {
+        apiPrefix = _prepareApiPrefix(apiPrefix);
+        if (!moduleInfo)
+            return null;
+        return `${apiPrefix}/${moduleInfo.pid}/${moduleInfo.name}`;
+    }
+    mockUrl(moduleInfo, url, apiPrefix = true) {
+        apiPrefix = _prepareApiPrefix(apiPrefix);
+        if (url && url.charAt(0) === '/')
+            return `${apiPrefix}${url}`;
+        const prefix = this.parseUrlFromModuleInfo(moduleInfo, apiPrefix);
+        return url ? `${prefix}/${url}` : `${prefix}/`;
+    }
+    async mockCtx(options) {
+        options = options || {};
+        const locale = options.locale;
+        const subdomain = options.subdomain !== undefined ? options.subdomain : '';
+        const module = options.module;
+        const ctx = await this.app.meta.util.createAnonymousContext({ locale, subdomain, module });
+        return ctx;
+    }
+}
+exports.AppMockUtil = AppMockUtil;
+function _prepareApiPrefix(apiPrefix) {
+    if (typeof apiPrefix === 'string')
+        return apiPrefix;
+    return apiPrefix ? '/api' : '';
+}
+//# sourceMappingURL=mockUtil.js.map

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

@@ -0,0 +1,10 @@
+import { BeanSimple } from '../bean/beanSimple.js';
+export declare class CtxMockUtil extends BeanSimple {
+    login({ auth, password }: {
+        auth: any;
+        password?: string | undefined;
+    }): Promise<any>;
+    logout(): Promise<any>;
+    catchError(fnMethod: any, fnError: any): Promise<any>;
+}
+//# sourceMappingURL=mockUtilCtx.d.ts.map

package/dist/lib/utils/mockUtilCtx.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CtxMockUtil = void 0;
+const beanSimple_js_1 = require("../bean/beanSimple.js");
+class CtxMockUtil extends beanSimple_js_1.BeanSimple {
+    // login
+    async login({ auth, password = '123456' }) {
+        return await this.ctx.bean.authSimple.signinDirect({ data: { auth, password } });
+    }
+    // logout
+    async logout() {
+        return await this.ctx.bean.auth.logout();
+    }
+    // catchError
+    async catchError(fnMethod, fnError) {
+        let success;
+        let data;
+        try {
+            data = await fnMethod();
+            success = true;
+        }
+        catch (err) {
+            success = false;
+            await fnError(err);
+        }
+        // success
+        if (success) {
+            const err = { code: 0 };
+            await fnError(err, data);
+        }
+        return data;
+    }
+}
+exports.CtxMockUtil = CtxMockUtil;
+//# sourceMappingURL=mockUtilCtx.js.map

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

@@ -0,0 +1,19 @@
+/**
+ * perform action of this or that module
+ * @param  {string} options options
+ * @param  {string} options.method method
+ * @param  {string} options.url    url
+ * @param  {json} options.body   body(optional)
+ * @return {promise}                response.body.data or throw error
+ */
+export default function performAction({ ctxCaller, innerAccess, method, url, query, params, headers, body, }: {
+    ctxCaller: any;
+    innerAccess: any;
+    method: any;
+    url: any;
+    query: any;
+    params: any;
+    headers: any;
+    body: any;
+}): Promise<any>;
+//# sourceMappingURL=performAction.d.ts.map

package/dist/lib/utils/performAction.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 });
+const http_1 = __importDefault(require("http"));
+const koa_compose_1 = __importDefault(require("koa-compose"));
+let __fnMiddleware;
+/**
+ * perform action of this or that module
+ * @param  {string} options options
+ * @param  {string} options.method method
+ * @param  {string} options.url    url
+ * @param  {json} options.body   body(optional)
+ * @return {promise}                response.body.data or throw error
+ */
+async function performAction({ ctxCaller, innerAccess, 
+// subdomain, deprecated
+method, url, query, params, headers, body, }) {
+    // app
+    const app = ctxCaller.app;
+    // middleware
+    if (!__fnMiddleware) {
+        const middleware = app.middleware[app.middleware.length - 1];
+        __fnMiddleware = (0, koa_compose_1.default)([middleware]);
+    }
+    // request
+    url = app.meta.util.combineFetchPath(ctxCaller.module && ctxCaller.module.info, url);
+    const req = createRequest({ method, url }, ctxCaller);
+    // response
+    const res = new http_1.default.ServerResponse(req);
+    // default status code
+    res.statusCode = 404;
+    // ctx
+    const ctx = app.createContext(req, res);
+    // locale
+    Object.defineProperty(ctx, 'locale', {
+        get() {
+            return ctxCaller.locale;
+        },
+    });
+    // subdomain
+    Object.defineProperty(ctx, 'subdomain', {
+        get() {
+            return ctxCaller.subdomain;
+        },
+    });
+    // query params body
+    if (query) {
+        ctx.req.query = ctx.request.query = query;
+    }
+    if (params) {
+        ctx.req.params = ctx.request.params = params;
+    }
+    ctx.req.body = ctx.request.body = body !== undefined ? body : {}; // not undefined
+    // headers
+    delegateHeaders(ctx, ctxCaller, headers);
+    // multipart
+    ctx.multipart = function (options) {
+        return ctxCaller.multipart(options);
+    };
+    // cookies
+    delegateCookies(ctx, ctxCaller);
+    // XX should not delegate session, because session._ctx related to ctx
+    // not delegate ctx.user, because will create req.user by state.user
+    for (const property of ['state', 'socket', 'session', 'instance']) {
+        delegateProperty(ctx, ctxCaller, property);
+    }
+    // ctxCaller
+    ctx.ctxCaller = ctxCaller;
+    // innerAccess
+    if (innerAccess !== undefined)
+        ctx.innerAccess = innerAccess;
+    // invoke middleware
+    await __fnMiddleware(ctx);
+    // check result
+    if (ctx.status === 200) {
+        if (!ctx.body || ctx.body.code === undefined) {
+            // not check code, e.g. text/xml
+            return ctx.body;
+        }
+        if (ctx.body.code === 0) {
+            return ctx.body.data;
+        }
+        throw ctx.createError(ctx.body);
+    }
+    else {
+        throw ctx.createError({
+            code: ctx.status,
+            message: ctx.message || ctx.body,
+        });
+    }
+}
+exports.default = performAction;
+function delegateHeaders(ctx, ctxCaller, headers) {
+    if (ctxCaller && ctxCaller.headers) {
+        Object.assign(ctx.headers, ctxCaller.headers);
+    }
+    if (headers) {
+        Object.assign(ctx.headers, headers);
+    }
+}
+function delegateCookies(ctx, ctxCaller) {
+    const _cookies = ctx.cookies;
+    Object.defineProperty(ctx, 'cookies', {
+        get() {
+            return ctxCaller.cookies || _cookies;
+        },
+    });
+}
+function delegateProperty(ctx, ctxCaller, property) {
+    Object.defineProperty(ctx, property, {
+        get() {
+            return ctxCaller[property];
+        },
+    });
+}
+function createRequest({ method, url }, ctxCaller) {
+    // _req
+    const _req = ctxCaller.request;
+    // req
+    const req = new http_1.default.IncomingMessage(null);
+    req.headers = _req.headers;
+    req.host = _req.host;
+    req.hostname = _req.hostname;
+    req.protocol = _req.protocol;
+    req.secure = _req.secure;
+    req.method = method.toUpperCase();
+    req.url = url;
+    // path,
+    req.socket = {
+        remoteAddress: _req.socket.remoteAddress,
+        remotePort: _req.socket.remotePort,
+    };
+    return req;
+}
+//# sourceMappingURL=performAction.js.map

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

@@ -0,0 +1,63 @@
+import Redlock from 'redlock';
+import { VonaContext, IModule, PowerPartial, TypeMonkeyName } from '../../types/index.js';
+import { BeanSimple } from '../bean/beanSimple.js';
+import { IModuleMiddlewareGate } from '../bean/index.js';
+export interface IExecuteBeanCallbackParams {
+    ctx: VonaContext;
+    bean: any;
+    context: any;
+}
+export interface IExecuteBeanCallback {
+    (params: IExecuteBeanCallbackParams): Promise<any>;
+}
+export declare class AppUtil extends BeanSimple {
+    instanceStarted(subdomain: any): any;
+    combineFetchPath(moduleName: any, arg: any): any;
+    combineApiPath(moduleName: any, arg: any): any;
+    combineQueries(url: any, queries: any): any;
+    createError(data: any, returnObject?: boolean): any;
+    monkeyModule(ebAppMonkey: any, ebModulesMonkey: any, monkeyName: TypeMonkeyName, moduleTarget?: IModule, ...monkeyData: any[]): Promise<void>;
+    getWhiteListCors(ctx: any): any;
+    isSafeDomain(ctx: any, origin: any): boolean;
+    isNullOrEmptyString(str?: string | undefined | null): boolean;
+    compose(chains: any, adapter: any): (context: any, next?: any) => any;
+    composeAsync(chains: any, adapter: any): (context: any, next?: any) => Promise<any>;
+    createAnonymousContext({ locale, subdomain, module, instance }: {
+        locale: any;
+        subdomain: any;
+        module: any;
+        instance: any;
+    }): Promise<VonaContext>;
+    executeBean({ locale, subdomain, beanModule, beanFullName, context, fn, transaction, ctxCaller, ctxParent, instance, }: {
+        locale?: string;
+        subdomain?: string;
+        beanModule?: string;
+        beanFullName?: string;
+        context: any;
+        fn?: any;
+        transaction?: boolean;
+        ctxCaller?: VonaContext;
+        ctxParent?: PowerPartial<VonaContext>;
+        instance?: boolean;
+    }): Promise<any>;
+    _executeBeanFn({ fn, ctx, bean, context }: {
+        fn: any;
+        ctx: any;
+        bean: any;
+        context: any;
+    }): Promise<any>;
+    lock({ subdomain, resource, fn, options, redlock, }: {
+        subdomain?: string;
+        resource: string;
+        fn: () => Promise<any>;
+        options: any;
+        redlock?: Redlock;
+    }): Promise<any>;
+    subdomainDesp(subdomain: any): any;
+    deprecated(oldUsage: any, newUsage: any): void;
+    checkGate(gate?: IModuleMiddlewareGate): boolean;
+    _checkGateEnv(env?: IModuleMiddlewareGate['env']): boolean;
+    requireDynamic(file: any): any;
+    private _requireDynamic_getFileTime;
+}
+//# sourceMappingURL=util.d.ts.map