cabloy 5.1.20 → 5.1.21

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

@@ -1,248 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { cast } from 'vona';
-import { app } from 'vona-mock';
-import { $relationDynamic } from 'vona-module-a-orm';
-import { ModelPost, ModelRole, ModelRoleUser } from 'vona-module-test-vona';
-
-describe('modelGroup.test.ts', () => {
-  it('action:modelGroup', async () => {
-    await app.bean.executor.mockCtx(async () => {
-      const prefix = 'action:modelGroup';
-      // scope
-      const scopeTest = app.scope('test-vona');
-      // insert: roles
-      const roles = await scopeTest.model.role.insertBulk([
-        { name: `${prefix}:family` },
-        { name: `${prefix}:friend` },
-      ]);
-      assert.equal(roles.length, 2);
-      assert.equal(roles[0].id !== undefined, true);
-      // create: users
-      const users = await scopeTest.model.user.insertBulk(
-        [
-          {
-            name: `${prefix}:tom`,
-            age: 3,
-            posts: [
-              {
-                title: `${prefix}:postApple`,
-                stars: 2,
-                postContent: {
-                  content: `${prefix}:postContentApple`,
-                },
-              },
-              {
-                title: `${prefix}:postApple2`,
-                stars: 3,
-                postContent: {
-                  content: `${prefix}:postContentApple2`,
-                },
-              },
-            ],
-            roles: [
-              {
-                id: roles[0].id,
-              },
-            ],
-          },
-          {
-            name: `${prefix}:jimmy`,
-            age: 5,
-            posts: [
-              {
-                title: `${prefix}:postPear`,
-                stars: 4,
-                postContent: {
-                  content: `${prefix}:postContentPear`,
-                },
-              },
-            ],
-          },
-          { name: `${prefix}:mike` },
-        ],
-        {
-          include: {
-            posts: { include: { postContent: true } },
-            roles: true,
-          },
-        },
-      );
-      // group: user
-      const usersGroup = await scopeTest.model.user.group({
-        groups: ['name'],
-        aggrs: {
-          count: ['*', 'age'],
-          sum: ['age'],
-          avg: 'age',
-          max: 'age',
-        },
-        where: {
-          name: { _startsWith_: `${prefix}:` },
-        },
-        having: {
-          _and_: {
-            name: { _startsWith_: `${prefix}:` },
-            max_age: { _isNot_: null },
-          },
-          count_all: { _gt_: 0 },
-        },
-        orders: [['max_age', 'desc']],
-      });
-      assert.equal(usersGroup.length, 2);
-      assert.equal(usersGroup[0].name, `${prefix}:jimmy`);
-      assert.equal(usersGroup[0].count_all, 1);
-      assert.equal(usersGroup[0].count_age, 1);
-      assert.equal(usersGroup[0].sum_age, 5);
-      assert.equal(usersGroup[0].avg_age, 5);
-      assert.equal(usersGroup[0].max_age, 5);
-      // group: usersStats: posts: autoload
-      const usersStats = await scopeTest.model.userStatsGroup.select({
-        where: {
-          id: users.map(item => item.id),
-        },
-        orders: [['id', 'asc']],
-        include: {
-          roles: true,
-        },
-      });
-      assert.equal(usersStats.length, 3);
-      assert.equal(usersStats[0].posts[0].title, `${prefix}:postApple2`);
-      assert.equal(usersStats[0].posts[0].count_all, 1);
-      assert.equal(usersStats[0].posts[0].count_title, 1);
-      assert.equal(usersStats[0].posts[0].sum_stars, 3);
-      assert.equal(usersStats[0].roles[0].count_all, 1);
-      // group: usersStats: posts: mixed
-      const usersStats2 = await scopeTest.model.userStatsGroup.select({
-        where: {
-          id: users.map(item => item.id),
-        },
-        orders: [['id', 'asc']],
-        include: {
-          posts: { aggrs: { count: '*' } },
-          roles: true,
-        },
-      });
-      assert.equal(usersStats2.length, 3);
-      assert.equal(usersStats2[0].posts[0].title, `${prefix}:postApple2`);
-      assert.equal(usersStats2[0].posts[0].count_all, 1);
-      assert.equal(cast(usersStats2[0].posts[0]).count_title, undefined);
-      assert.equal(usersStats2[0].posts[0].sum_stars, 3);
-      assert.equal(usersStats2[0].roles[0].count_all, 1);
-      // group: usersStats: posts: disable
-      const usersStats3 = await scopeTest.model.userStatsGroup.select({
-        where: {
-          id: users.map(item => item.id),
-        },
-        orders: [['id', 'asc']],
-        include: {
-          posts: {
-            aggrs: {
-              count: ['*'],
-              sum: [],
-            },
-          },
-          roles: true,
-        },
-      });
-      assert.equal(usersStats3.length, 3);
-      assert.equal(usersStats3[0].posts[0].title, `${prefix}:postApple2`);
-      assert.equal(usersStats3[0].posts[0].count_all, 1);
-      assert.equal(cast(usersStats3[0].posts[0]).count_title, undefined);
-      assert.equal(cast(usersStats3[0].posts[0]).sum_stars, undefined);
-      assert.equal(usersStats3[0].roles[0].count_all, 1);
-      // group: usersStats: with
-      const usersStats4 = await scopeTest.model.userStatsGroup.select({
-        where: {
-          id: users.map(item => item.id),
-        },
-        orders: [['id', 'asc']],
-        include: {
-          posts: false,
-          roles: false,
-        },
-        with: {
-          posts: $relationDynamic.hasMany(
-            () => ModelPost,
-            'userId',
-            {
-              groups: ['title'],
-              aggrs: { count: '*' },
-              orders: [['title', 'desc']],
-            },
-            undefined,
-            true,
-          ),
-          roles: $relationDynamic.belongsToMany(
-            () => ModelRoleUser,
-            () => ModelRole,
-            'userId',
-            'roleId',
-            {
-              groups: 'name',
-              aggrs: { count: '*' },
-            },
-          ),
-        },
-      });
-      assert.equal(usersStats4.length, 3);
-      assert.equal(usersStats4[0].posts[0].title, `${prefix}:postApple2`);
-      assert.equal(usersStats4[0].posts[0].count_all, 1);
-      assert.equal(cast(usersStats4[0].posts[0]).count_title, undefined);
-      assert.equal(cast(usersStats4[0].posts[0]).sum_stars, undefined);
-      assert.equal(usersStats4[0].roles[0].count_all, 1);
-      // group: get
-      const userStats4 = await scopeTest.model.userStatsGroup.get(
-        {
-          id: users[0].id,
-        },
-        {
-          include: {
-            posts: false,
-            roles: false,
-          },
-          with: {
-            posts: $relationDynamic.hasMany(
-              () => ModelPost,
-              'userId',
-              {
-                groups: ['title'],
-                aggrs: { count: '*' },
-                orders: [['title', 'desc']],
-              },
-              undefined,
-              true,
-            ),
-            roles: $relationDynamic.belongsToMany(
-              () => ModelRoleUser,
-              () => ModelRole,
-              'userId',
-              'roleId',
-              {
-                groups: 'name',
-                aggrs: { count: '*' },
-              },
-            ),
-          },
-        },
-      );
-      assert.equal(userStats4?.posts[0].title, `${prefix}:postApple2`);
-      assert.equal(userStats4?.posts[0].count_all, 1);
-      assert.equal(cast(userStats4?.posts[0]).count_title, undefined);
-      assert.equal(cast(userStats4?.posts[0]).sum_stars, undefined);
-      assert.equal(userStats4?.roles[0].count_all, 1);
-      // delete: users
-      await scopeTest.model.user.deleteBulk(
-        users.map(item => item.id),
-        {
-          include: {
-            posts: { include: { postContent: true } },
-            roles: true,
-          },
-        },
-      );
-      // delete: roles
-      await scopeTest.model.role.deleteBulk(roles.map(item => item.id));
-    });
-  });
-});

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

