vona-module-test-vona 5.0.39 → 5.0.42

package/src/service/category.ts

@@ -0,0 +1,72 @@
+import assert from 'node:assert';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceCategory extends BeanBase {
+  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/src/service/order.ts

@@ -0,0 +1,65 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceOrder extends BeanBase {
+  async relationHasMany() {
+    // insert
+    const orderCreate = await this.scope.model.order.insert(
+      {
+        orderNo: 'Order001',
+        products: [
+          { name: 'Apple' },
+          { name: 'Pear' },
+        ],
+      },
+      {
+        include: {
+          products: true,
+        },
+      },
+    );
+    // get
+    await this.scope.model.order.get(
+      {
+        id: orderCreate.id,
+      },
+      {
+        include: {
+          products: true,
+        },
+      },
+    );
+    // update
+    await this.scope.model.order.update(
+      {
+        id: orderCreate.id,
+        orderNo: 'Order001-Update',
+        products: [
+          // 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 },
+        ],
+      },
+      {
+        include: {
+          products: true,
+        },
+      },
+    );
+    // delete
+    await this.scope.model.order.delete(
+      {
+        id: orderCreate.id,
+      },
+      {
+        include: {
+          products: true,
+        },
+      },
+    );
+  }
+}

package/src/service/post.ts

@@ -0,0 +1,219 @@
+import type { TableIdentity } from 'table-identity';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Database } from 'vona-module-a-orm';
+
+@Service()
+export class ServicePost extends BeanBase {
+  async relationBelongsTo() {
+    const postContent = await this.scope.model.postContent.select({
+      include: {
+        post: true,
+      },
+    });
+    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',
+        },
+      },
+      {
+        include: {
+          postContent: true,
+        },
+      },
+    );
+    // get
+    const post = await this.scope.model.post.get(
+      {
+        id: postCreate.id,
+      },
+      {
+        include: {
+          postContent: true,
+        },
+      },
+    );
+    // update
+    await this.scope.model.post.update(
+      {
+        id: postCreate.id,
+        title: 'Post001-Update',
+        postContent: {
+          content: 'This is a post-changed',
+        },
+      },
+      {
+        include: {
+          postContent: true,
+        },
+      },
+    );
+    // delete
+    await this.scope.model.post.delete(
+      {
+        id: postCreate.id,
+      },
+      {
+        include: {
+          postContent: true,
+        },
+      },
+    );
+    console.log(post?.postContent?.id);
+  }
+
+  @Database.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.get({ id });
+  }
+
+  async mget(ids: TableIdentity[]) {
+    return await this.scope.model.post.mget(ids);
+  }
+
+  async count() {
+    return await this.scope.model.post.count();
+  }
+}

package/src/service/test.ts

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

package/src/service/testApp.ts

@@ -0,0 +1,13 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceTestApp extends BeanBase {
+  actionSync({ a, b }: any) {
+    return a + b;
+  }
+
+  async actionAsync({ a, b }: any) {
+    return Promise.resolve(a + b);
+  }
+}

package/src/service/testClass.ts

@@ -0,0 +1,15 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+class ClassBeanBase extends BeanBase {
+  actionSync({ a, b }: any) {
+    return a + b;
+  }
+}
+
+@Service()
+export class ServiceTestClass extends ClassBeanBase {
+  async actionAsync({ a, b }: any) {
+    return Promise.resolve(a + b);
+  }
+}

package/src/service/testData.ts

