vona-module-test-vona 5.0.38 → 5.0.41

package/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'test-vona';
+export { ScopeModuleTestVona as ScopeModule } from './index.ts';

package/src/bean/aop.regExp.ts

@@ -0,0 +1,30 @@
+import { BeanAopBase } from 'vona';
+import { Aop } from 'vona-module-a-aspect';
+
+@Aop({ match: [/^test-vona\.service\.test\w+$/, 'testCtx'], meta: { mode: 'test' } })
+export class AopRegExp extends BeanAopBase {
+  __get_name__(next) {
+    const value = next();
+    return `${value}:regexpaop`;
+  }
+
+  __set_name__(value, next) {
+    const parts = value.split(':');
+    const index = parts.indexOf('regexpaop');
+    if (index > -1) {
+      parts.splice(index, 1);
+    }
+    value = parts.join(':');
+    return next(value);
+  }
+
+  actionSync(_args, next) {
+    const result = next();
+    return `${result}:regexpaop`;
+  }
+
+  async actionAsync(_args, next) {
+    const result = await next();
+    return `${result}:regexpaop`;
+  }
+}

package/src/bean/aop.simple.ts

@@ -0,0 +1,58 @@
+import type { Next } from 'vona';
+import type { BeanTestCtx } from 'vona-module-test-vona';
+import { BeanAopBase } from 'vona';
+import { Aop } from 'vona-module-a-aspect';
+
+class AopSimpleBase extends BeanAopBase {
+  actionSync(_args, next) {
+    const result = next();
+    return `${result}:simpleaop`;
+  }
+}
+
+@Aop({ match: 'testCtx', dependencies: 'test-vona:regExp', meta: { mode: 'test' } })
+export class AopSimple extends AopSimpleBase {
+  // magic
+  __get__(prop, next) {
+    const value = next();
+    if (prop === 'magic') {
+      return 'magic:simpleaop';
+    }
+    if (prop === 'name') {
+      return `${value}:simpleaop`;
+    }
+    return value;
+  }
+
+  __set__(prop, value, next): boolean {
+    if (prop === 'name') {
+      const parts = value.split(':');
+      const index = parts.indexOf('simpleaop');
+      if (index > -1) {
+        parts.splice(index, 1);
+      }
+      value = parts.join(':');
+    }
+    return next(value);
+  }
+
+  __get_name__(next) {
+    const value = next();
+    return `${value}:simpleaop`;
+  }
+
+  __set_name__(value, next): boolean {
+    const parts = value.split(':');
+    const index = parts.indexOf('simpleaop');
+    if (index > -1) {
+      parts.splice(index, 1);
+    }
+    value = parts.join(':');
+    return next(value);
+  }
+
+  async actionAsync(_args: Parameters<BeanTestCtx['actionAsync']>, next: Next, _receiver: BeanTestCtx) {
+    const result = await next();
+    return `${result}:simpleaop`;
+  }
+}

package/src/bean/aopMethod.test.ts

@@ -0,0 +1,42 @@
+import type { Next, NextSync } from 'vona';
+import type { IAopMethodExecute, IAopMethodGet, IAopMethodSet, IDecoratorAopMethodOptions } from 'vona-module-a-aspect';
+import { BeanAopMethodBase } from 'vona';
+import { AopMethod } from 'vona-module-a-aspect';
+
+export interface IAopMethodOptionsTest extends IDecoratorAopMethodOptions {
+  wrapper: string;
+}
+
+@AopMethod<IAopMethodOptionsTest>({ wrapper: '' })
+export class AopMethodTest extends BeanAopMethodBase implements IAopMethodGet, IAopMethodSet, IAopMethodExecute {
+  get(options: IAopMethodOptionsTest, next: NextSync, _receiver: any, _prop: string): string {
+    const res = next();
+    return this._wrapper(options.wrapper, res);
+  }
+
+  set(options: IAopMethodOptionsTest, value: string, next: NextSync, _receiver: any, _prop: string): boolean {
+    return next(this._unwrapper(options.wrapper, value));
+  }
+
+  execute(options: IAopMethodOptionsTest, _args: [], next: Next | NextSync, _receiver: any, _prop: string): Promise<string> | string {
+    const res = next();
+    if (res?.then) {
+      return res.then(res => {
+        return this._wrapper(options.wrapper, res);
+      });
+    }
+    return this._wrapper(options.wrapper, res);
+  }
+
+  _wrapper(wrapper: string, data: string) {
+    return `${wrapper}${data}${wrapper}`;
+  }
+
+  _unwrapper(wrapper: string, data: string) {
+    let index = data.indexOf(wrapper);
+    if (index === 0) data = data.substring(wrapper.length);
+    index = data.lastIndexOf(wrapper);
+    if (index === data.length - wrapper.length) data = data.substring(0, index);
+    return data;
+  }
+}

