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

package/src/__tests__/operator/date-operator.test.ts

@@ -1,24 +1,26 @@
-import { mockDatabase } from '../index';
-import { Collection } from '../../collection';
 import Database from '../../database';
+import { Repository } from '../../repository';
+import { mockDatabase } from '../index';
 
 describe('date operator test', () => {
   let db: Database;
 
-  let User: Collection;
+  let repository: Repository;
 
   afterEach(async () => {
     await db.close();
   });
 
   beforeEach(async () => {
-    db = mockDatabase();
-
-    User = db.collection({
-      name: 'users',
+    db = mockDatabase({
+      timezone: '+00:00',
+    });
+    await db.clean({ drop: true });
+    const Test = db.collection({
+      name: 'tests',
       fields: [
         {
-          name: 'birthday',
+          name: 'date1',
           type: 'date',
         },
         {
@@ -27,139 +29,283 @@ describe('date operator test', () => {
         },
       ],
     });
-
-    await db.sync({ force: true, alter: { drop: false } });
+    repository = Test.repository;
+    await db.sync();
   });
 
   test('$dateOn', async () => {
-    const u0 = await User.repository.create({
-      values: {
-        birthday: '1990-01-02 12:03:02',
-        name: 'u0',
-      },
+    await repository.create({
+      values: [
+        {
+          date1: '2023-01-01T00:00:00.000Z',
+          name: 'u0',
+        },
+        {
+          date1: '2023-01-01T00:00:00.001Z',
+          name: 'u1',
+        },
+        {
+          date1: '2022-12-31T16:00:00.000Z',
+          name: 'u2',
+        },
+        {
+          date1: '2022-12-31T16:00:00.001Z',
+          name: 'u3',
+        },
+      ],
     });
-
-    const user1 = await User.repository.create({
-      values: {
-        birthday: '1990-01-01 12:03:02',
-        name: 'user1',
+    let count: number;
+    count = await repository.count({
+      filter: {
+        'date1.$dateOn': '2023',
       },
     });
-
-    const user = await User.repository.findOne({
-      filter: { 'birthday.$dateOn': '1990-01-01' },
+    expect(count).toBe(2);
+    count = await repository.count({
+      filter: {
+        'date1.$dateOn': '2023+08:00',
+      },
     });
-
-    expect(user.get('id')).toEqual(user1.get('id'));
+    expect(count).toBe(4);
   });
 
   test('$dateNotOn', async () => {
-    const u0 = await User.repository.create({
-      values: {
-        birthday: '1990-01-02 12:03:02',
-        name: 'u0',
-      },
+    await repository.create({
+      values: [
+        {
+          date1: '2023-01-01T00:00:00.000Z',
+          name: 'u0',
+        },
+        {
+          date1: '2023-01-01T00:00:00.001Z',
+          name: 'u1',
+        },
+        {
+          date1: '2022-12-31T16:00:00.000Z',
+          name: 'u2',
+        },
+        {
+          date1: '2022-12-31T16:00:00.001Z',
+          name: 'u3',
+        },
+      ],
     });
-
-    const user1 = await User.repository.create({
-      values: {
-        birthday: '1990-01-01 12:03:02',
-        name: 'user1',
+    let count: number;
+    count = await repository.count({
+      filter: {
+        'date1.$dateNotOn': '2023',
       },
     });
-
-    const user = await User.repository.findOne({
-      filter: { 'birthday.$dateNotOn': '1990-01-01' },
+    expect(count).toBe(2);
+    count = await repository.count({
+      filter: {
+        'date1.$dateNotOn': '2023+08:00',
+      },
     });
-
-    expect(user.get('id')).toEqual(u0.get('id'));
+    expect(count).toBe(0);
   });
 
   test('$dateBefore', async () => {
-    const u0 = await User.repository.create({
-      values: {
-        birthday: '1990-05-01 12:03:02',
-        name: 'u0',
-      },
+    await repository.create({
+      values: [
+        {
+          date1: '2023-01-01T00:00:00.000Z',
+          name: 'u0',
+        },
+        {
+          date1: '2023-01-01T00:00:00.001Z',
+          name: 'u1',
+        },
+        {
+          date1: '2022-12-31T16:00:00.000Z',
+          name: 'u2',
+        },
+        {
+          date1: '2022-12-31T16:00:00.001Z',
+          name: 'u3',
+        },
+        {
+          date1: '2022-12-30T15:59:59.999Z',
+          name: 'u4',
+        },
+      ],
     });
-
-    const user1 = await User.repository.create({
-      values: {
-        birthday: '1990-01-01 12:03:02',
-        name: 'user1',
+    let count: number;
+    count = await repository.count({
+      filter: {
+        'date1.$dateBefore': '2023',
       },
     });
-
-    const user = await User.repository.findOne({
-      filter: { 'birthday.$dateBefore': '1990-04-01' },
+    expect(count).toBe(3);
+    count = await repository.count({
+      filter: {
+        'date1.$dateBefore': '2023+08:00',
+      },
     });
-
-    expect(user.get('id')).toEqual(user1.get('id'));
+    expect(count).toBe(1);
   });
 
   test('$dateNotBefore', async () => {
-    const u0 = await User.repository.create({
-      values: {
-        birthday: '1990-05-01 12:03:02',
-        name: 'u0',
-      },
+    await repository.create({
+      values: [
+        {
+          date1: '2023-01-01T00:00:00.000Z',
+          name: 'u0',
+        },
+        {
+          date1: '2023-01-01T00:00:00.001Z',
+          name: 'u1',
+        },
+        {
+          date1: '2022-12-31T16:00:00.000Z',
+          name: 'u2',
+        },
+        {
+          date1: '2022-12-31T16:00:00.001Z',
+          name: 'u3',
+        },
+        {
+          date1: '2022-12-30T15:59:59.999Z',
+          name: 'u4',
+        },
+      ],
     });
-
-    const user1 = await User.repository.create({
-      values: {
-        birthday: '1990-01-01 12:03:02',
-        name: 'user1',
+    let count: number;
+    count = await repository.count({
+      filter: {
+        'date1.$dateNotBefore': '2023',
       },
     });
-
-    const user = await User.repository.findOne({
-      filter: { 'birthday.$dateNotBefore': '1990-04-01' },
+    expect(count).toBe(2);
+    count = await repository.count({
+      filter: {
+        'date1.$dateNotBefore': '2023+08:00',
+      },
     });
-
-    expect(user.get('id')).toEqual(u0.get('id'));
+    expect(count).toBe(4);
   });
 
   test('$dateAfter', async () => {
-    const u0 = await User.repository.create({
-      values: {
-        birthday: '1990-05-01 12:03:02',
-        name: 'u0',
-      },
+    await repository.create({
+      values: [
+        {
+          date1: '2023-01-01T00:00:00.000Z',
+          name: 'u0',
+        },
+        {
+          date1: '2023-01-01T00:00:00.001Z',
+          name: 'u1',
+        },
+        {
+          date1: '2022-12-31T16:00:00.000Z',
+          name: 'u2',
+        },
+        {
+          date1: '2022-12-31T16:00:00.001Z',
+          name: 'u3',
+        },
+        {
+          date1: '2022-12-30T15:59:59.999Z',
+          name: 'u4',
+        },
+      ],
     });
-
-    const user1 = await User.repository.create({
-      values: {
-        birthday: '1990-01-01 12:03:02',
-        name: 'user1',
+    let count: number;
+    count = await repository.count({
+      filter: {
+        'date1.$dateAfter': '2022',
       },
     });
-
-    const user = await User.repository.findOne({
-      filter: { 'birthday.$dateAfter': '1990-04-01' },
+    expect(count).toBe(2);
+    count = await repository.count({
+      filter: {
+        'date1.$dateAfter': '2022+08:00',
+      },
     });
-
-    expect(user.get('id')).toEqual(u0.get('id'));
+    expect(count).toBe(4);
   });
 
   test('$dateNotAfter', async () => {
-    const u0 = await User.repository.create({
-      values: {
-        birthday: '1990-05-01 12:03:02',
-        name: 'u0',
+    await repository.create({
+      values: [
+        {
+          date1: '2023-01-01T00:00:00.000Z',
+          name: 'u0',
+        },
+        {
+          date1: '2023-01-01T00:00:00.001Z',
+          name: 'u1',
+        },
+        {
+          date1: '2022-12-31T16:00:00.000Z',
+          name: 'u2',
+        },
+        {
+          date1: '2022-12-31T16:00:00.001Z',
+          name: 'u3',
+        },
+        {
+          date1: '2022-12-30T15:59:59.999Z',
+          name: 'u4',
+        },
+      ],
+    });
+    let count: number;
+    count = await repository.count({
+      filter: {
+        'date1.$dateNotAfter': '2022',
       },
     });
-
-    const user1 = await User.repository.create({
-      values: {
-        birthday: '1990-01-01 12:03:02',
-        name: 'user1',
+    expect(count).toBe(3);
+    count = await repository.count({
+      filter: {
+        'date1.$dateNotAfter': '2022+08:00',
       },
     });
+    expect(count).toBe(1);
+  });
 
-    const user = await User.repository.findOne({
-      filter: { 'birthday.$dateNotAfter': '1990-04-01' },
+  test('$dateBetween', async () => {
+    await repository.create({
+      values: [
+        {
+          date1: '2023-01-01T00:00:00.000Z',
+          name: 'u0',
+        },
+        {
+          date1: '2023-01-05T16:00:00.000Z',
+          name: 'u1',
+        },
+        {
+          date1: '2022-12-31T16:00:00.000Z',
+          name: 'u2',
+        },
+        {
+          date1: '2022-12-31T16:00:00.001Z',
+          name: 'u3',
+        },
+        {
+          date1: '2022-12-30T15:59:59.999Z',
+          name: 'u4',
+        },
+        {
+          date1: '2023-01-04T16:00:00.000Z',
+          name: 'u1',
+        },
+      ],
     });
-
-    expect(user.get('id')).toEqual(user1.get('id'));
+    let count: number;
+    count = await repository.count({
+      filter: {
+        'date1.$dateBetween': '[2023-01-01,2023-01-05]',
+      },
+    });
+    expect(count).toBe(3);
+    count = await repository.count({
+      filter: {
+        'date1.$dateBetween': '[2023-01-01,2023-01-05]+08:00',
+      },
+    });
+    expect(count).toBe(4);
   });
 });

package/src/__tests__/operator/eq.test.ts

@@ -0,0 +1,76 @@
+import Database from '../../database';
+import { mockDatabase } from '../index';
+
+describe('eq operator', () => {
+  let db: Database;
+  let Test;
+
+  beforeEach(async () => {
+    db = mockDatabase({});
+
+    Test = db.collection({
+      name: 'tests',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    await db.sync();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should eq with array', async () => {
+    await db.getRepository('tests').create({
+      values: [
+        { name: '123' },
+        { name: '234' },
+        { name: '345' },
+      ]
+    });
+
+    const results = await db.getRepository('tests').count({
+      filter: {
+        'name.$eq': ['123', '234'],
+      },
+    });
+
+    expect(results).toEqual(2);
+  });
+
+  it('should eq with array', async () => {
+    await db.getRepository('tests').create({
+      values: [
+        { name: '123' },
+        { name: '234' },
+        { name: '345' },
+      ]
+    });
+
+    const results = await db.getRepository('tests').count({
+      filter: {
+        'name.$eq': '123',
+      },
+    });
+
+    expect(results).toEqual(1);
+  });
+
+  it('should eq with array', async () => {
+    await db.getRepository('tests').create({
+      values: [
+        { name: '123' },
+        { name: '234' },
+        { name: '345' },
+      ]
+    });
+
+    const results = await db.getRepository('tests').count({
+      filter: {
+        'name.$eq': '456',
+      },
+    });
+
+    expect(results).toEqual(0);
+  });
+});

package/src/__tests__/operator/ne.test.ts

@@ -1,5 +1,5 @@
-import { mockDatabase } from '../index';
 import Database from '../../database';
+import { mockDatabase } from '../index';
 
 describe('ne operator', () => {
   let db: Database;
@@ -42,4 +42,22 @@ describe('ne operator', () => {
 
     expect(results).toBe(0);
   });
+
+  it('should ne with array', async () => {
+    await db.getRepository('tests').create({
+      values: [
+        { name: '123' },
+        { name: '234' },
+        { name: '345' },
+      ]
+    });
+
+    const results = await db.getRepository('tests').count({
+      filter: {
+        'name.$ne': ['123', '234'],
+      },
+    });
+
+    expect(results).toEqual(1);
+  });
 });

package/src/__tests__/relation-repository/belongs-to-many-repository.test.ts

@@ -3,6 +3,88 @@ import Database from '../../database';
 import { BelongsToManyRepository } from '../../relation-repository/belongs-to-many-repository';
 import { mockDatabase } from '../index';
 
+describe('belongs to many with collection that has no id key', () => {
+  let db: Database;
+  beforeEach(async () => {
+    db = mockDatabase();
+
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('should set relation', async () => {
+    const A = db.collection({
+      name: 'a',
+      autoGenId: false,
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+          primaryKey: true,
+        },
+        {
+          type: 'belongsToMany',
+          name: 'bs',
+          target: 'b',
+          through: 'asbs',
+          sourceKey: 'name',
+          foreignKey: 'aName',
+          otherKey: 'bName',
+          targetKey: 'name',
+        },
+      ],
+    });
+
+    const B = db.collection({
+      name: 'b',
+      autoGenId: false,
+      fields: [
+        {
+          type: 'string',
+          name: 'key',
+          primaryKey: true,
+        },
+        {
+          type: 'string',
+          name: 'name',
+          unique: true,
+        },
+        {
+          type: 'belongsToMany',
+          name: 'as',
+          target: 'a',
+          through: 'asbs',
+          sourceKey: 'name',
+          foreignKey: 'bName',
+          otherKey: 'aName',
+          targetKey: 'name',
+        },
+      ],
+    });
+
+    await db.sync();
+    const a = await A.repository.create({
+      values: {
+        name: 'a1',
+      },
+    });
+    const b = await B.repository.create({
+      values: {
+        key: 'b1_key',
+        name: 'b1',
+      },
+    });
+
+    const a1bsRepository = await A.repository.relation<BelongsToManyRepository>('bs').of('a1');
+    expect(await a1bsRepository.find()).toHaveLength(0);
+    await a1bsRepository.toggle('b1');
+    expect(await a1bsRepository.find()).toHaveLength(1);
+  });
+});
+
 describe('belongs to many with target key', function () {
   let db: Database;
   let Tag: Collection;

package/src/__tests__/repository/find.test.ts

@@ -9,6 +9,7 @@ describe('repository find', () => {
   let Post: Collection;
   let Comment: Collection;
   let Tag: Collection;
+  let Profile: Collection;
 
   let A1: Collection;
   let A2: Collection;
@@ -26,6 +27,7 @@ describe('repository find', () => {
         { type: 'string', name: 'name' },
         { type: 'integer', name: 'age' },
         { type: 'hasMany', name: 'posts' },
+        { type: 'hasOne', name: 'profile' },
         { type: 'belongsToMany', name: 'a1' },
         { type: 'belongsToMany', name: 'a2' },
       ],
@@ -41,6 +43,15 @@ describe('repository find', () => {
       fields: [{ type: 'string', name: 'name' }],
     });
 
+    Profile = db.collection({
+      name: 'profiles',
+      fields: [
+        { type: 'integer', name: 'salary' },
+        { type: 'belongsTo', name: 'user' },
+        { type: 'string', name: 'description' },
+      ],
+    });
+
     Post = db.collection({
       name: 'posts',
       fields: [
@@ -90,6 +101,7 @@ describe('repository find', () => {
           posts: [{ title: 'u1t1', comments: [{ content: 'u1t1c1' }], abc1: [{ name: 't1' }] }],
           a1: [{ name: 'u1a11' }, { name: 'u1a12' }],
           a2: [{ name: 'u1a21' }, { name: 'u1a22' }],
+          profile: { salary: 1000 },
         },
         {
           name: 'u2',
@@ -97,16 +109,37 @@ describe('repository find', () => {
           posts: [{ title: 'u2t1', comments: [{ content: 'u2t1c1' }] }],
           a1: [{ name: 'u2a11' }, { name: 'u2a12' }],
           a2: [{ name: 'u2a21' }, { name: 'u2a22' }],
+          profile: { salary: 2000 },
         },
         {
           name: 'u3',
           age: 30,
           posts: [{ title: 'u3t1', comments: [{ content: 'u3t1c1' }] }],
+          profile: { salary: 3000 },
         },
       ],
     });
   });
 
+  it('should only output filed in fields args', async () => {
+    const resp = await User.model.findOne({
+      attributes: [],
+      include: [
+        {
+          association: 'profile',
+          attributes: ['salary'],
+        },
+      ],
+    });
+
+    const users = await User.repository.find({
+      fields: ['profile', 'profile.salary', 'profile.id'],
+    });
+
+    const firstUser = users[0].toJSON();
+    expect(Object.keys(firstUser)).toEqual(['profile']);
+  });
+
   it('append with associations', async () => {
     const users = await User.repository.findAndCount({
       appends: ['posts', 'posts.comments'],