@@ -1,37 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { app } from 'vona-mock';
-
-describe('modelMagic.test.ts', () => {
-  it('action:modelMagic', async () => {
-    await app.bean.executor.mockCtx(async () => {
-      const name = 'modelMagic:001';
-      // scope
-      const scopeTest = app.scope('test-vona');
-      // create
-      const item = await scopeTest.model.user.insert({ name });
-      assert.equal(item.name, name);
-      // getById
-      let user = await scopeTest.model.user.getById(item.id);
-      assert.equal(user?.name, name);
-      // getByName
-      user = await scopeTest.model.user.getByName(name);
-      assert.equal(user?.name, name);
-      user = await scopeTest.model.user.getByNameEqI(name.toUpperCase());
-      assert.equal(user?.name, name);
-      const users = await scopeTest.model.user.selectByName(name);
-      assert.equal(users[0].name, name);
-      const users2 = await scopeTest.model.user.selectByName(name, {
-        where: { id: item.id },
-        columns: ['age', 'name'],
-      });
-      assert.equal(users2[0].name, name);
-      // updateById
-      await scopeTest.model.user.updateById(item.id, { age: 18 });
-      user = await scopeTest.model.user.getById(item.id);
-      assert.equal(user?.age, 18);
-      // deleteById
-      await scopeTest.model.user.deleteById(item.id);
-    });
-  });
-});

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

