@nocobase/database 0.9.1-alpha.2 → 0.9.2-alpha.1

package/src/__tests__/fields/date.test.ts

@@ -0,0 +1,75 @@
+import { mockDatabase } from '../';
+import { Database } from '../../database';
+import { Repository } from '../../repository';
+
+describe('date-field', () => {
+  let db: Database;
+  let repository: Repository;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    db.collection({
+      name: 'tests',
+      fields: [
+        { name: 'date1', type: 'date' },
+      ],
+    });
+    await db.sync();
+    repository = db.getRepository('tests');
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  const createExpectToBe = async (key, actual, expected) => {
+    const instance = await repository.create({
+      values: {
+        [key]: actual,
+      },
+    });
+    return expect(instance.get(key).toISOString()).toEqual(expected);
+  };
+
+  test('create', async () => {
+    // sqlite 时区不能自定义，只有 +00:00，postgres 和 mysql 可以自定义 DB_TIMEZONE
+    await createExpectToBe('date1', '2023-03-24', '2023-03-24T00:00:00.000Z');
+    await createExpectToBe('date1', '2023-03-24T16:00:00.000Z', '2023-03-24T16:00:00.000Z');
+  });
+
+  // dateXX 相关 Operator 都是去 time 比较的
+  describe('dateOn', () => {
+    test('dateOn operator', async () => {
+      console.log('timezone', db.options.timezone);
+      // 默认的情况，时区为 db.options.timezone
+      await repository.find({
+        filter: {
+          date1: {
+            // 由 db.options.timezone 来处理日期转换，假设是 +08:00 的时区
+            // 2023-03-24表示的范围：2023-03-23T16:00:00 ~ 2023-03-24T16:00:00
+            $dateOn: '2023-03-24',
+          },
+        },
+      });
+
+      await repository.find({
+        filter: {
+          date1: {
+            // +06:00 时区 2023-03-24 的范围：2023-03-23T18:00:00 ~ 2023-03-24T18:00:00
+            $dateOn: '2023-03-24+06:00',
+          },
+        },
+      });
+
+      await repository.find({
+        filter: {
+          date1: {
+            // 2023-03-23T20:00:00+08:00 在 +08:00 时区的时间是：2023-03-24 04:00:00
+            // 也就是 +08:00 时区 2023-03-24 这一天的范围：2023-03-23T16:00:00 ~ 2023-03-24T16:00:00
+            $dateOn: '2023-03-23T20:00:00+08:00',
+          },
+        },
+      });
+    });
+  });
+});

package/src/__tests__/fields/sort-field.test.ts

@@ -17,6 +17,106 @@ describe('string field', () => {
     await db.close();
   });
 
