@nocobase/database 0.7.4-alpha.7 → 0.7.6-alpha.1

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

@@ -0,0 +1,455 @@
+import moment from 'moment';
+
+import { Database } from '../../database';
+import { mockDatabase } from '..';
+
+describe('string field', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  describe('define', () => {
+    it('without any pattern will throw error', async () => {
+      expect(() => {
+        db.collection({
+          name: 'tests',
+          fields: [{ type: 'sequence', name: 'name' }],
+        });
+      }).toThrow();
+    });
+
+    it('with empty pattern will throw error', async () => {
+      expect(() => {
+        db.collection({
+          name: 'tests',
+          fields: [{ type: 'sequence', name: 'name', patterns: [] }],
+        });
+      }).toThrow();
+    });
+  });
+
+  describe('string pattern', () => {
+    it('no options', async () => {
+      expect(() => {
+        db.collection({
+          name: 'tests',
+          fields: [{ type: 'sequence', name: 'name', patterns: [{ type: 'string' }] }],
+        });
+      }).toThrow();
+    });
+
+    it('constant', async () => {
+      db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              { type: 'string', options: { value: 'abc' } }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create();
+      expect(item1.get('name')).toBe('abc');
+
+      const item2 = await TestModel.create();
+      expect(item2.get('name')).toBe('abc');
+    });
+  });
+
+  describe('integer pattern', () => {
+    it('default start from 0, digits as 1, no cycle', async () => {
+      db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              {
+                type: 'integer'
+              }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create();
+      expect(item1.get('name')).toBe('0');
+
+      const item2 = await TestModel.create();
+      expect(item2.get('name')).toBe('1');
+    });
+
+    it('start from 9', async () => {
+      db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              {
+                type: 'integer',
+                options: {
+                  start: 9
+                }
+              }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create();
+      expect(item1.get('name')).toBe('9');
+
+      const item2 = await TestModel.create();
+      expect(item2.get('name')).toBe('9');
+    });
+
+    it('start from 0, current set to 9', async () => {
+      const collection = db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              {
+                type: 'integer'
+              }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+      const field = collection.getField('name');
+      // set current option in memory
+      field.options.patterns[0].options = { current: 9 };
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create();
+      expect(item1.get('name')).toBe('0');
+    });
+
+    it('digits more than 1, start from 9', async () => {
+      db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              {
+                type: 'integer',
+                options: {
+                  digits: 2,
+                  start: 9
+                }
+              }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create();
+      expect(item1.get('name')).toBe('09');
+
+      const item2 = await TestModel.create();
+      expect(item2.get('name')).toBe('10');
+    });
+
+    it('cycle by day', async () => {
+      db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              {
+                type: 'integer',
+                options: {
+                  cycle: '0 0 * * * *'
+                }
+              }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+
+      const now = new Date();
+      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create({
+        createdAt: yesterday
+      });
+      expect(item1.get('name')).toBe('0');
+
+      const item2 = await TestModel.create({
+        createdAt: yesterday
+      });
+      expect(item2.get('name')).toBe('1');
+
+      const item3 = await TestModel.create();
+      expect(item3.get('name')).toBe('0');
+
+      const item4 = await TestModel.create();
+      expect(item4.get('name')).toBe('1');
+    });
+  });
+
+  describe('date pattern', () => {
+    it('default to current createdAt as YYYYMMDD', async () => {
+      db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              { type: 'date' }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+
+      const now = new Date();
+      const YYYYMMDD = moment(now).format('YYYYMMDD');
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create();
+      expect(item1.get('name')).toBe(YYYYMMDD);
+    });
+
+    it('field option', async () => {
+      db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              { type: 'date', options: { field: 'date' } }
+            ]
+          },
+          {
+            type: 'date',
+            name: 'date'
+          }
+        ],
+      });
+      await db.sync();
+
+      const date = new Date(2022, 7, 1);
+      const YYYYMMDD = moment(date).format('YYYYMMDD');
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create({
+        date
+      });
+      expect(item1.get('name')).toBe(YYYYMMDD);
+    });
+
+    it('format option', async () => {
+      db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              { type: 'date', options: { format: 'YYYY-MM-DD' } }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+
+      const now = new Date();
+      const YYYYMMDD = moment(now).format('YYYY-MM-DD');
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create();
+      expect(item1.get('name')).toBe(YYYYMMDD);
+    });
+  });
+
+  describe('mixed pattern', () => {
+    it('all patterns', async () => {
+      db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              { type: 'string', options: { value: 'A' } },
+              { type: 'date' },
+              { type: 'integer' }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+
+      const now = new Date();
+      const YYYYMMDD = moment(now).format('YYYYMMDD');
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create();
+      expect(item1.get('name')).toBe(`A${YYYYMMDD}0`);
+
+      const item2 = await TestModel.create();
+      expect(item2.get('name')).toBe(`A${YYYYMMDD}1`);
+    });
+
+    it('changed after generated', async () => {
+      const testsCollection = db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              { type: 'string', options: { value: 'A' } },
+              { type: 'date' },
+              { type: 'integer' }
+            ]
+          }
+        ],
+      });
+      await db.sync();
+
+      const now = new Date();
+      const YYYYMMDD = moment(now).format('YYYYMMDD');
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create();
+      expect(item1.get('name')).toBe(`A${YYYYMMDD}0`);
+
+      testsCollection.setField('name', {
+        type: 'sequence',
+        patterns: [
+          { type: 'string', options: { value: 'A' } },
+          { type: 'date' },
+          // change options but no difference with default
+          { type: 'integer', options: { digits: 1 } }
+        ]
+      });
+
+      const item2 = await TestModel.create();
+      expect(item2.get('name')).toBe(`A${YYYYMMDD}1`);
+
+      testsCollection.setField('name', {
+        type: 'sequence',
+        patterns: [
+          { type: 'string', options: { value: 'A' } },
+          { type: 'date' },
+          { type: 'integer', options: { digits: 2 } }
+        ]
+      });
+
+      const item3 = await TestModel.create();
+      expect(item3.get('name')).toBe(`A${YYYYMMDD}00`);
+
+      testsCollection.setField('name', {
+        type: 'sequence',
+        patterns: [
+          { type: 'string', options: { value: 'a' } },
+          { type: 'date' },
+          { type: 'integer', options: { digits: 2 } }
+        ]
+      });
+
+      const item4 = await TestModel.create();
+      expect(item4.get('name')).toBe(`a${YYYYMMDD}01`);
+
+      testsCollection.setField('name', {
+        type: 'sequence',
+        patterns: [
+          { type: 'date' },
+          { type: 'integer', options: { digits: 2 } }
+        ]
+      });
+
+      const item5 = await TestModel.create();
+      expect(item5.get('name')).toBe(`${YYYYMMDD}00`);
+    });
+  });
+
+  describe('multiple serial fields', () => {
+    it('2 fields', async () => {
+      const testsCollection = db.collection({
+        name: 'tests',
+        fields: [
+          {
+            type: 'sequence',
+            name: 'name',
+            patterns: [
+              { type: 'string', options: { value: 'A' } },
+              { type: 'date' },
+              { type: 'integer', options: { digits: 2, cycle: '0 0 * * *' } }
+            ]
+          },
+          {
+            type: 'sequence',
+            name: 'code',
+            patterns: [
+              { type: 'string', options: { value: 'C' } },
+              { type: 'integer', options: { digits: 4 }}
+            ]
+          }
+        ]
+      });
+      await db.sync();
+
+      const now = new Date();
+      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+      const NOW = moment(now).format('YYYYMMDD');
+      const YESTERDAY = moment(yesterday).format('YYYYMMDD');
+
+      const TestModel = db.getModel('tests');
+      const item1 = await TestModel.create({ createdAt: yesterday });
+      expect(item1.get('name')).toBe(`A${YESTERDAY}00`);
+      expect(item1.get('code')).toBe(`C0000`);
+
+      const item2 = await TestModel.create();
+      expect(item2.get('name')).toBe(`A${NOW}00`);
+      expect(item2.get('code')).toBe(`C0001`);
+
+      testsCollection.setField('name', {
+        type: 'sequence',
+        patterns: [
+          { type: 'string', options: { value: 'a' } },
+          { type: 'date' },
+          { type: 'integer', options: { digits: 1 } }
+        ]
+      });
+
+      const item3 = await TestModel.create();
+      expect(item3.get('name')).toBe(`a${NOW}0`);
+      expect(item3.get('code')).toBe(`C0002`);
+    });
+  });
+});