@@ -1,215 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { cast } from 'vona';
-import { app } from 'vona-mock';
-import { $relationDynamic } from 'vona-module-a-orm';
-import { ModelPost, ModelPostContent, ModelUser } from 'vona-module-test-vona';
-
-describe('modelRelations.test.ts', () => {
-  it('action:modelRelations', async () => {
-    await app.bean.executor.mockCtx(async () => {
-      const prefix = 'action:modelRelations';
-      // scope
-      const scopeTest = app.scope('test-vona');
-      // test data: create
-      const testData = await scopeTest.service.testData.create(prefix);
-      const { userTom, userJimmy, roleFamily, roleFriend, postApple, postPear, postContentApple } =
-        testData;
-      // relation: hasOne
-      const posts = await scopeTest.model.post.select({
-        columns: ['id', 'title', 'userId'],
-        where: {
-          id: [postApple.id, postPear.id],
-        },
-        orders: [['id', 'asc']],
-        include: { postContent: true },
-      });
-      assert.equal(posts.length, 2);
-      assert.equal(posts[0].postContent?.content, 'action:modelRelations:postContentApple');
-      assert.equal(cast(posts[0].postContent)?.iid, undefined);
-      assert.equal(posts[1].postContent, undefined);
-      // relation: hasOne: get
-      const postGet = await scopeTest.model.post.get(
-        { id: postApple.id },
-        { columns: 'id', include: { postContent: true } },
-      );
-      assert.equal(cast(postGet)?.iid, undefined);
-      assert.equal(postGet?.postContent?.content, 'action:modelRelations:postContentApple');
-      // relation: hasOne: columns
-      const postGetColumns = await scopeTest.model.post.get(
-        { id: postApple.id },
-        { columns: ['id'], include: { postContent: { columns: ['id'] } } },
-      );
-      assert.equal(cast(postGetColumns?.postContent)?.content, undefined);
-      assert.equal(Object.keys(postGetColumns!.postContent!).length, 1);
-      assert.equal(Object.keys(postGetColumns!).length, 1 + 2); // .user + .postContent
-      // relation: belongsTo
-      const postContents = await scopeTest.model.postContent.select({
-        where: {
-          id: postContentApple.id,
-        },
-        include: { post: true },
-      });
-      assert.equal(postContents.length, 1);
-      assert.equal(postContents[0].post?.title, 'action:modelRelations:postApple');
-      // relation: belongsTo: get
-      const postContentGet = await scopeTest.model.postContent.get(
-        { id: postContentApple.id },
-        { include: { post: true } },
-      );
-      assert.equal(postContentGet?.post?.title, 'action:modelRelations:postApple');
-      // relation: belongsTo: autoload
-      const postAutoload = await scopeTest.model.post.get({ id: postApple.id });
-      assert.equal(postAutoload!.user?.id, postAutoload!.userId);
-      assert.equal(cast(postAutoload?.user)?.iid, undefined);
-      assert.equal(Object.keys(postAutoload!.user!).length, 2); // id + name
-      // relation: hasMany
-      const users = await scopeTest.model.user.select({
-        where: {
-          id: [userTom.id, userJimmy.id],
-        },
-        orders: [['id', 'asc']],
-        include: { posts: true },
-      });
-      assert.equal(users.length, 2);
-      assert.equal(users[0].posts.length, 2);
-      assert.equal(users[1].posts.length, 0);
-      // relation: hasMany: options.where/orders
-      const userOptions = await scopeTest.model.user.select({
-        where: {
-          id: [userTom.id, userJimmy.id],
-        },
-        orders: [['id', 'asc']],
-        include: {
-          posts: {
-            where: {
-              id: { _in_: [postApple.id, postPear.id] },
-            },
-            orders: [['id', 'desc']],
-          },
-        },
-      });
-      assert.equal(userOptions.length, 2);
-      assert.equal(userOptions[0].posts.length, 2);
-      assert.equal(userOptions[1].posts.length, 0);
-      assert.equal(cast(userOptions[0].posts[0]).iid, undefined);
-      assert.equal(
-        Number.parseInt(userOptions[0].posts[0].id as any) >
-          Number.parseInt(userOptions[0].posts[1].id as any),
-        true,
-      );
-      // relation: hasMany: options.where/orders
-      const userOptions2 = await scopeTest.model.user.select({
-        where: {
-          id: [userTom.id, userJimmy.id],
-        },
-        orders: [['id', 'asc']],
-        include: {
-          posts: {
-            joins: [
-              [
-                'innerJoin',
-                'testVonaPostContent',
-                ['testVonaPost.id', 'testVonaPostContent.postId'],
-              ],
-            ],
-            where: {
-              'testVonaPost.id': { _in_: [postApple.id, postPear.id] },
-              '_and_': { 'testVonaPost.id': { _notIn_: [postApple.id, postPear.id] } },
-              'testVonaPostContent.id': [postContentApple.id],
-            },
-            orders: [['testVonaPost.id', 'desc']],
-          },
-          roles: true,
-        },
-      });
-      assert.equal(userOptions2.length, 2);
-      assert.equal(userOptions2[0].posts.length, 0);
-      assert.equal(userOptions2[1].posts.length, 0);
-      // relation: hasMany: get
-      const userGet = await scopeTest.model.user.get(
-        { id: userTom.id },
-        { include: { posts: true } },
-      );
-      assert.equal(userGet?.posts.length, 2);
-      // relation: belongsToMany
-      const roles = await scopeTest.model.role.select({
-        where: {
-          id: [roleFamily.id, roleFriend.id],
-        },
-        orders: [['id', 'asc']],
-        include: { users: true },
-      });
-      assert.equal(roles.length, 2);
-      assert.equal(roles[0].users.length, 2);
-      assert.equal(roles[1].users.length, 1);
-      // relation: belongsToMany: get
-      const roleGet = await scopeTest.model.role.get(
-        { id: roleFamily.id },
-        { include: { users: true } },
-      );
-      assert.equal(roleGet?.users.length, 2);
-      assert.equal(cast(roleGet?.users[0]).iid, undefined);
-      // relation: belongsToMany: mget
-      const roles2 = await scopeTest.model.role.mget([roleFamily.id, roleFriend.id], {
-        columns: ['id', 'name'],
-        include: { users: true },
-      });
-      assert.equal(roles2.length, 2);
-      assert.equal(cast(roles2[0]).iid, undefined);
-      assert.equal(roles2[0].users.length, 2);
-      assert.equal(roles2[1].users.length, 1);
-      // relation: include + with
-      const items = await scopeTest.model.post.select({
-        where: {
-          id: postApple.id,
-        },
-        include: {
-          postContent: {
-            include: {
-              post: { include: { user: { columns: ['id'] } }, meta: { client: '_auto_' } },
-            },
-            with: {
-              post3: $relationDynamic.belongsTo(
-                () => ModelPostContent,
-                () => ModelPost,
-                'postId',
-                {
-                  include: {
-                    postContent: true,
-                  },
-                },
-              ),
-            },
-          },
-        },
-        with: {
-          user3: $relationDynamic.belongsTo(ModelPost, () => ModelUser, 'userId', {
-            include: { posts: true },
-            with: {
-              roles: $relationDynamic.belongsToMany(
-                'test-vona:roleUser',
-                'test-vona:role',
-                'userId',
-                'roleId',
-                {
-                  columns: ['id', 'name'],
-                  meta: { client: '_auto_' },
-                },
-              ),
-            },
-            columns: ['id', 'name'],
-          }),
-        },
-      });
-      assert.equal(Object.keys(items[0].postContent!.post!.user!).length, 1);
-      assert.equal(items[0].postContent?.post3?.postContent?.content !== undefined, true);
-      assert.equal(items[0].user3!.posts.length > 0, true);
-      assert.equal(items[0].user3!.roles.length > 0, true);
-      assert.equal(cast(items[0].user3!.roles[0]).iid, undefined);
-      assert.equal(cast(items[0].user3)?.iid, undefined);
-      // test data: delete
-      await scopeTest.service.testData.drop(testData);
-    });
-  });
-});

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