package/src/bean/bean.testCtx.ts

@@ -0,0 +1,55 @@
+import { BeanBase } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+
+class TestCtx0 extends BeanBase {
+  _name: string;
+
+  protected __init__(moduleName) {
+    this._name = moduleName;
+  }
+
+  protected __get__(prop) {
+    if (prop === 'magicSelf') {
+      return this['magic:self'];
+    }
+  }
+
+  protected __set__(prop, value): boolean {
+    if (prop === 'magicSelf') {
+      this['magic:self'] = value;
+      return true;
+    }
+    return false;
+  }
+
+  get name() {
+    return this._name;
+  }
+
+  set name(value) {
+    this._name = value;
+  }
+
+  actionSync({ a, b }: any) {
+    return a + b;
+  }
+
+  async actionAsync({ a, b }: { a: number; b: number }) {
+    return Promise.resolve(a + b);
+  }
+
+  async actionAsync2({ a, b }: any) {
+    const name = this.name;
+    const value = await this.actionAsync({ a, b });
+    return `${name}:${value}`;
+  }
+}
+
+class TestCtx1 extends TestCtx0 {
+  async actionAsync3({ a, b }: any) {
+    return await this.actionAsync2({ a, b });
+  }
+}
+
+@Bean()
+export class BeanTestCtx extends TestCtx1 {}

package/src/bean/broadcast.test.ts

@@ -0,0 +1,22 @@
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+import assert from 'node:assert';
+import { BeanBroadcastBase, Broadcast } from 'vona-module-a-broadcast';
+
+export interface TypeBroadcastTestJobData {
+  message: string;
+}
+
+@Broadcast()
+export class BroadcastTest
+  extends BeanBroadcastBase<TypeBroadcastTestJobData>
+  implements IBroadcastExecute<TypeBroadcastTestJobData> {
+  async execute(data: TypeBroadcastTestJobData, isEmitter?: boolean) {
+    if (!isEmitter) {
+      // do something
+    }
+    // locale
+    assert.equal(this.ctx.locale, 'zh-cn');
+    // data
+    assert.equal(data.message, 'hello');
+  }
+}

package/src/bean/cacheMem.test.ts

@@ -0,0 +1,7 @@
+import { BeanCacheMemBase, CacheMem } from 'vona-module-a-cache';
+
+export type TCacheMemTestKey = '__immutable__' | undefined;
+export type TCacheMemTestData = { name: string } | string;
+
+@CacheMem({ ttl: 1 * 1000 })
+export class CacheMemTest extends BeanCacheMemBase<TCacheMemTestKey, TCacheMemTestData> {}

package/src/bean/cacheRedis.post.ts

@@ -0,0 +1,10 @@
+import type { TableIdentity } from 'table-identity';
+import type { EntityPost } from '../entity/post.ts';
+import { BeanCacheRedisBase, CacheRedis } from 'vona-module-a-cache';
+
+export type TCacheRedisPostKey = TableIdentity;
+export type TCacheRedisPostData = Partial<EntityPost>;
+
+@CacheRedis()
+export class CacheRedisPost
+  extends BeanCacheRedisBase<TCacheRedisPostKey, TCacheRedisPostData> {}

