cabloy 5.1.19 → 5.1.21

package/vona/src/suite-vendor/a-vona/modules/test-vona/src/model/userStats.ts

@@ -1,22 +0,0 @@
-import type { IDecoratorModelOptions } from 'vona-module-a-orm';
-
-import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
-
-import { EntityUser } from '../entity/user.ts';
-import { ModelPost } from './post.ts';
-
-export interface IModelOptionsUserStats extends IDecoratorModelOptions<EntityUser> {}
-
-@Model<IModelOptionsUserStats>({
-  entity: EntityUser,
-  relations: {
-    posts: $relation.hasMany(() => ModelPost, 'userId', {
-      autoload: true,
-      aggrs: { count: ['*', 'title'], sum: 'stars' },
-    }),
-    roles: $relation.belongsToMany('test-vona:roleUser', 'test-vona:role', 'userId', 'roleId', {
-      aggrs: { count: '*' },
-    }),
-  },
-})
-export class ModelUserStats extends BeanModelBase<EntityUser> {}

package/vona/src/suite-vendor/a-vona/modules/test-vona/src/model/userStatsGroup.ts

@@ -1,36 +0,0 @@
-import type { IDecoratorModelOptions } from 'vona-module-a-orm';
-
-import { $relation, BeanModelBase, Model } from 'vona-module-a-orm';
-
-import { EntityUser } from '../entity/user.ts';
-import { ModelPost } from './post.ts';
-
-export interface IModelOptionsUserStatsGroup extends IDecoratorModelOptions<EntityUser> {}
-
-@Model<IModelOptionsUserStatsGroup>({
-  entity: EntityUser,
-  relations: {
-    posts: $relation.hasMany(
-      () => ModelPost,
-      'userId',
-      {
-        autoload: true,
-        groups: ['title'],
-        aggrs: { count: ['*', 'title'], sum: 'stars' },
-        orders: [['title', 'desc']],
-      },
-      undefined,
-      true,
-    ),
-    roles: $relation.belongsToMany(
-      'test-vona:roleUser',
-      'test-vona:role',
-      'userId',
-      'roleId',
-      { groups: ['name'], aggrs: { count: '*' }, orders: [['name', 'asc']] },
-      undefined,
-      true,
-    ),
-  },
-})
-export class ModelUserStatsGroup extends BeanModelBase<EntityUser> {}

package/vona/src/suite-vendor/a-vona/modules/test-vona/src/service/aopMethod.ts

@@ -1,38 +0,0 @@
-import { BeanBase } from 'vona';
-import { Aspect } from 'vona-module-a-aspect';
-import { Service } from 'vona-module-a-bean';
-
-class ServiceAopMethodBase extends BeanBase {
-  @Aspect.aopMethod('test-vona:test', { wrapper: '+' })
-  @Aspect.aopMethod('test-vona:test', { wrapper: '-' })
-  testSyncBase() {
-    return 'hello';
-  }
-}
-
-@Service()
-export class ServiceAopMethod extends ServiceAopMethodBase {
-  private _name: string = '';
-
-  @Aspect.aopMethod('test-vona:test', { wrapper: '+' })
-  @Aspect.aopMethod('test-vona:test', { wrapper: '-' })
-  testSync() {
-    return 'hello';
-  }
-
-  @Aspect.aopMethod('test-vona:test', { wrapper: '+' })
-  @Aspect.aopMethod('test-vona:test', { wrapper: '-' })
-  async testAsync() {
-    return 'hello';
-  }
-
-  @Aspect.aopMethod('test-vona:test', { wrapper: '+' })
-  @Aspect.aopMethod('test-vona:test', { wrapper: '-' })
-  get name() {
-    return this._name;
-  }
-
-  set name(value) {
-    this._name = value;
-  }
-}

package/vona/src/suite-vendor/a-vona/modules/test-vona/src/service/caching.ts

