vona-module-a-executor 5.0.8 → 5.0.10

package/dist/.metadata/index.d.ts

@@ -0,0 +1,65 @@
+import type { BeanScopeUtil } from 'vona';
+/** bean: end */
+/** bean: begin */
+import type { BeanExecutor } from '../bean/bean.executor.ts';
+/** service: end */
+/** service: begin */
+import type { ServiceExecutor } from '../service/executor.ts';
+/** service: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+/** bean: begin */
+import 'vona';
+/** service: end */
+/** service: begin */
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from '../bean/bean.executor.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-a-executor' {
+    interface BeanExecutor {
+    }
+}
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        executor: BeanExecutor;
+    }
+}
+/** bean: end */
+/** service: begin */
+export * from '../service/executor.ts';
+declare module 'vona-module-a-web' {
+    interface IServiceRecord {
+        'a-executor:executor': never;
+    }
+}
+declare module 'vona-module-a-executor' {
+    interface ServiceExecutor {
+    }
+}
+export interface IModuleService {
+    executor: ServiceExecutor;
+}
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'a-executor.service.executor': ServiceExecutor;
+    }
+}
+export declare class ScopeModuleAExecutor extends BeanScopeBase {
+}
+export interface ScopeModuleAExecutor {
+    util: BeanScopeUtil;
+    service: IModuleService;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-executor': ScopeModuleAExecutor;
+    }
+    interface IBeanScopeContainer {
+        executor: ScopeModuleAExecutor;
+    }
+}
+/** scope: end */

package/dist/.metadata/index.js

@@ -0,0 +1,29 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/** service: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+/** bean: begin */
+import 'vona';
+/** service: end */
+/** service: begin */
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from "../bean/bean.executor.js";
+/** bean: end */
+/** service: begin */
+export * from "../service/executor.js";
+let ScopeModuleAExecutor = class ScopeModuleAExecutor extends BeanScopeBase {
+};
+ScopeModuleAExecutor = __decorate([
+    Scope()
+], ScopeModuleAExecutor);
+export { ScopeModuleAExecutor };
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "a-executor";
+export { ScopeModuleAExecutor as ScopeModule } from './index.ts';

package/dist/.metadata/this.js

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'a-executor';
+export { ScopeModuleAExecutor as ScopeModule } from "./index.js";

package/dist/bean/bean.executor.d.ts

@@ -0,0 +1,12 @@
+import type { FunctionAsync } from 'vona';
+import type { IApiPathRecordMethodMap } from 'vona-module-a-web';
+import type { INewCtxOptions, IPerformActionOptions } from '../types/executor.ts';
+import { BeanBase } from 'vona';
+export declare class BeanExecutor extends BeanBase {
+    performAction<METHOD extends keyof IApiPathRecordMethodMap, PATH extends keyof IApiPathRecordMethodMap[METHOD]>(method: METHOD, path: PATH, options?: IPerformActionOptions): Promise<any>;
+    runInBackground(fn: FunctionAsync<void>): Promise<void>;
+    newCtxIsolate<RESULT>(fn: FunctionAsync<RESULT>, options?: INewCtxOptions): Promise<RESULT>;
+    mockCtx<RESULT>(fn: FunctionAsync<RESULT>, options?: INewCtxOptions): Promise<RESULT>;
+    newCtx<RESULT>(fn: FunctionAsync<RESULT>, options?: INewCtxOptions): Promise<RESULT>;
+    private _newCtxInner;
+}

package/dist/bean/bean.executor.js