package/src/bean/cacheRedis.test.ts

@@ -0,0 +1,7 @@
+import { BeanCacheRedisBase, CacheRedis } from 'vona-module-a-cache';
+
+export type TCacheRedisTestKey = any;
+export type TCacheRedisTestData = string;
+
+@CacheRedis({ ttl: 1 * 1000 })
+export class CacheRedisTest extends BeanCacheRedisBase<TCacheRedisTestKey, TCacheRedisTestData> {}

package/src/bean/event.helloEcho.ts

@@ -0,0 +1,8 @@
+import { BeanEventBase, Event } from 'vona-module-a-event';
+
+export interface TypeEventHelloEchoData { text: string }
+
+export type TypeEventHelloEchoResult = string;
+
+@Event()
+export class EventHelloEcho extends BeanEventBase<TypeEventHelloEchoData, TypeEventHelloEchoResult> {}

package/src/bean/eventListener.helloEcho.ts

@@ -0,0 +1,21 @@
+import type { IEventExecute, NextEvent } from 'vona-module-a-event';
+import type { TypeEventHelloEchoData, TypeEventHelloEchoResult } from './event.helloEcho.ts';
+import { BeanBase } from 'vona';
+import { EventListener } from 'vona-module-a-event';
+
+type TypeEventData = TypeEventHelloEchoData;
+type TypeEventResult = TypeEventHelloEchoResult;
+
+@EventListener({ match: 'test-vona:helloEcho' })
+export class EventListenerHelloEcho
+  extends BeanBase
+  implements IEventExecute<TypeEventData, TypeEventResult> {
+  async execute(
+    data: TypeEventData,
+    next: NextEvent<TypeEventData, TypeEventResult>,
+  ): Promise<TypeEventResult> {
+    // next
+    const result = await next();
+    return `${data.text} ${result}`;
+  }
+}

package/src/bean/meta.version.ts

@@ -0,0 +1,81 @@
+import type { IMetaVersionUpdate, IMetaVersionUpdateOptions } from 'vona-module-a-version';
+import { BeanBase } from 'vona';
+import { Meta } from 'vona-module-a-meta';
+
+@Meta()
+export class MetaVersion extends BeanBase implements IMetaVersionUpdate {
+  async update(options: IMetaVersionUpdateOptions) {
+    if (options.version === 1) {
+      // testVonaTest
+      const entityTest = this.scope.entity.test;
+      await this.bean.model.createTable(entityTest.$table, table => {
+        table.comment(entityTest.$comment.$table);
+        table.basicFields();
+        table.string(entityTest.title, 255).comment(entityTest.$comment.title);
+        table.string(entityTest.description, 255);
+      });
+      // testVonaUser
+      const entityUser = this.scope.entity.user;
+      await this.bean.model.createTable(entityUser.$table, table => {
+        table.basicFields();
+        table.string(entityUser.name, 255);
+        table.integer(entityUser.age);
+        table.integer(entityUser.scores);
+      });
+      // testVonaRole
+      const entityRole = this.scope.entity.role;
+      await this.bean.model.createTable(entityRole.$table, table => {
+        table.basicFields();
+        table.string(entityRole.name, 255);
+      });
+      // testVonaRoleUser
+      const entityRoleUser = this.scope.entity.roleUser;
+      await this.bean.model.createTable(entityRoleUser.$table, table => {
+        table.basicFields();
+        table.tableIdentity(entityRoleUser.userId);
+        table.tableIdentity(entityRoleUser.roleId);
+      });
+      // testVonaPost
+      const entityPost = this.scope.entity.post;
+      await this.bean.model.createTable(entityPost.$table, table => {
+        table.basicFields();
+        table.string(entityPost.title, 255);
+        table.userId();
+        table.integer(entityPost.stars);
+      });
+      // testVonaPostContent
+      const entityPostContent = this.scope.entity.postContent;
+      await this.bean.model.createTable(entityPostContent.$table, table => {
+        table.basicFields();
+        table.text(entityPostContent.content);
+        table.tableIdentity(entityPostContent.postId);
+      });
+      // testVonaCategory
+      const entityCategory = this.scope.entity.category;
+      await this.bean.model.createTable(entityCategory.$table, table => {
+        table.basicFields();
+        table.string(entityCategory.name, 255);
+        table.tableIdentity(entityCategory.categoryIdParent);
+      });
+      // order
+      const entityOrder = this.scope.entity.order;
+      await this.bean.model.createTable(entityOrder.$table, table => {
+        table.comment(entityOrder.$comment.$table);
+        table.basicFields();
+        table.string(entityOrder.orderNo, 50).defaultTo(entityOrder.$default.orderNo).comment(entityOrder.$comment.orderNo);
+        table.string(entityOrder.remark, 255).comment(entityOrder.$comment.remark);
+        table.tableIdentity(entityOrder.userId);
+      });
+      // product
+      const entityProduct = this.scope.entity.product;
+      await this.bean.model.createTable(entityProduct.$table, table => {
+        table.basicFields();
+        table.string(entityProduct.name, 50).comment(entityProduct.$comment.name);
+        table.integer(entityProduct.price);
+        table.integer(entityProduct.quantity);
+        table.integer(entityProduct.amount);
+        table.tableIdentity(entityProduct.orderId);
+      });
+    }
+  }
+}