@@ -1,89 +0,0 @@
-import type {
-  ICachingActionKeyInfo,
-  ICachingActionValueInfo,
-  TypeCachingActionOptions,
-} from 'vona-module-a-caching';
-
-import { cel } from '@cabloy/utils';
-import { BeanBase } from 'vona';
-import { Service } from 'vona-module-a-bean';
-import { Caching } from 'vona-module-a-caching';
-
-import type { TSummerCacheTestData } from '../bean/summerCache.test.ts';
-
-function cacheKeyFn(
-  this: ServiceCaching,
-  info: ICachingActionKeyInfo,
-  _options: TypeCachingActionOptions,
-): any {
-  return info.args[0];
-}
-
-@Service()
-export class ServiceCaching extends BeanBase {
-  cacheKey(info: ICachingActionKeyInfo, _options: TypeCachingActionOptions) {
-    return info.args[0];
-  }
-
-  cacheValue(info: ICachingActionValueInfo, _options: TypeCachingActionOptions) {
-    return info.args[1];
-  }
-
-  @Caching.get({ cacheName: 'test-vona:caching', cacheKeyFn: 'cacheKey' })
-  async get(id: number): Promise<TSummerCacheTestData> {
-    return {
-      id,
-      name: `name_${id}`,
-    };
-  }
-
-  @Caching.get({ cacheName: 'test-vona:caching', cacheKeyFn })
-  async get2(_id: number): Promise<TSummerCacheTestData> {
-    return undefined as any;
-  }
-
-  @Caching.get({ cacheName: 'test-vona:caching', cacheKey: cel('args[0]') })
-  async get3(_id: number): Promise<TSummerCacheTestData> {
-    return undefined as any;
-  }
-
-  // default cacheKey
-  @Caching.get({ cacheName: 'test-vona:caching' })
-  async get4(_id: number): Promise<TSummerCacheTestData> {
-    return undefined as any;
-  }
-
-  @Caching.set({
-    cacheName: 'test-vona:caching',
-    cacheKeyFn: 'cacheKey',
-    cacheValueFn: 'cacheValue',
-  })
-  async set(_id: number, _value: TSummerCacheTestData): Promise<void> {
-    // do nothing
-  }
-
-  //
-  @Caching.set({
-    cacheName: 'test-vona:caching',
-    cacheKey: cel('args[0]'),
-    cacheValue: cel('{"id": args[1].id, "name": args[1].name}'),
-  })
-  async set2(_id: number, _value: TSummerCacheTestData): Promise<void> {
-    // do nothing
-  }
-
-  @Caching.set({ cacheName: 'test-vona:caching', cacheKeyFn: 'cacheKey' })
-  async set3(_id: number, value: TSummerCacheTestData): Promise<TSummerCacheTestData> {
-    return value;
-  }
-
-  @Caching.del({ cacheName: 'test-vona:caching' })
-  async del(_id: number): Promise<void> {
-    // do nothing
-  }
-
-  @Caching.clear({ cacheName: 'test-vona:caching' })
-  async clear(): Promise<void> {
-    // do nothing
-  }
-}

package/vona/src/suite-vendor/a-vona/modules/test-vona/src/service/category.ts

