@nocobase/database 0.9.4-alpha.1 → 0.10.0-alpha.2

package/src/__tests__/eager-loading/eager-loading-tree.test.ts

@@ -15,6 +15,149 @@ describe('Eager loading tree', () => {
     await db.close();
   });
 
+  it('should sort has many default by primary key', async () => {
+    const Source = db.collection({
+      name: 'source',
+      fields: [
+        { type: 'string', name: 'name' },
+        {
+          type: 'hasMany',
+          name: 'targets',
+          target: 'target',
+          foreignKey: 'source_id',
+        },
+      ],
+    });
+
+    const Target = db.collection({
+      name: 'target',
+      fields: [{ type: 'integer', name: 'seq_number' }],
+    });
+
+    await db.sync();
+
+    const target1 = await Target.repository.create({ values: { seq_number: 1 } });
+    const target2 = await Target.repository.create({ values: { seq_number: 3 } });
+
+    await target1.update({ values: { seq_number: 2 } });
+
+    await Source.repository.create({
+      values: { name: 's1', targets: [{ id: target2.get('id') }, { id: target1.get('id') }] },
+    });
+
+    const source = await Source.repository.findOne({
+      appends: ['targets'],
+    });
+
+    expect(source.get('targets').map((item: any) => item.get('id'))).toEqual([1, 2]);
+  });
+
+  it('should sort belongs to many default by target primary key', async () => {
+    const Through = db.collection({
+      name: 'through',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    const Source = db.collection({
+      name: 'source',
+      fields: [
+        { type: 'string', name: 'name' },
+        {
+          type: 'belongsToMany',
+          name: 'targets',
+          target: 'target',
+          through: 'through',
+          foreignKey: 'source_id',
+          otherKey: 'target_id',
+          sourceKey: 'id',
+          targetKey: 'id',
+        },
+      ],
+    });
+
+    const Target = db.collection({
+      name: 'target',
+      fields: [{ type: 'integer', name: 'seq_number' }],
+    });
+
+    await db.sync({
+      force: true,
+    });
+
+    const targets = await Target.repository.create({
+      values: [
+        { seq_number: 1 },
+        { seq_number: 2 },
+        { seq_number: 3 },
+        { seq_number: 4 },
+        { seq_number: 5 },
+        { seq_number: 6 },
+      ],
+    });
+
+    await Source.repository.create({
+      values: {
+        name: 'source1',
+        targets: [targets[2], targets[0], targets[1]],
+      },
+    });
+
+    const source = await Source.repository.findOne({
+      appends: ['targets'],
+    });
+
+    expect(source.targets.map((t) => t.get('id'))).toEqual([1, 2, 3]);
+  });
+
+  it('should handle eager loading with long field', async () => {
+    const Through = db.collection({
+      name: 'abc_abcd_abcd_abcdefg_abc_abc_a_abcdefghijk',
+    });
+
+    const A = db.collection({
+      name: 'a',
+      fields: [
+        { type: 'string', name: 'name' },
+        {
+          type: 'belongsToMany',
+          name: 'bs',
+          target: 'b',
+          through: 'abc_abcd_abcd_abcdefg_abc_abc_a_abcdefghijk',
+          foreignKey: 'abc_abcd_abcdefg_abcd_abc',
+          sourceKey: 'id',
+          otherKey: 'b_id',
+          targetKey: 'id',
+        },
+      ],
+    });
+
+    const B = db.collection({
+      name: 'b',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    await db.sync();
+
+    await A.repository.create({
+      values: {
+        name: 'a1',
+        bs: [{ name: 'b1' }, { name: 'b2' }],
+      },
+    });
+
+    const a = await A.repository.findOne({
+      appends: ['bs'],
+    });
+
+    expect(a.get('bs')).toHaveLength(2);
+    const data = a.toJSON();
+
+    // @ts-ignore
+    const as = A.model.associations.bs.oneFromTarget.as;
+
+    expect(data['bs'][0][as]).toBeDefined();
+  });
+
   it('should handle fields filter', async () => {
     const User = db.collection({
       name: 'users',
@@ -55,6 +198,7 @@ describe('Eager loading tree', () => {
       model: User.model,
       rootAttributes: findOptions.attributes,
       includeOption: findOptions.include,
+      db: db,
     });
 
     await eagerLoadingTree.load(users.map((item) => item.id));
@@ -105,6 +249,7 @@ describe('Eager loading tree', () => {
       model: User.model,
       rootAttributes: findOptions.attributes,
       includeOption: findOptions.include,
+      db: db,
     });
 
     await eagerLoadingTree.load([1, 2]);
@@ -155,6 +300,7 @@ describe('Eager loading tree', () => {
       model: User.model,
       rootAttributes: findOptions.attributes,
       includeOption: findOptions.include,
+      db: db,
     });
 
     await eagerLoadingTree.load(users.map((item) => item.id));
@@ -210,6 +356,7 @@ describe('Eager loading tree', () => {
       model: Post.model,
       rootAttributes: findOptions.attributes,
       includeOption: findOptions.include,
+      db: db,
     });
 
     await eagerLoadingTree.load([1, 2]);
@@ -272,6 +419,7 @@ describe('Eager loading tree', () => {
       model: Post.model,
       rootAttributes: findOptions.attributes,
       includeOption: findOptions.include,
+      db: db,
     });
     await eagerLoadingTree.load([1, 2]);
     const root = eagerLoadingTree.root;
@@ -374,6 +522,7 @@ describe('Eager loading tree', () => {
       model: User.model,
       rootAttributes: findOptions.attributes,
       includeOption: findOptions.include,
+      db: db,
     });
 
     expect(eagerLoadingTree.root.children).toHaveLength(1);

package/src/__tests__/field-options/sort-by.test.ts

@@ -151,10 +151,11 @@ describe('associated field order', () => {
     });
 
     const u1 = await db.getRepository('users').findOne({
-      appends: ['posts.tags'],
+      appends: ['posts.tags', 'posts.title'],
     });
 
     const u1Json = u1.toJSON();
+
     const u1Posts = u1Json['posts'];
     expect(u1Posts.map((p) => p['title'])).toEqual(['a', 'b', 'c']);
 
@@ -214,6 +215,7 @@ describe('associated field order', () => {
     });
 
     const p1JSON = p1Result.toJSON();
+
     const p1Images = p1JSON['images'];
     expect(p1Images.map((i) => i['url'])).toEqual(['t2', 't1']);
   });

package/src/__tests__/filter.test.ts

@@ -14,6 +14,60 @@ describe('filter', () => {
     await db.close();
   });
 
+  it('should filter by belongs to many association', async () => {
+    const A = db.collection({
+      name: 'a',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'hasMany', name: 'b', target: 'b' },
+      ],
+    });
+
+    const B = db.collection({
+      name: 'b',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'belongsTo', name: 'c', target: 'c' },
+        { type: 'belongsTo', name: 'd', target: 'd' },
+      ],
+    });
+
+    const C = db.collection({
+      name: 'c',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    const D = db.collection({
+      name: 'd',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    await db.sync();
+
+    const findArgs = {
+      filter: {
+        $and: [{ b: { c: { name: { $eq: 'c1' } } } }, { b: { d: { name: { $eq: 'd1' } } } }],
+      },
+    };
+
+    const findOptions = A.repository.buildQueryOptions(findArgs);
+
+    const include = findOptions.include;
+
+    const associationB = include.find((i) => i.association === 'b');
+    expect(associationB).toBeDefined();
+    expect(associationB.include).toHaveLength(2);
+
+    let err;
+    try {
+      await A.repository.find({ ...findArgs });
+    } catch (e) {
+      err = e;
+    }
+
+    expect(err).toBeUndefined();
+  });
+
   it('should filter by hasMany association field', async () => {
     const DeptCollection = db.collection({
       name: 'depts',

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

@@ -16,6 +16,171 @@ pgOnly()('collection inherits', () => {
     await db.close();
   });
 
+  it('should append __collection with eager load', async () => {
+    const Root = db.collection({
+      name: 'root',
+      fields: [
+        { name: 'name', type: 'string' },
+        {
+          name: 'bs',
+          type: 'hasMany',
+          target: 'b',
+          foreignKey: 'root_id',
+        },
+      ],
+    });
+
+    const Child = db.collection({
+      name: 'child',
+      inherits: ['root'],
+    });
+
+    const B = db.collection({
+      name: 'b',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
+    await db.sync();
+
+    await Child.repository.create({
+      values: {
+        name: 'child1',
+        bs: [
+          {
+            name: 'b1',
+          },
+        ],
+      },
+    });
+
+    const data = await Root.repository.findOne({
+      fields: ['bs.name'],
+    });
+
+    expect(data.get('__collection')).toEqual('child');
+    expect(data.get('bs')[0].get('name')).toEqual('b1');
+  });
+
+  it('should not remove parent field reference map after child rewrite field', async () => {
+    const through = db.collection({
+      name: 'through',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
+    const rootCollection = db.collection({
+      name: 'root',
+      fields: [
+        { name: 'name', type: 'string' },
+        {
+          name: 'targets',
+          type: 'belongsToMany',
+          target: 'root-target',
+          through: 'through',
+          foreignKey: 'rootId',
+          otherKey: 'targetId',
+        },
+      ],
+    });
+
+    const rootTarget = db.collection({
+      name: 'root-target',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
+    await db.sync({ force: true });
+
+    expect(db.referenceMap.getReferences('root-target')).toHaveLength(1);
+
+    const child = db.collection({
+      name: 'child',
+      inherits: ['root'],
+    });
+
+    const childTarget = db.collection({
+      name: 'child-target',
+      inherits: ['root-target'],
+    });
+
+    await child.setField('targets', {
+      name: 'targets',
+      type: 'belongsToMany',
+      target: 'child-target',
+      through: 'through',
+      foreignKey: 'rootId',
+      otherKey: 'targetId',
+    });
+
+    await db.sync();
+
+    expect(db.referenceMap.getReferences('root-target')).toHaveLength(1);
+  });
+
+  it('should append collection name in eager load', async () => {
+    const rootCollection = db.collection({
+      name: 'assoc',
+      fields: [
+        { name: 'name', type: 'string' },
+        { type: 'belongsToMany', name: 'other-assocs' },
+      ],
+    });
+
+    const childCollection = db.collection({
+      name: 'child',
+      inherits: ['assoc'],
+    });
+
+    const otherAssoc = db.collection({
+      name: 'other-assocs',
+      fields: [{ name: 'name', type: 'string' }],
+    });
+
+    const User = db.collection({
+      name: 'users',
+      fields: [
+        {
+          name: 'name',
+          type: 'string',
+        },
+        {
+          name: 'assocs',
+          type: 'hasMany',
+          target: 'assoc',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const child = await childCollection.repository.create({
+      values: {
+        name: 'child1',
+      },
+    });
+
+    await User.repository.create({
+      values: {
+        name: 'user1',
+        assocs: [
+          {
+            id: child.get('id'),
+          },
+        ],
+      },
+    });
+
+    const users = await User.repository.find({
+      appends: ['assocs.other-assocs'],
+    });
+
+    const user = users[0];
+
+    const assoc = user.get('assocs')[0];
+    expect(assoc.get('__tableName')).toEqual(childCollection.model.tableName);
+    expect(assoc.get('__schemaName')).toEqual(childCollection.collectionSchema());
+
+    expect(user.get('assocs')[0].get('__collection')).toBe('child');
+  });
+
   it('should list data filtered by child type', async () => {
     const rootCollection = db.collection({
       name: 'root',

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

@@ -1,10 +1,11 @@
 import { mockDatabase } from '../index';
 import Database from '../../database';
+import { Collection } from '../../collection';
 
 describe('create with hasMany', () => {
   let db: Database;
-  let Post;
-  let User;
+  let Post: Collection;
+  let User: Collection;
 
   afterEach(async () => {
     await db.close();
@@ -61,8 +62,8 @@ describe('create with hasMany', () => {
 
 describe('create with belongsToMany', () => {
   let db: Database;
-  let Post;
-  let Tag;
+  let Post: Collection;
+  let Tag: Collection;
 
   afterEach(async () => {
     await db.close();
@@ -122,16 +123,36 @@ describe('create with belongsToMany', () => {
 
 describe('create', () => {
   let db: Database;
-  let User;
-  let Post;
+  let User: Collection;
+  let Post: Collection;
+  let Group: Collection;
+  let Role: Collection;
 
   beforeEach(async () => {
     db = mockDatabase();
+    await db.clean({ drop: true });
+
+    Group = db.collection({
+      name: 'groups',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
     User = db.collection({
       name: 'users',
       fields: [
         { type: 'string', name: 'name' },
+        { type: 'integer', name: 'age' },
         { type: 'hasMany', name: 'posts' },
+        { type: 'belongsTo', name: 'group' },
+        { type: 'belongsToMany', name: 'roles' },
+      ],
+    });
+
+    Role = db.collection({
+      name: 'roles',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'belongsToMany', name: 'users' },
       ],
     });
 
@@ -149,6 +170,108 @@ describe('create', () => {
     await db.close();
   });
 
+  test('firstOrCreate by filterKeys', async () => {
+    const u1 = await User.repository.firstOrCreate({
+      filterKeys: ['name'],
+      values: {
+        name: 'u1',
+        age: 10,
+        group: {
+          name: 'g1',
+        },
+      },
+    });
+    expect(u1.name).toEqual('u1');
+    const group = await u1.get('group');
+    expect(group.name).toEqual('g1');
+
+    const u2 = await User.repository.firstOrCreate({
+      filterKeys: ['group'],
+      values: {
+        group: {
+          name: 'g1',
+        },
+      },
+    });
+
+    expect(u2.name).toEqual('u1');
+  });
+
+  test('firstOrCreate by many to many associations', async () => {
+    const roles = await Role.repository.create({
+      values: [{ name: 'r1' }, { name: 'r2' }],
+    });
+
+    const u1 = await User.repository.firstOrCreate({
+      values: {
+        name: 'u1',
+        roles: [{ name: 'r1' }, { name: 'r2' }],
+      },
+      filterKeys: ['roles.name'],
+    });
+
+    expect(u1.get('roles')).toHaveLength(2);
+
+    const u1a = await User.repository.firstOrCreate({
+      values: {
+        name: 'u1',
+        roles: [{ name: 'r1' }, { name: 'r2' }],
+      },
+      filterKeys: ['roles.name'],
+    });
+
+    expect(u1a.get('id')).toEqual(u1.get('id'));
+  });
+
+  test('firstOrCreate', async () => {
+    const u1 = await User.repository.firstOrCreate({
+      filterKeys: ['name'],
+      values: {
+        name: 'u1',
+        age: 10,
+      },
+    });
+
+    expect(u1.name).toEqual('u1');
+    expect(u1.age).toEqual(10);
+
+    expect(
+      (
+        await User.repository.firstOrCreate({
+          filterKeys: ['name'],
+          values: {
+            name: 'u1',
+            age: 10,
+          },
+        })
+      ).get('id'),
+    ).toEqual(u1.get('id'));
+  });
+
+  test('updateOrCreate', async () => {
+    const u1 = await User.repository.updateOrCreate({
+      filterKeys: ['name'],
+      values: {
+        name: 'u1',
+        age: 10,
+      },
+    });
+
+    expect(u1.name).toEqual('u1');
+    expect(u1.age).toEqual(10);
+
+    await User.repository.updateOrCreate({
+      filterKeys: ['name'],
+      values: {
+        name: 'u1',
+        age: 20,
+      },
+    });
+
+    await u1.reload();
+    expect(u1.age).toEqual(20);
+  });
+
   test('create with association', async () => {
     const u1 = await User.repository.create({
       values: {

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

@@ -488,6 +488,17 @@ describe('repository find', () => {
       expect(user['posts']).toBeDefined();
     });
 
+    test('find with nested fields', async () => {
+      const user = await User.repository.findOne({
+        fields: ['posts.comments.content'],
+      });
+
+      const userData = user.toJSON();
+
+      const post = userData['posts'][0];
+      expect(Object.keys(post)).toEqual(['comments']);
+    });
+
     describe('find with appends', () => {
       test('toJSON', async () => {
         const user = await User.repository.findOne({

package/src/__tests__/repository.test.ts

@@ -1,6 +1,29 @@
 import { Collection } from '../collection';
 import { Database } from '../database';
 import { mockDatabase } from './';
+import { Repository } from '@nocobase/database';
+
+describe('repository', () => {
+  test('value to filter', async () => {
+    const value = {
+      tags: [
+        {
+          categories: [{ name: 'c1' }, { name: 'c2' }],
+        },
+        {
+          categories: [{ name: 'c3' }, { name: 'c4' }],
+        },
+      ],
+    };
+
+    const filter = Repository.valuesToFilter(value, ['tags.categories.name']);
+    expect(filter.$and).toEqual([
+      {
+        'tags.categories.name': ['c1', 'c2', 'c3', 'c4'],
+      },
+    ]);
+  });
+});
 
 describe('find by targetKey', function () {
   let db: Database;
@@ -563,6 +586,7 @@ describe('repository.relatedQuery', () => {
     const post2 = await userPostRepository.create({
       values: { name: 'post2' },
     });
+
     expect(post2).toMatchObject({
       name: 'post2',
       userId: user.get('id'),