@@ -0,0 +1,67 @@
+import type { EntityRole } from 'vona-module-home-user';
+import type { EntityPost } from '../entity/post.ts';
+import type { EntityPostContent } from '../entity/postContent.ts';
+import type { EntityUser } from '../entity/user.ts';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+export interface ITestData {
+  userTom: EntityUser;
+  userJimmy: EntityUser;
+  roleFamily: EntityRole;
+  roleFriend: EntityRole;
+  postApple: EntityPost;
+  postPear: EntityPost;
+  postContentApple: EntityPostContent;
+}
+
+@Service()
+export class ServiceTestData extends BeanBase {
+  async create(prefix: string): Promise<ITestData> {
+    const scopeTest = this.scope;
+    const userTom = await scopeTest.model.user.insert({ name: `${prefix}:tom` });
+    const userJimmy = await scopeTest.model.user.insert({ name: `${prefix}:jimmy` });
+    const roleFamily = await scopeTest.model.role.insert({ name: `${prefix}:family` });
+    const roleFriend = await scopeTest.model.role.insert({ name: `${prefix}:friend` });
+    await scopeTest.model.roleUser.insertBulk([
+      { userId: userTom.id, roleId: roleFamily.id },
+      { userId: userTom.id, roleId: roleFriend.id },
+      { userId: userJimmy.id, roleId: roleFamily.id },
+    ]);
+    const postApple = await scopeTest.model.post.insert({ title: `${prefix}:postApple`, userId: userTom.id });
+    const postPear = await scopeTest.model.post.insert({ title: `${prefix}:postPear`, userId: userTom.id });
+    const postContentApple = await scopeTest.model.postContent.insert({ content: `${prefix}:postContentApple`, postId: postApple.id });
+    // ok
+    return {
+      userTom,
+      userJimmy,
+      roleFamily,
+      roleFriend,
+      postApple,
+      postPear,
+      postContentApple,
+    };
+  }
+
+  async drop(data: ITestData) {
+    const {
+      userTom,
+      userJimmy,
+      roleFamily,
+      roleFriend,
+      postApple,
+      postPear,
+      postContentApple,
+    } = data;
+    const scopeTest = this.scope;
+    await scopeTest.model.postContent.delete({ id: postContentApple.id });
+    await scopeTest.model.post.delete({ id: postApple.id });
+    await scopeTest.model.post.delete({ id: postPear.id });
+    await scopeTest.model.roleUser.delete({ userId: userTom.id });
+    await scopeTest.model.roleUser.delete({ userId: userJimmy.id });
+    await scopeTest.model.role.delete({ id: roleFamily.id });
+    await scopeTest.model.role.delete({ id: roleFriend.id });
+    await scopeTest.model.user.delete({ id: userTom.id });
+    await scopeTest.model.user.delete({ id: userJimmy.id });
+  }
+}

package/src/service/transaction.ts

@@ -0,0 +1,20 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { Database } from 'vona-module-a-orm';
+
+const tableNameFail = '__tempTransactionFail';
+const tableNameSuccess = '__tempTransactionSuccess';
+
+@Service()
+export class ServiceTransaction extends BeanBase {
+  @Database.transaction()
+  async fail(item: object) {
+    await this.bean.model.update(`${tableNameFail}` as any, item);
+    await this.bean.model.update(`${tableNameFail}error` as any, item);
+  }
+
+  @Database.transaction()
+  async success(item: object) {
+    await this.bean.model.update(tableNameSuccess as any, item);
+  }
+}

package/src/service/user.ts

@@ -0,0 +1,68 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceUser extends BeanBase {
+  async relationBelongsToMany() {
+    // insert: roles
+    const roles = await this.scope.model.role.insertBulk([
+      { name: 'role-family' },
+      { name: 'role-friend' },
+    ]);
+    const roleIdFamily = roles[0].id;
+    const roleIdFriend = roles[1].id;
+    // insert: user
+    const userCreate = await this.scope.model.user.insert(
+      {
+        name: 'Tom',
+        roles: [{
+          id: roleIdFamily,
+        }],
+      },
+      {
+        include: {
+          roles: true,
+        },
+      },
+    );
+    // get: user
+    await this.scope.model.user.get(
+      {
+        id: userCreate.id,
+      },
+      {
+        include: {
+          roles: true,
+        },
+      },
+    );
+    // update: user
+    await this.scope.model.user.update(
+      {
+        id: userCreate.id,
+        roles: [
+          // delete
+          { id: roleIdFamily, deleted: true },
+          // insert
+          { id: roleIdFriend },
+        ],
+      },
+      {
+        include: {
+          roles: true,
+        },
+      },
+    );
+    // delete: user
+    await this.scope.model.user.delete(
+      {
+        id: userCreate.id,
+      },
+      {
+        include: {
+          roles: true,
+        },
+      },
+    );
+  }
+}