@@ -1,153 +0,0 @@
-import assert from 'node:assert';
-import { BeanBase } from 'vona';
-import { Service } from 'vona-module-a-bean';
-import { $relationDynamic } from 'vona-module-a-orm';
-
-import { ModelCategory } from '../model/category.ts';
-
-@Service()
-export class ServiceCategory extends BeanBase {
-  async categoryTreeDynamic() {
-    // create
-    const treeCreate = await this.scope.model.category.insert(
-      {
-        name: 'Category-1',
-        children2: [
-          {
-            name: 'Category-1-1',
-            children2: [{ name: 'Category-1-1-1' }],
-          },
-          {
-            name: 'Category-1-2',
-          },
-        ],
-      },
-      {
-        with: {
-          children2: $relationDynamic.hasMany(() => ModelCategory, 'categoryIdParent', {
-            with: {
-              children2: $relationDynamic.hasMany(() => ModelCategory, 'categoryIdParent', {}),
-            },
-          }),
-        },
-      },
-    );
-    // get
-    const tree = await this.scope.model.category.get(
-      {
-        id: treeCreate.id,
-      },
-      {
-        with: {
-          children2: $relationDynamic.hasMany(() => ModelCategory, 'categoryIdParent', {
-            columns: ['id', 'name'],
-            with: {
-              children2: $relationDynamic.hasMany(() => ModelCategory, 'categoryIdParent', {
-                columns: ['id', 'name'],
-              }),
-            },
-          }),
-        },
-      },
-    );
-    assert.equal(tree?.children2.length, 2);
-    assert.equal(tree?.children2[0].children2.length, 1);
-    // update
-    await this.scope.model.category.update(
-      {
-        id: treeCreate.id,
-        name: 'Category-1-Update',
-        children2: [
-          // create
-          { name: 'Category-1-3' },
-          // update
-          { id: treeCreate.children2?.[0].id, name: 'Category-1-1-Update' },
-          // delete
-          { id: treeCreate.children2?.[1].id, deleted: true },
-        ],
-      },
-      {
-        with: {
-          children2: $relationDynamic.hasMany(() => ModelCategory, 'categoryIdParent'),
-        },
-      },
-    );
-    // delete
-    await this.scope.model.category.delete(
-      {
-        id: treeCreate.id,
-      },
-      {
-        with: {
-          children2: $relationDynamic.hasMany(() => ModelCategory, 'categoryIdParent', {
-            with: {
-              children2: $relationDynamic.hasMany(() => ModelCategory, 'categoryIdParent', {}),
-            },
-          }),
-        },
-      },
-    );
-  }
-
-  async categoryTreeReverse() {
-    // create
-    const treeCreate = await this.scope.model.category.insert({
-      name: 'Category-1',
-      children: [
-        {
-          name: 'Category-1-1',
-          children: [{ name: 'Category-1-1-1' }],
-        },
-        {
-          name: 'Category-1-2',
-        },
-      ],
-    });
-    // 'Category-1-1-1'
-    const subCategoryId = treeCreate.children?.[0].children?.[0].id;
-    // get: reverse
-    const subCategory = await this.scope.model.categoryChain.get({
-      id: subCategoryId,
-    });
-    assert.equal(subCategory?.parent?.parent?.id, treeCreate.id);
-  }
-
-  async categoryTree() {
-    // create
-    const treeCreate = await this.scope.model.category.insert({
-      name: 'Category-1',
-      children: [
-        {
-          name: 'Category-1-1',
-          children: [{ name: 'Category-1-1-1' }],
-        },
-        {
-          name: 'Category-1-2',
-        },
-      ],
-    });
-    // get
-    const tree = await this.scope.model.category.get({
-      id: treeCreate.id,
-    });
-    assert.equal(tree?.children.length, 2);
-    assert.equal(tree?.children[0].children.length, 1);
-    // update
-    await this.scope.model.category.update({
-      id: treeCreate.id,
-      name: 'Category-1-Update',
-      children: [
-        // create
-        { name: 'Category-1-3' },
-        // update
-        { id: treeCreate.children?.[0].id, name: 'Category-1-1-Update' },
-        // delete
-        { id: treeCreate.children?.[1].id, deleted: true },
-      ],
-    });
-    // delete
-    await this.scope.model.category.delete({
-      id: treeCreate.id,
-    });
-  }
-}

package/vona/src/suite-vendor/a-vona/modules/test-vona/src/service/order.ts

@@ -1,67 +0,0 @@
-import { BeanBase } from 'vona';
-import { Service } from 'vona-module-a-bean';
-import { $relationDynamic } from 'vona-module-a-orm';
-
-import { ModelProduct } from '../model/product.ts';
-
-@Service()
-export class ServiceOrder extends BeanBase {
-  async relationHasMany() {
-    // insert
-    const orderCreate = await this.scope.model.order.insert(
-      {
-        orderNo: 'Order001',
-        products2: [{ name: 'Apple' }, { name: 'Pear' }],
-      },
-      {
-        with: {
-          products2: $relationDynamic.hasMany(() => ModelProduct, 'orderId'),
-        },
-      },
-    );
-    // get
-    await this.scope.model.order.get(
-      {
-        id: orderCreate.id,
-      },
-      {
-        with: {
-          products2: $relationDynamic.hasMany(() => ModelProduct, 'orderId', {
-            columns: ['id', 'name', 'price', 'quantity', 'amount'],
-          }),
-        },
-      },
-    );
-    // update
-    await this.scope.model.order.update(
-      {
-        id: orderCreate.id,
-        orderNo: 'Order001-Update',
-        products2: [
-          // create product: Peach
-          { name: 'Peach' },
-          // update product: Apple
-          { id: orderCreate.products?.[0].id, name: 'Apple-Update' },
-          // delete product: Pear
-          { id: orderCreate.products?.[1].id, deleted: true },
-        ],
-      },
-      {
-        with: {
-          products2: $relationDynamic.hasMany(() => ModelProduct, 'orderId'),
-        },
-      },
-    );
-    // delete
-    await this.scope.model.order.delete(
-      {
-        id: orderCreate.id,
-      },
-      {
-        with: {
-          products2: $relationDynamic.hasMany(() => ModelProduct, 'orderId'),
-        },
-      },
-    );
-  }
-}