@@ -0,0 +1,111 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BeanBase } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+import { __delegateProperties } from "../lib/utils.js";
+let BeanExecutor = class BeanExecutor extends BeanBase {
+    async performAction(method, path, options) {
+        // url
+        const url = this.app.util.combineApiPath(path, '', true, true);
+        return await this.scope.service.executor.performActionInner(method, url, options);
+    }
+    runInBackground(fn) {
+        return this.bean.database.newDbIsolate(() => {
+            return this.newCtx(fn);
+        });
+    }
+    async newCtxIsolate(fn, options) {
+        options = Object.assign({}, options);
+        // instanceName !== undefined means isolate
+        options.instanceName = options.instanceName === undefined ? this.ctx?.instanceName : options.instanceName;
+        return this.newCtx(fn, options);
+    }
+    async mockCtx(fn, options) {
+        options = Object.assign({}, options);
+        options.dbInfo = options.dbInfo === undefined ? true : options.dbInfo;
+        options.instanceName = options.instanceName === undefined ? (this.ctx?.instanceName ?? '') : options.instanceName;
+        return this.newCtx(fn, options);
+    }
+    async newCtx(fn, options) {
+        if (!options?.dbInfo)
+            return this._newCtxInner(fn, options);
+        const dbInfo = options.dbInfo === true ? {} : options.dbInfo;
+        return this.bean.database.newDb(() => {
+            return this._newCtxInner(fn, options);
+        }, dbInfo);
+    }
+    async _newCtxInner(fn, options) {
+        options = Object.assign({}, options);
+        // innerAccess
+        const innerAccess = options.innerAccess !== false;
+        // ctx ref
+        const ctxRef = innerAccess ? this.ctx : undefined;
+        // isolate
+        const isolate = !ctxRef || options.instanceName !== undefined;
+        const ctxCaller = (!isolate && ctxRef) ? ctxRef : undefined;
+        // locale/instanceName
+        if (ctxRef) {
+            options.locale = options.locale === undefined ? ctxRef.locale : options.locale;
+            options.instanceName = options.instanceName === undefined ? ctxRef.instanceName : options.instanceName;
+        }
+        // run
+        const ctx = this.app.createAnonymousContext(options.req, options.res);
+        return await this.app.ctxStorage.run(ctx, async () => {
+            // innerAccess
+            ctx.innerAccess = innerAccess;
+            // locale
+            if (options.locale !== undefined) {
+                ctx.locale = options.locale;
+            }
+            // instanceName: undefined/null is different
+            if (options.instanceName !== undefined) {
+                ctx.instanceName = options.instanceName;
+            }
+            // ctxCaller
+            if (ctxCaller) {
+                // delegateProperties
+                __delegateProperties(ctx, ctxCaller);
+                // ctxCaller
+                ctx.ctxCaller = ctxCaller;
+            }
+            else {
+                // isolate: extraData
+                if (options.extraData) {
+                    // delegateProperties
+                    __delegateProperties(ctx, options.extraData);
+                }
+            }
+            // instance
+            const instanceName = ctx.instanceName; // use default instanceName when undefined
+            if (instanceName !== undefined && instanceName !== null) {
+                ctx.instance = (await this.bean.instance.get(instanceName));
+                // start instance
+                if (options.instance) {
+                    await this.$scope.instance.service.instance.checkAppReadyInstance(true);
+                }
+            }
+            // execute
+            let res;
+            if (options.transaction) {
+                res = await this.bean.database.current.transaction.begin(async () => {
+                    return await fn();
+                }, options.transactionOptions);
+            }
+            else {
+                res = await fn();
+            }
+            // commitDone
+            await ctx.commitDone();
+            // ok
+            return res;
+        });
+    }
+};
+BeanExecutor = __decorate([
+    Bean()
+], BeanExecutor);
+export { BeanExecutor };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './.metadata/index.ts';
+export * from './types/index.ts';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./.metadata/index.js";
+export * from "./types/index.js";

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function __delegateProperties(ctx: any, ctxCaller: any): void;
+export declare function __delegateProperty(ctx: any, ctxCaller: any, property: any): void;

package/dist/lib/utils.js