@@ -1,58 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { app } from 'vona-mock';
-
-describe('modelRelationsJoins.test.ts', () => {
-  it('action:modelRelationsJoins', async () => {
-    await app.bean.executor.mockCtx(async () => {
-      const prefix = 'action:modelRelationsJoins';
-      // scope
-      const scopeTest = app.scope('test-vona');
-      // test data: create
-      const testData = await scopeTest.service.testData.create(prefix);
-      const { userTom, userJimmy } = testData;
-      // joins: auto
-      const itemsJoins = await scopeTest.model.post.select({
-        joins: [['innerJoin', 'testVonaUser', ['testVonaPost.userId', 'testVonaUser.id']]],
-        where: {
-          'testVonaUser.id': userTom.id,
-        },
-        orders: [['testVonaUser.id', 'asc']],
-      });
-      assert.equal(itemsJoins.length, 2);
-      // joins: manual
-      const itemsJoins2 = await scopeTest.model.post.select(
-        {
-          joins: [['innerJoin', 'testVonaUser', ['testVonaPost.userId', 'testVonaUser.id']]],
-          where: {
-            'testVonaUser.id': userJimmy.id,
-          },
-          orders: [['testVonaUser.id', 'asc']],
-        },
-        {},
-        ['test-vona:user'],
-      );
-      assert.equal(itemsJoins2.length, 0);
-      // joins: manual: no table prefix
-      const itemsJoins3 = await scopeTest.model.post.select(
-        {
-          columns: ['id', 'title'],
-          joins: [['innerJoin', 'testVonaUser', ['userId', 'testVonaUser.id']]],
-          where: {
-            'testVonaUser.id': userJimmy.id,
-            'userId': userJimmy.id,
-          },
-          orders: [
-            ['testVonaUser.id', 'asc'],
-            ['testVonaPost.createdAt', 'asc'],
-          ],
-        },
-        {},
-        ['test-vona:user'],
-      );
-      assert.equal(itemsJoins3.length, 0);
-      // test data: delete
-      await scopeTest.service.testData.drop(testData);
-    });
-  });
-});