package/src/__tests__/magic-attribute-model.test.ts

@@ -12,6 +12,30 @@ describe('magic-attribute-model', () => {
     await db.close();
   });
 
+  it('case 0', async () => {
+    db.registerModels({ MagicAttributeModel });
+
+    const Test = db.collection({
+      name: 'tests',
+      model: 'MagicAttributeModel',
+      fields: [
+        { type: 'string', name: 'title' },
+        { type: 'json', name: 'options' },
+      ],
+    });
+
+    await db.sync();
+
+    const test = await Test.model.create({
+      title: 'aa',
+      'x-component-props': { key1: 'val1', arr1: [1, 2, 3], arr2: [4, 5] },
+    });
+
+    test.set('x-component-props', { arr2: [1, 2, 3] });
+
+    expect(test.previous('options')['x-component-props']['arr2']).toEqual([4, 5]);
+  });
+
   it('case 1', async () => {
     db.registerModels({ MagicAttributeModel });
 

package/src/__tests__/model.changedWithAssociations.test.ts

@@ -0,0 +1,46 @@
+import Database from '../database';
+import { mockDatabase } from '../mock-database';
+
+describe('changedWithAssociations', () => {
+  let db: Database;
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  test('changedWithAssociations', async () => {
+    db.collection({
+      name: 'test',
+      fields: [
+        {
+          type: 'string',
+          name: 'n1',
+        },
+        {
+          type: 'string',
+          name: 'n2',
+        },
+      ],
+    });
+    let changed = [];
+    db.on('test.afterCreateWithAssociations', (model, options) => {
+      changed = model.changedWithAssociations();
+    });
+    db.on('test.afterUpdateWithAssociations', (model, options) => {
+      changed = model.changedWithAssociations();
+    });
+    await db.sync();
+    const r = db.getRepository('test');
+    const m = await r.create({ values: { n1: 'a' } });
+    expect(changed.includes('n1')).toBeTruthy();
+    expect(m.changedWithAssociations()).toBeFalsy();
+    await r.update({ filterByTk: m.id, values: { n1: 'b', n2: 'c' } });
+    expect(changed).toEqual(['n1', 'n2']);
+    expect(m.changedWithAssociations()).toBeFalsy();
+  });
+});

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

@@ -30,4 +30,16 @@ describe('ne operator', () => {
 
     expect(results).toEqual(1);
   });
+
+  it('compare with null', async () => {
+    await db.getRepository('tests').create({});
+
+    const results = await db.getRepository('tests').count({
+      filter: {
+        'name.$ne': null,
+      },
+    });
+
+    expect(results).toBe(0);
+  });
 });