@@ -0,0 +1,43 @@
+export function __delegateProperties(ctx, ctxCaller) {
+    for (const property of ['state']) {
+        __delegateProperty(ctx, ctxCaller, property);
+    }
+    for (const property of ['headers']) {
+        __delegateProperty(ctx.request, ctxCaller.request, property);
+        // if (ctx.request[property]) req[property] = ctx.request[property];
+    }
+}
+export function __delegateProperty(ctx, ctxCaller, property) {
+    if (!ctxCaller[property])
+        ctxCaller[property] = {};
+    ctx[property] = ctxCaller[property];
+}
+// export function delegateProperty(ctx, ctxCaller, property) {
+//   if (!ctxCaller[property]) return;
+//   if (!ctx[property]) ctx[property] = {};
+//   for (const key in ctxCaller[property]) {
+//     ctx[property][key] = ctxCaller[property][key];
+//   }
+// }
+// function _delegateProperty(ctx, ctxCaller, property) {
+//   const keyMock = `__executeBean__mock__${property}__`;
+//   const keyOriginal = `__executeBean__mock__${property}__original__`;
+//   if (['headers'].includes(property)) {
+//     ctx[keyOriginal] = ctx[property];
+//   }
+//   Object.defineProperty(ctx, property, {
+//     get() {
+//       const value = ctxCaller && ctxCaller[property];
+//       if (value) return value;
+//       //
+//       if (['headers'].includes(property)) {
+//         return ctx[keyOriginal];
+//       }
+//       //
+//       if (!ctx[keyMock]) {
+//         ctx[keyMock] = {};
+//       }
+//       return ctx[keyMock];
+//     },
+//   });
+// }

package/dist/service/executor.d.ts

@@ -0,0 +1,7 @@
+import type { IApiPathRecordMethodMap } from 'vona-module-a-web';
+import type { IGeneralInfoOptions, IPerformActionOptions } from '../types/executor.ts';
+import { BeanBase } from 'vona';
+export declare class ServiceExecutor extends BeanBase {
+    performActionInner<METHOD extends keyof IApiPathRecordMethodMap>(method: METHOD, url: string, options?: IPerformActionOptions): Promise<any>;
+    prepareGeneralInfo(options?: IGeneralInfoOptions): IGeneralInfoOptions;
+}

package/dist/service/executor.js

@@ -0,0 +1,127 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+import { combineParamsAndQuery } from '@cabloy/utils';
+import { BeanBase, cast, deepExtend } from 'vona';
+import { Log } from 'vona-module-a-logger';
+import { Service } from 'vona-module-a-web';
+import { SymbolRouterMiddleware } from "../types/executor.js";
+let ServiceExecutor = class ServiceExecutor extends BeanBase {
+    async performActionInner(method, url, options) {
+        // app
+        const app = this.app;
+        // new ctx
+        return await this.bean.executor.newCtx(async () => {
+            const ctx = this.ctx;
+            // default status code
+            ctx.res.statusCode = 404;
+            ctx.req.method = method.toUpperCase();
+            // url
+            ctx.req.url = combineParamsAndQuery(url, { params: options?.params, query: options?.query });
+            // headers
+            ctx.req.headers = Object.assign({}, ctx.req.headers, options?.headers);
+            // json
+            if (!ctx.req.headers.accept) {
+                ctx.req.headers.accept = 'application/json';
+            }
+            // authToken
+            if (options?.authToken) {
+                ctx.req.headers.authorization = `Bearer ${options?.authToken}`;
+            }
+            // // query
+            // if (options?.query !== undefined) {
+            //   cast(ctx.req).query = cast(ctx.request).query = options?.query;
+            // }
+            // body
+            cast(ctx.req).body = ctx.request.body = options?.body ?? {}; // body should set {} if undefined/null
+            // onion
+            ctx.onionsDynamic = options?.onions;
+            // invoke middleware
+            await app[SymbolRouterMiddleware](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 app.util.createError(ctx.body);
+            }
+            else {
+                if (ctx.body && typeof ctx.body === 'object') {
+                    throw app.util.createError(ctx.body);
+                }
+                else {
+                    throw app.util.createError({
+                        code: ctx.status,
+                        message: ctx.message,
+                    });
+                }
+            }
+        }, { innerAccess: options?.innerAccess, extraData: options?.extraData });
+    }
+    prepareGeneralInfo(options) {
+        const current = this.bean.database.current;
+        const level = (options?.dbInfo?.level ?? current?.level ?? 0) + 1;
+        const clientName = options?.dbInfo?.clientName ?? current?.clientName;
+        const locale = options?.locale === undefined ? this.ctx?.locale : options.locale;
+        const instanceName = options?.instanceName === undefined ? this.ctx?.instanceName : options.instanceName;
+        options = {
+            dbInfo: { level, clientName },
+            locale,
+            instanceName,
+        };
+        if (this.ctx) {
+            options = deepExtend({ extraData: { request: { headers: {} } } }, options);
+            // extraData: headers
+            const headers = options.extraData.request.headers;
+            for (const key in this.ctx.request.headers) {
+                if (key.startsWith('x-vona-data-') && !headers[key]) {
+                    const value = this.ctx.request.headers[key];
+                    if (value) {
+                        headers[key] = value;
+                    }
+                }
+            }
+        }
+        return options;
+    }
+};
+__decorate([
+    Log({ level: 'debug' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_a = typeof METHOD !== "undefined" && METHOD) === "function" ? _a : Object, String, Object]),
+    __metadata("design:returntype", Promise)
+], ServiceExecutor.prototype, "performActionInner", null);
+ServiceExecutor = __decorate([
+    Service()
+], ServiceExecutor);
+export { ServiceExecutor };
+// for (const key of ['x-clientid', 'x-scene']) {
+//   if (!headers[key]) {
+//     const value =
+//       key === 'x-clientid'
+//         ? (<any>ctx.app.bean).util.getFrontClientId()
+//         : (<any>ctx.app.bean).util.getFrontScene();
+//     if (value) {
+//       headers[key] = value;
+//     }
+//   }
+// }
+// for (const key of ['host', 'origin', 'referer', 'user-agent']) {
+//   if (!headers[key]) {
+//     const value = this.ctx.request.headers[key];
+//     if (value) {
+//       headers[key] = value;
+//     }
+//   }
+// }