package/test/aopMethod.test.ts

@@ -0,0 +1,21 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('aopMethod.test.ts', () => {
+  it('action:aopMethod', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // scope
+      const scopeTest = app.bean.scope('test-vona');
+      let result = scopeTest.service.aopMethod.testSyncBase();
+      assert.equal(result, '-+hello+-');
+      result = scopeTest.service.aopMethod.testSync();
+      assert.equal(result, '-+hello+-');
+      result = await scopeTest.service.aopMethod.testAsync();
+      assert.equal(result, '-+hello+-');
+      scopeTest.service.aopMethod.name = '-+vona+-';
+      result = scopeTest.service.aopMethod.name;
+      assert.equal(result, '-+vona+-');
+    });
+  });
+});

package/test/authSimple.test.ts

@@ -0,0 +1,45 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { catchError } from '@cabloy/utils';
+import { app } from 'vona-mock';
+
+describe('authSimple.test.ts', () => {
+  it('action:passwordHash', async () => {
+    const scope = app.bean.scope('a-authsimple');
+    const password = '12344##1xxaasDFQ,.$';
+    const hash = await scope.service.authSimple.calcPasswordHash(password);
+    let verified = await scope.service.authSimple.verifyPasswordHash(password, hash);
+    assert.equal(verified, true);
+    verified = await scope.service.authSimple.verifyPasswordHash(`${password}failed`, hash);
+    assert.equal(verified, false);
+  });
+
+  it('action:authSimple', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      // login
+      const jwt = await app.bean.auth.authenticate('a-authsimple:simple', {
+        clientName: 'default',
+        clientOptions: { username: 'admin', password: '123456' },
+      });
+      assert.equal(!!jwt?.accessToken, true);
+      // isAuthenticated: isolate
+      const [isAuthenticated2, _err] = await catchError(async () => {
+        return await app.bean.executor.newCtxIsolate(async () => {
+          return await app.bean.executor.performAction('get', '/test/vona/passport/isAuthenticated');
+        });
+      });
+      assert.equal(isAuthenticated2, undefined);
+      // isAuthenticated: isolate + header
+      const isAuthenticated = await app.bean.executor.newCtxIsolate(async () => {
+        return await app.bean.executor.performAction('get', '/test/vona/passport/isAuthenticated', { authToken: jwt?.accessToken });
+      });
+      assert.equal(isAuthenticated, true);
+      // login again
+      const jwt2 = await app.bean.authSimple.authenticate(
+        { username: 'admin', password: '123456' },
+        'default',
+      );
+      assert.equal(!!jwt2?.accessToken, true);
+    });
+  });
+});

package/test/bean.test.ts

@@ -0,0 +1,16 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('bean.test.ts', () => {
+  it('action:bean', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('get', '/test/vona/bean/test');
+    });
+  });
+
+  it('action:service', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('get', '/test/vona/bean/service');
+    });
+  });
+});

package/test/broadcast.test.ts

@@ -0,0 +1,17 @@
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('broadcast.test.ts', () => {
+  it('action:broadcast', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      app.bean.scope('test-vona').broadcast.test.emit(
+        { message: 'hello' },
+        {
+          locale: 'zh-cn',
+        },
+      );
+      assert.equal(app.ctx.instanceName, '');
+    });
+  });
+});

package/test/cache/cacheMem.test.ts

@@ -0,0 +1,10 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('cacheMem.test.ts', () => {
+  it('action:cacheMem', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('post', '/test/vona/cacheMem');
+    });
+  });
+});

package/test/cache/cacheRedis.test.ts

@@ -0,0 +1,10 @@
+import { describe, it } from 'node:test';
+import { app } from 'vona-mock';
+
+describe('cacheRedis.test.ts', () => {
+  it('action:cacheRedis', async () => {
+    await app.bean.executor.mockCtx(async () => {
+      await app.bean.executor.performAction('post', '/test/vona/cacheRedis');
+    });
+  });
+});