package/vona/src/suite-vendor/a-vona/modules/test-vona/src/service/post.ts

@@ -1,280 +0,0 @@
-import type { TableIdentity } from 'table-identity';
-import type { IQueryParams } from 'vona-module-a-orm';
-
-import { BeanBase } from 'vona';
-import { Service } from 'vona-module-a-bean';
-import { Core } from 'vona-module-a-core';
-import { $relationDynamic } from 'vona-module-a-orm';
-
-import { ModelPost } from '../model/post.ts';
-import { ModelPostContent } from '../model/postContent.ts';
-
-@Service()
-export class ServicePost extends BeanBase {
-  async findMany(params?: IQueryParams<ModelPost>) {
-    return await this.scope.model.post.selectAndCount({
-      ...params,
-      include: { postContent: true },
-    });
-  }
-
-  async group() {
-    const result = await this.scope.model.post.group({
-      groups: 'userId',
-      aggrs: {
-        count: '*',
-        sum: 'stars',
-      },
-      orders: [['count_all', 'desc']],
-    });
-    return result;
-  }
-
-  async aggregate() {
-    const result = await this.scope.model.post.aggregate({
-      aggrs: {
-        count: ['*', 'stars'],
-        sum: 'stars',
-        avg: 'stars',
-        min: 'stars',
-        max: 'stars',
-      },
-    });
-    return result;
-  }
-
-  async count() {
-    return await this.scope.model.post.count();
-  }
-
-  async relationBelongsTo() {
-    const postContent = await this.scope.model.postContent.select({
-      with: {
-        post: $relationDynamic.belongsTo(
-          () => ModelPostContent,
-          () => ModelPost,
-          'postId',
-          {
-            columns: ['id', 'title'],
-          },
-        ),
-      },
-    });
-    // eslint-disable-next-line no-console
-    console.log(postContent[0]?.post?.title);
-  }
-
-  async relationHasOne() {
-    // insert
-    const postCreate = await this.scope.model.post.insert(
-      {
-        title: 'Post001',
-        postContent: {
-          content: 'This is a post',
-        },
-      },
-      {
-        with: {
-          postContent: $relationDynamic.hasOne(() => ModelPostContent, 'postId', {
-            columns: ['id', 'content'],
-          }),
-        },
-      },
-    );
-    // get
-    const post = await this.scope.model.post.get(
-      {
-        id: postCreate.id,
-      },
-      {
-        with: {
-          postContent: $relationDynamic.hasOne(() => ModelPostContent, 'postId', {
-            columns: ['id', 'content'],
-          }),
-        },
-      },
-    );
-    // update
-    await this.scope.model.post.update(
-      {
-        id: postCreate.id,
-        title: 'Post001-Update',
-        postContent: {
-          content: 'This is a post-changed',
-        },
-      },
-      {
-        with: {
-          postContent: $relationDynamic.hasOne(() => ModelPostContent, 'postId', {
-            columns: ['id', 'content'],
-          }),
-        },
-      },
-    );
-    // delete
-    await this.scope.model.post.delete(
-      {
-        id: postCreate.id,
-      },
-      {
-        with: {
-          postContent: $relationDynamic.hasOne(() => ModelPostContent, 'postId'),
-        },
-      },
-    );
-    // eslint-disable-next-line no-console
-    console.log(post?.postContent?.id);
-  }
-
-  @Core.transaction()
-  async transaction() {
-    // insert
-    const post = await this.scope.model.post.insert({
-      title: 'Post001',
-    });
-    // cache
-    await this.scope.cacheRedis.post.set(post, post.id);
-  }
-
-  async transactionManually() {
-    const db = this.bean.database.getDb({ clientName: 'default' });
-    await db.transaction.begin(async () => {
-      const modelPost = this.scope.model.post.newInstance(db);
-      const post = await modelPost.insert({ title: 'Post001' });
-      await this.scope.cacheRedis.post.set(post, post.id, { db });
-    });
-  }
-
-  async create() {
-    const post = await this.scope.model.post.insert({
-      title: 'Post001',
-    });
-    // console.log(post.id);
-    return post;
-  }
-
-  async createBulk() {
-    const posts = await this.scope.model.post.insertBulk([
-      { title: 'Post001' },
-      { title: 'Post002' },
-    ]);
-    // console.log(posts[0].id, posts[1].id);
-    return posts;
-  }
-
-  async update() {
-    const post = await this.scope.model.post.update({
-      id: 1,
-      title: 'Post001-Update',
-    });
-    return post;
-  }
-
-  async update2() {
-    const post = await this.scope.model.post.update(
-      {
-        title: 'Post001-Update',
-      },
-      {
-        where: {
-          title: { _startsWith_: 'Post001' },
-        },
-      },
-    );
-    return post;
-  }
-
-  async updateBulk() {
-    const posts = await this.scope.model.post.updateBulk([
-      { id: 1, title: 'Post001-Update' },
-      { id: 2, title: 'Post002-Update' },
-    ]);
-    return posts;
-  }
-
-  async delete() {
-    await this.scope.model.post.delete({
-      id: 1,
-    });
-  }
-
-  async delete2() {
-    await this.scope.model.post.delete({
-      title: {
-        _startsWith_: 'Post',
-      },
-    });
-  }
-
-  async deleteBulk() {
-    await this.scope.model.post.deleteBulk([1, 2]);
-  }
-
-  async mutate() {
-    // insert
-    const post = await this.scope.model.post.mutate({
-      title: 'Post001',
-    });
-    // update
-    await this.scope.model.post.mutate({
-      id: post.id,
-      title: 'Post001-Update',
-    });
-    // delete
-    await this.scope.model.post.mutate({
-      id: post.id,
-      deleted: true,
-    });
-  }
-
-  async mutateBulk() {
-    await this.scope.model.post.mutateBulk([
-      // insert
-      { title: 'Post003' },
-      // update
-      { id: 1, title: 'Post001-Update' },
-      // delete
-      { id: 2, deleted: true },
-    ]);
-  }
-
-  async select() {
-    return await this.scope.model.post.select({
-      where: {
-        stars: '_skip_',
-      },
-    });
-  }
-
-  async select2() {
-    return await this.scope.model.post.select(
-      {
-        columns: ['id', 'title', 'userId'],
-        where: {
-          'id': { _gt_: 1 },
-          'testVonaUser.id': 1,
-        },
-        joins: [['innerJoin', 'testVonaUser', ['userId', 'testVonaUser.id']]],
-        offset: 0,
-        limit: 20,
-        orders: [['createdAt', 'desc']],
-      },
-      {
-        disableDeleted: false,
-      },
-      'test-vona:user',
-    );
-  }
-
-  async get(id: TableIdentity) {
-    return await this.scope.model.post.getById(id);
-  }
-
-  async mget(ids: TableIdentity[]) {
-    return await this.scope.model.post.mget(ids);
-  }
-
-  // async count() {
-  //   return await this.scope.model.post.count();
-  // }
-}

package/vona/src/suite-vendor/a-vona/modules/test-vona/src/service/product.ts

@@ -1,5 +0,0 @@
-import { BeanBase } from 'vona';
-import { Service } from 'vona-module-a-bean';
-
-@Service()
-export class ServiceProduct extends BeanBase {}

package/vona/src/suite-vendor/a-vona/modules/test-vona/src/service/test.ts

@@ -1,9 +0,0 @@
-import { BeanBase } from 'vona';
-import { Service } from 'vona-module-a-bean';
-
-@Service()
-export class ServiceTest extends BeanBase {
-  get name() {
-    return 'serviceTest';
-  }
-}