vona-module-a-executor 5.0.9 → 5.0.11

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/this.d.ts

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

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/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,291 @@
+import { BeanInfo, BeanBase, cast, deepExtend, BeanScopeBase } from 'vona';
+import { Bean, Scope } from 'vona-module-a-bean';
+import { combineParamsAndQuery } from '@cabloy/utils';
+import { Log } from 'vona-module-a-logger';
+import { Service } from 'vona-module-a-web';
+
+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];
+  }
+}
+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];
+//     },
+//   });
+// }
+
+var _dec$2, _dec2$2, _class$2;
+let BeanExecutor = (_dec$2 = Bean(), _dec2$2 = BeanInfo({
+  module: "a-executor"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = 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;
+    });
+  }
+}) || _class$2) || _class$2);
+
+function _applyDecoratedDescriptor(i, e, r, n, l) {
+  var a = {};
+  return Object.keys(n).forEach(function (i) {
+    a[i] = n[i];
+  }), a.enumerable = !!a.enumerable, a.configurable = !!a.configurable, ("value" in a || a.initializer) && (a.writable = true), a = r.slice().reverse().reduce(function (r, n) {
+    return n(i, e, r) || r;
+  }, a), l && void 0 !== a.initializer && (a.value = a.initializer ? a.initializer.call(l) : void 0, a.initializer = void 0), void 0 === a.initializer ? (Object.defineProperty(i, e, a), null) : a;
+}
+
+const SymbolRouterMiddleware = Symbol('SymbolRouterMiddleware');
+
+var _dec$1, _dec2$1, _dec3, _dec4, _dec5, _class$1, _class2;
+let ServiceExecutor = (_dec$1 = Service(), _dec2$1 = BeanInfo({
+  module: "a-executor"
+}), _dec3 = Log({
+  level: 'debug'
+}), _dec4 = Reflect.metadata("design:type", Function), _dec5 = Reflect.metadata("design:paramtypes", [typeof METHOD === "undefined" ? Object : METHOD, String, typeof IPerformActionOptions === "undefined" ? Object : IPerformActionOptions]), _dec$1(_class$1 = _dec2$1(_class$1 = (_class2 = 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;
+  }
+}, _applyDecoratedDescriptor(_class2.prototype, "performActionInner", [_dec3, _dec4, _dec5], Object.getOwnPropertyDescriptor(_class2.prototype, "performActionInner"), _class2.prototype), _class2)) || _class$1) || _class$1);
+
+// 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;
+//     }
+//   }
+// }
+
+var _dec, _dec2, _class;
+let ScopeModuleAExecutor = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-executor"
+}), _dec(_class = _dec2(_class = class ScopeModuleAExecutor extends BeanScopeBase {}) || _class) || _class);
+
+/** scope: end */
+
+export { BeanExecutor, ScopeModuleAExecutor, ServiceExecutor, SymbolRouterMiddleware };

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/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/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/index.d.ts

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-executor",
   "type": "module",
-  "version": "5.0.9",
+  "version": "5.0.11",
   "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 && vona :bin:buildModule && tsc -p tsconfig.build.json"
   }
 }