package/src/bean/queue.test.ts

@@ -0,0 +1,18 @@
+import type { IQueueExecute, IQueuePushOptions } from 'vona-module-a-queue';
+import { BeanQueueBase, Queue } from 'vona-module-a-queue';
+
+export interface TypeQueueTestJobData {
+  a: number;
+  b: number;
+}
+
+export type TypeQueueTestJobResult = number;
+
+@Queue()
+export class QueueTest
+  extends BeanQueueBase<TypeQueueTestJobData, TypeQueueTestJobResult>
+  implements IQueueExecute<TypeQueueTestJobData, TypeQueueTestJobResult> {
+  async execute(data: TypeQueueTestJobData, _options?: IQueuePushOptions): Promise<TypeQueueTestJobResult> {
+    return data.a + data.b;
+  }
+}

package/src/bean/schedule.test.ts

@@ -0,0 +1,12 @@
+import type { IScheduleExecute, TypeScheduleJob } from 'vona-module-a-schedule';
+import { BeanBase } from 'vona';
+import { Schedule } from 'vona-module-a-schedule';
+
+@Schedule({ enable: false, repeat: { every: 3000 } })
+export class ScheduleTest extends BeanBase implements IScheduleExecute {
+  async execute(job?: TypeScheduleJob) {
+    this.$logger.silly(
+      `Schedule Test: iid=${this.ctx.instance.id}, every=${job?.data.options?.jobOptions?.repeat?.every}, ${new Date()}`,
+    );
+  }
+}

package/src/bean/schedule.test3.ts

@@ -0,0 +1,12 @@
+import type { IScheduleExecute, TypeScheduleJob } from 'vona-module-a-schedule';
+import { BeanBase } from 'vona';
+import { Schedule } from 'vona-module-a-schedule';
+
+@Schedule({ enable: false, repeat: { every: 5000 } })
+export class ScheduleTest3 extends BeanBase implements IScheduleExecute {
+  async execute(job?: TypeScheduleJob) {
+    this.$logger.silly(
+      `Schedule Test3: iid=${this.ctx.instance.id}, every=${job?.data.options?.jobOptions?.repeat?.every}, ${new Date()}`,
+    );
+  }
+}

package/src/bean/summerCache.test.ts