package/dist/types/executor.d.ts

@@ -0,0 +1,40 @@
+import type { ContextState, ILocaleInfos, PowerPartial } from 'vona';
+import type { IDbInfo, ITransactionOptions } from 'vona-module-a-database';
+import type { ConfigOnions } from 'vona-module-a-onion';
+export declare const SymbolRouterMiddleware: unique symbol;
+export interface INewCtxExtraData {
+    state?: ContextState;
+    request?: {
+        headers?: Record<string, string>;
+    };
+}
+export interface INewCtxOptions extends INewCtxBaseOptions {
+    dbInfo?: IDbInfo | true;
+}
+export interface INewCtxBaseOptions {
+    locale?: keyof ILocaleInfos;
+    instanceName?: string | undefined | null;
+    instance?: boolean;
+    transaction?: boolean;
+    transactionOptions?: ITransactionOptions;
+    extraData?: INewCtxExtraData | undefined;
+    innerAccess?: boolean;
+    req?: any;
+    res?: any;
+}
+export interface IPerformActionOptions {
+    innerAccess?: boolean;
+    params?: object;
+    query?: object;
+    headers?: object;
+    body?: any;
+    onions?: PowerPartial<ConfigOnions>;
+    authToken?: string;
+    extraData?: INewCtxExtraData | undefined;
+}
+export interface IGeneralInfoOptions {
+    dbInfo?: IDbInfo;
+    locale?: keyof ILocaleInfos;
+    instanceName?: string | undefined | null;
+    extraData?: INewCtxExtraData;
+}

package/dist/types/executor.js

@@ -0,0 +1 @@
+export const SymbolRouterMiddleware = Symbol('SymbolRouterMiddleware');

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './executor.ts';

package/dist/types/index.js

@@ -0,0 +1 @@
+export * from "./executor.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-executor",
   "type": "module",
-  "version": "5.0.8",
+  "version": "5.0.10",
   "title": "a-executor",
   "vonaModule": {
     "dependencies": {}
@@ -28,8 +28,12 @@
   "dependencies": {
     "koa-compose": "^4.1.0"
   },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
   "scripts": {
-    "clean": "rimraf dist tsconfig.tsbuildinfo",
-    "tsc:publish": "npm run clean && tsc"
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && tsc -p tsconfig.build.json"
   }
 }