package/src/__tests__/relation-repository/appends.test.ts

@@ -0,0 +1,64 @@
+import Database, { BelongsToRepository, Collection, mockDatabase } from '@nocobase/database';
+
+describe('appends', () => {
+  let db: Database;
+
+  let User: Collection;
+  let Post: Collection;
+
+  let A1: Collection;
+  let A2: Collection;
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase();
+
+    User = db.collection({
+      name: 'users',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'hasMany', name: 'posts' },
+      ],
+    });
+
+    Post = db.collection({
+      name: 'posts',
+      fields: [
+        { type: 'string', name: 'title' },
+        {
+          type: 'belongsTo',
+          name: 'user',
+        },
+      ],
+    });
+
+    await db.sync();
+  });
+
+  it('should find with appends', async () => {
+    await User.repository.create({
+      values: {
+        name: 'u1',
+        posts: [
+          {
+            title: 'p1',
+          },
+        ],
+      },
+    });
+
+    const p1 = await Post.repository.findOne({});
+
+    const repository = new BelongsToRepository(Post, 'user', p1['id']);
+
+    const user = await repository.findOne({
+      appends: ['posts'],
+    });
+
+    const data = user.toJSON();
+    expect(data['posts'][0]['title']).toEqual('p1');
+  });
+});

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

@@ -235,6 +235,29 @@ describe('belongs to many', () => {
     expect(findFilterResult[0].name).toEqual('t2');
   });
 
+  test('create with array', async () => {
+    const p1 = await Post.repository.create({
+      values: {
+        title: 'p1',
+      },
+    });
+
+    const PostTagRepository = new BelongsToManyRepository(Post, 'tags', p1.id);
+
+    const results = await PostTagRepository.create({
+      values: [
+        {
+          name: 't1',
+        },
+        {
+          name: 't2',
+        },
+      ],
+    });
+
+    expect(results.length).toEqual(2);
+  });
+
   test('find and count', async () => {
     const p1 = await Post.repository.create({
       values: {

package/src/__tests__/relation-repository/has-many-repository.test.ts

@@ -203,6 +203,26 @@ describe('has many repository', () => {
     expect(post.userId).toEqual(u1.id);
   });
 
+  test('create with array', async () => {
+    const u1 = await User.repository.create({
+      values: { name: 'u1' },
+    });
+
+    const UserPostRepository = new HasManyRepository(User, 'posts', u1.id);
+    const posts = await UserPostRepository.create({
+      values: [
+        {
+          title: 't1',
+        },
+        {
+          title: 't2',
+        },
+      ],
+    });
+
+    expect(posts.length).toEqual(2);
+  });
+
   test('update', async () => {
     const u1 = await User.repository.create({
       values: { name: 'u1' },