@@ -0,0 +1,29 @@
+import type { ISummerCacheGet, TSummerCacheActionOptions } from 'vona-module-a-summer';
+import { BeanSummerCacheBase, SummerCache } from 'vona-module-a-summer';
+
+export interface TSummerCacheTestKey { id: number }
+export interface TSummerCacheTestData { id: number; name: string }
+
+@SummerCache({
+  mode: 'all',
+  mem: {
+    max: 2,
+    ttl: 1 * 1000,
+  },
+  redis: {
+    ttl: 3 * 1000,
+  },
+})
+export class SummerCacheTest
+  extends BeanSummerCacheBase<TSummerCacheTestKey, TSummerCacheTestData>
+  implements ISummerCacheGet<TSummerCacheTestKey, TSummerCacheTestData> {
+  async getNative(
+    key: TSummerCacheTestKey,
+    _options?: TSummerCacheActionOptions<TSummerCacheTestKey, TSummerCacheTestData>,
+  ): Promise<TSummerCacheTestData | null | undefined> {
+    return {
+      id: key.id,
+      name: `name_${key.id}`,
+    };
+  }
+}

package/src/config/config.ts

@@ -0,0 +1,5 @@
+import type { VonaApplication } from 'vona';
+
+export function config(_app: VonaApplication) {
+  return {};
+}

package/src/config/locale/en-us.ts

@@ -0,0 +1,19 @@
+export default {
+  Name: 'Name',
+  User: 'User',
+  UserId: 'User Id',
+  Test: 'Test',
+  TestHelloWorld: 'Hello World',
+  TestApples: '%d apples',
+  TestApples_0: 'no apples',
+  TestApples_1: 'one apple',
+  TestNameApples_: '%s has %d apples',
+  TestNameApples_0_1: '%s has no apples',
+  TestNameApples_1_1: '%s has one apple',
+  Order: 'Order',
+  OrderNo: 'Order No',
+  Remark: 'Remark',
+  Price: 'Price',
+  Quantity: 'Quantity',
+  Amount: 'Amount',
+};

package/src/config/locale/zh-cn.ts

@@ -0,0 +1,17 @@
+export default {
+  Name: '名称',
+  User: '用户',
+  UserId: '用户Id',
+  Test: '测试',
+  TestHelloWorld: '您好，世界',
+  TestApples: '%d个苹果',
+  TestApples_0: '没有苹果',
+  TestNameApples_: '%s有%d个苹果',
+  TestNameApples_0_1: '%s没有苹果',
+  Order: '订单',
+  OrderNo: '订单号',
+  Remark: '备注',
+  Price: '单价',
+  Quantity: '数量',
+  Amount: '金额',
+};

package/src/controller/bean.ts