+  it('should init sorted value with thousand records', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'string',
+          name: 'group',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    await Test.model.bulkCreate(
+      (() => {
+        const values = [];
+        for (let i = 0; i < 100000; i++) {
+          values.push({
+            group: 'a',
+            name: `r${i}`,
+          });
+
+          values.push({
+            group: 'b',
+            name: `r${i}`,
+          });
+        }
+        return values;
+      })(),
+    );
+
+    Test.setField('sort', { type: 'sort', scopeKey: 'group' });
+
+    const begin = Date.now();
+    await db.sync();
+    const end = Date.now();
+    // log time cost as milliseconds
+    console.log(end - begin);
+  });
+
+  it('should init sorted value with scopeKey', async () => {
+    const Test = db.collection({
+      name: 'tests',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'string',
+          name: 'group',
+        },
+      ],
+    });
+
+    await db.sync();
+    await Test.repository.create({
+      values: [
+        {
+          group: 'a',
+          name: 'r1',
+        },
+        {
+          group: 'b',
+          name: 'r2',
+        },
+        {
+          group: 'a',
+          name: 'r3',
+        },
+        {
+          group: 'b',
+          name: 'r4',
+        },
+        {
+          group: null,
+          name: 'r5',
+        },
+        {
+          group: null,
+          name: 'r6',
+        },
+      ],
+    });
+
+    Test.setField('sort', { type: 'sort', scopeKey: 'group' });
+
+    await db.sync();
+
+    const records = await Test.repository.find({});
+    const r3 = records.find((r) => r.get('name') === 'r3');
+    expect(r3.get('sort')).toBe(2);
+    const r5 = records.find((r) => r.get('name') === 'r5');
+    expect(r5.get('sort')).toBe(1);
+  });
+
   it('should init sorted value by createdAt when primaryKey not exists', async () => {
     const Test = db.collection({
       autoGenId: false,

package/src/__tests__/filter.test.ts

@@ -47,14 +47,14 @@ describe('filter', () => {
       },
     });
 
-    const response = await UserCollection.repository.find({
+    const count = await PostCollection.repository.count({
       filter: {
-        'posts.createdAt': {
+        'user.createdAt': {
           $dateOn: user.get('createdAt'),
         },
       },
     });
 
-    expect(response).toHaveLength(1);
+    expect(count).toBe(2);
   });
 });

package/src/__tests__/group.test.ts

@@ -0,0 +1,50 @@
+import { Database, mockDatabase } from '@nocobase/database';
+import sequelize from 'sequelize';
+
+describe('migrator', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase({
+      tablePrefix: 'test_',
+    });
+
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('addMigrations', async () => {
+    db.collection({
+      name: 'test',
+      fields: [
+        {
+          type: 'string',
+          name: 'status',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const r = db.getRepository('test');
+
+    await r.create({
+      values: [{ status: 's1' }, { status: 's1' }, { status: 's1' }, { status: 's2' }, { status: 's3' }],
+    });
+
+    const result = await r.find({
+      attributes: ['status', [sequelize.fn('COUNT', sequelize.col('id')), 'count']],
+      sort: 'status',
+      group: 'status',
+    });
+
+    expect(result.map((r) => r.toJSON())).toMatchObject([
+      { status: 's1', count: 3 },
+      { status: 's2', count: 1 },
+      { status: 's3', count: 1 },
+    ]);
+  });
+});

package/src/__tests__/inhertits/collection-inherits.test.ts

@@ -1,6 +1,7 @@
 import Database from '../../database';
 import { InheritedCollection } from '../../inherited-collection';
 import { mockDatabase } from '../index';
+import { BelongsToManyRepository } from '@nocobase/database';
 import pgOnly from './helper';
 
 pgOnly()('collection inherits', () => {
@@ -15,6 +16,119 @@ pgOnly()('collection inherits', () => {
     await db.close();
   });
 
+  it('should list data filtered by child type', async () => {
+    const rootCollection = db.collection({
+      name: 'root',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
+    const child1Collection = db.collection({
+      name: 'child1',
+      inherits: ['root'],
+    });
+
+    const child2Collection = db.collection({
+      name: 'child2',
+      inherits: ['root'],
+    });
+
+    await db.sync();
+
+    await rootCollection.repository.create({
+      values: {
+        name: 'root1',
+      },
+    });
+
+    await child1Collection.repository.create({
+      values: [{ name: 'child1-1' }, { name: 'child1-2' }],
+    });
+
+    await child2Collection.repository.create({
+      values: [{ name: 'child2-1' }, { name: 'child2-2' }],
+    });
+
+    const records = await rootCollection.repository.find({
+      filter: {
+        'tableoid.$childIn': [child1Collection.name],
+      },
+    });
+
+    expect(records.every((r) => r.get('__collection') === child1Collection.name)).toBe(true);
+
+    const records2 = await rootCollection.repository.find({
+      filter: {
+        'tableoid.$childNotIn': [child1Collection.name],
+      },
+    });
+    expect(records2.every((r) => r.get('__collection') !== child1Collection.name)).toBe(true);
+  });
+
+  it('should list collection name in relation repository', async () => {
+    const personTagCollection = db.collection({
+      name: 'personTags',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
+    const studentTagCollection = db.collection({
+      name: 'studentTags',
+      inherits: ['personTags'],
+      fields: [{ name: 'school', type: 'string' }],
+    });
+
+    const personCollection = db.collection({
+      name: 'person',
+      fields: [{ name: 'tags', type: 'belongsToMany', target: 'personTags' }],
+    });
+
+    const studentCollection = db.collection({
+      name: 'student',
+      inherits: ['person'],
+      fields: [],
+    });
+
+    await db.sync();
+
+    const studentTag1 = await studentTagCollection.repository.create({
+      values: {
+        name: 'studentTag',
+        school: 'school1',
+      },
+    });
+
+    const personTag1 = await personTagCollection.repository.create({
+      values: {
+        name: 'personTag',
+      },
+    });
+
+    await studentCollection.repository.create({
+      values: {
+        tags: [
+          {
+            id: studentTag1.get('id'),
+          },
+          {
+            id: personTag1.get('id'),
+          },
+        ],
+      },
+    });
+
+    const person1 = await personCollection.repository.findOne({});
+
+    const tags = await personCollection.repository
+      .relation<BelongsToManyRepository>('tags')
+      .of(person1.get('id'))
+      .find({});
+
+    const personTag = tags.find((tag) => tag.get('name') === 'personTag');
+    const studentTag = tags.find((tag) => tag.get('name') === 'studentTag');
+
+    expect(personTag.get('__collection')).toEqual(personTagCollection.name);
+    expect(studentTag.get('__collection')).toEqual(studentTagCollection.name);
+  });
+
   it('should create inherits with table name contains upperCase', async () => {
     db.collection({
       name: 'parent',