@@ -0,0 +1,95 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import assert from 'node:assert';
+import { BeanBase, cast } from 'vona';
+import { Api } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+import { __ThisModule__ } from '../.metadata/this.ts';
+import { ServiceTest } from '../service/test.ts';
+
+export interface IControllerOptionsBean extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsBean>({ path: 'bean', meta: { mode: 'test' } })
+@Api.exclude()
+@Passport.public()
+export class ControllerBean extends BeanBase {
+  @Web.get('test')
+  async test() {
+    const a = 3;
+    const b = 4;
+    let res;
+
+    // app.bean
+    assert.equal(this.bean._getBean('test-vona.service.testApp'), this.bean['test-vona.service.testApp']);
+
+    res = this.bean['test-vona.service.testApp'].actionSync({ a, b });
+    assert.equal(res, `${a + b}:regexpaop`);
+
+    res = await this.bean['test-vona.service.testApp'].actionAsync({ a, b });
+    assert.equal(res, `${a + b}:regexpaop`);
+
+    // ctx.bean: global
+    assert.equal(this.bean.testCtx, this.bean.testCtx);
+
+    // magic
+    res = cast(this.bean.testCtx).magic;
+    assert.equal(res, 'magic:simpleaop');
+
+    // name
+    this.bean.testCtx.name = 'test-vona:simpleaop:regexpaop';
+    res = this.bean.testCtx.name;
+    assert.equal(res, 'test-vona:simpleaop:regexpaop');
+
+    res = this.bean.testCtx.actionSync({ a, b });
+    assert.equal(res, `${a + b}:simpleaop:regexpaop`);
+
+    res = await this.bean.testCtx.actionAsync({ a, b });
+    assert.equal(res, `${a + b}:simpleaop:regexpaop`);
+
+    res = await this.bean.testCtx.actionAsync2({ a, b });
+    assert.equal(res, `test-vona:simpleaop:regexpaop:${a + b}:simpleaop:regexpaop`);
+
+    res = await this.bean.testCtx.actionAsync3({ a, b });
+    assert.equal(res, `test-vona:simpleaop:regexpaop:${a + b}:simpleaop:regexpaop`);
+
+    // ctx.bean: class
+    assert.equal(this.bean['test-vona.service.testClass'], this.app.bean['test-vona.service.testClass']);
+
+    res = this.bean['test-vona.service.testClass'].actionSync({ a, b });
+    assert.equal(res, `${a + b}:regexpaop`);
+
+    res = await this.bean['test-vona.service.testClass'].actionAsync({ a, b });
+    assert.equal(res, `${a + b}:regexpaop`);
+
+    // magic of self
+    cast(this.bean.testCtx).magicSelf = '__magicSelf__';
+    res = cast(this.bean.testCtx).magicSelf;
+    assert.equal(res, '__magicSelf__');
+    res = cast(this.bean.testCtx)['magic:self'];
+    assert.equal(res, '__magicSelf__');
+  }
+
+  @Web.get('service')
+  @Passport.public()
+  async service() {
+    let res;
+
+    // general way
+    res = this.bean._getBean(ServiceTest).name;
+    assert.equal(res, 'serviceTest');
+
+    res = this.bean._getBean('test-vona.service.test').name;
+    assert.equal(res, 'serviceTest');
+
+    // this scope
+    res = this.scope.service.test.name;
+    assert.equal(res, 'serviceTest');
+
+    // general scope
+    res = this.bean.scope(__ThisModule__).service.test.name;
+    assert.equal(res, 'serviceTest');
+
+    res = this.$scope.testVona.service.test.name;
+    assert.equal(res, 'serviceTest');
+  }
+}

package/src/controller/cacheMem.ts

@@ -0,0 +1,63 @@
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+import assert from 'node:assert';
+import { sleep } from '@cabloy/utils';
+import { BeanBase, retry } from 'vona';
+import { Api } from 'vona-module-a-openapi';
+import { Passport } from 'vona-module-a-user';
+import { Controller, Web } from 'vona-module-a-web';
+
+export interface IControllerOptionsCacheMem extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsCacheMem>({ path: 'cacheMem', meta: { mode: 'test' } })
+@Api.exclude()
+@Passport.public()
+export class ControllerCacheMem extends BeanBase {
+  @Web.post()
+  async mem() {
+    let res;
+    let value;
+
+    // set/get
+    this.scope.cacheMem.test.set({ name: 'zhen.nann' }, '__immutable__');
+    value = this.scope.cacheMem.test.get('__immutable__');
+    assert.deepEqual(value, { name: 'zhen.nann' });
+    value.name = 'zhennann';
+    value = this.scope.cacheMem.test.get('__immutable__');
+    assert.deepEqual(value, { name: 'zhen.nann' });
+
+    // set
+    value = this.scope.cacheMem.test.getset('zhen.nann');
+    assert.equal(value, undefined);
+
+    value = this.scope.cacheMem.test.getset('zhennann');
+    assert.equal(value, 'zhen.nann');
+
+    // has
+    res = this.scope.cacheMem.test.has();
+    assert.equal(!!res, true);
+
+    // get
+    value = this.scope.cacheMem.test.get();
+    assert.equal(value, 'zhennann');
+
+    // del
+    this.scope.cacheMem.test.del();
+    res = this.scope.cacheMem.test.has();
+    assert.equal(res, false);
+
+    // set again
+    this.scope.cacheMem.test.set('zhennann'); // will be expired after 1s
+
+    // get
+    value = this.scope.cacheMem.test.get();
+    assert.equal(value, 'zhennann');
+
+    // peek after timeout
+    await sleep(900);
+    await retry({ retries: 3 }, async () => {
+      await sleep(100);
+      value = this.scope.cacheMem.test.peek();
+      assert.equal(value, undefined);
+    });
+  }
+}