@nocobase/database 0.9.3-alpha.1 → 0.9.4-alpha.1

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

@@ -0,0 +1,297 @@
+import { BelongsToManyRepository, HasManyRepository, mockDatabase } from '../../index';
+import Database from '../../database';
+import { Collection } from '../../collection';
+
+describe('association aggregation', () => {
+  let db: Database;
+
+  let User: Collection;
+  let Post: Collection;
+  let Tag: Collection;
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    await db.clean({ drop: true });
+
+    User = db.collection({
+      name: 'users',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'integer', name: 'age' },
+        { type: 'hasMany', name: 'posts' },
+        {
+          type: 'belongsToMany',
+          name: 'tags',
+        },
+      ],
+    });
+
+    Post = db.collection({
+      name: 'posts',
+      fields: [
+        {
+          type: 'string',
+          name: 'title',
+        },
+        {
+          type: 'string',
+          name: 'category',
+        },
+        {
+          type: 'integer',
+          name: 'readCount',
+        },
+        {
+          type: 'belongsTo',
+          name: 'user',
+        },
+      ],
+    });
+
+    Tag = db.collection({
+      name: 'tags',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'integer',
+          name: 'score',
+        },
+      ],
+    });
+
+    await db.sync();
+  });
+
+  describe('belongs to many', () => {
+    beforeEach(async () => {
+      await User.repository.create({
+        values: [
+          {
+            name: 'u1',
+            age: 1,
+            tags: [
+              { name: 't1', score: 1 },
+              { name: 't2', score: 2 },
+            ],
+          },
+          {
+            name: 'u2',
+            age: 2,
+            tags: [
+              { name: 't3', score: 3 },
+              { name: 't4', score: 4 },
+              { name: 't5', score: 4 },
+            ],
+          },
+        ],
+      });
+    });
+
+    it('should sum field', async () => {
+      const user1 = await User.repository.findOne({
+        filter: {
+          name: 'u1',
+        },
+      });
+
+      const TagRepository = await db.getRepository<BelongsToManyRepository>('users.tags', user1.get('id'));
+
+      const sumResult = await TagRepository.aggregate({
+        field: 'score',
+        method: 'sum',
+      });
+
+      expect(sumResult).toEqual(3);
+    });
+
+    it('should sum with filter', async () => {
+      const user1 = await User.repository.findOne({
+        filter: {
+          name: 'u2',
+        },
+      });
+
+      const TagRepository = await db.getRepository<BelongsToManyRepository>('users.tags', user1.get('id'));
+
+      const sumResult = await TagRepository.aggregate({
+        field: 'score',
+        method: 'sum',
+        filter: {
+          score: 4,
+        },
+      });
+
+      expect(sumResult).toEqual(8);
+    });
+
+    it('should sum with distinct', async () => {
+      const user1 = await User.repository.findOne({
+        filter: {
+          name: 'u2',
+        },
+      });
+
+      const TagRepository = await db.getRepository<BelongsToManyRepository>('users.tags', user1.get('id'));
+
+      const sumResult = await TagRepository.aggregate({
+        field: 'score',
+        method: 'sum',
+        distinct: true,
+        filter: {
+          score: 4,
+        },
+      });
+
+      expect(sumResult).toEqual(4);
+    });
+    it('should sum with association filter', async () => {
+      const sumResult = await User.repository.aggregate({
+        field: 'age',
+        method: 'sum',
+        filter: {
+          'tags.score': 4,
+        },
+      });
+
+      expect(sumResult).toEqual(2);
+    });
+  });
+
+  describe('has many', () => {
+    beforeEach(async () => {
+      await User.repository.create({
+        values: [
+          {
+            name: 'u1',
+            age: 1,
+            posts: [
+              { title: 'p1', category: 'c1', readCount: 1 },
+              { title: 'p2', category: 'c2', readCount: 2 },
+            ],
+          },
+          {
+            name: 'u2',
+            age: 2,
+            posts: [
+              { title: 'p3', category: 'c3', readCount: 3 },
+              { title: 'p4', category: 'c4', readCount: 4 },
+            ],
+          },
+        ],
+      });
+    });
+
+    it('should sum field', async () => {
+      const user1 = await User.repository.findOne({
+        filter: {
+          name: 'u1',
+        },
+      });
+
+      const PostRepository = await db.getRepository<HasManyRepository>('users.posts', user1.get('id'));
+      const sumResult = await PostRepository.aggregate({
+        field: 'readCount',
+        method: 'sum',
+      });
+
+      expect(sumResult).toEqual(3);
+    });
+
+    it('should sum with filter', async () => {
+      const user1 = await User.repository.findOne({
+        filter: {
+          name: 'u1',
+        },
+      });
+
+      const PostRepository = await db.getRepository<HasManyRepository>('users.posts', user1.get('id'));
+      const sumResult = await PostRepository.aggregate({
+        field: 'readCount',
+        method: 'sum',
+      });
+
+      expect(sumResult).toEqual(3);
+    });
+  });
+});
+
+describe('Aggregation', () => {
+  let db: Database;
+
+  let User: Collection;
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    await db.clean({ drop: true });
+
+    User = db.collection({
+      name: 'users',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'integer',
+          name: 'age',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    await User.repository.create({
+      values: [
+        { name: 'u1', age: 1 },
+        { name: 'u2', age: 2 },
+        { name: 'u3', age: 3 },
+        { name: 'u4', age: 4 },
+        { name: 'u5', age: 5 },
+        { name: 'u5', age: 5 },
+      ],
+    });
+  });
+
+  describe('sum', () => {
+    it('should sum field', async () => {
+      const sumResult = await User.repository.aggregate({
+        method: 'sum',
+        field: 'age',
+      });
+
+      expect(sumResult).toEqual(20);
+    });
+
+    it('should sum with distinct', async () => {
+      const sumResult = await User.repository.aggregate({
+        method: 'sum',
+        field: 'age',
+        distinct: true,
+      });
+
+      expect(sumResult).toEqual(15);
+    });
+
+    it('should sum with filter', async () => {
+      const sumResult = await User.repository.aggregate({
+        method: 'sum',
+        field: 'age',
+        filter: {
+          name: 'u5',
+        },
+      });
+
+      expect(sumResult).toEqual(10);
+    });
+  });
+});

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

@@ -117,7 +117,7 @@ describe('count', () => {
       appends: ['tags'],
     });
 
-    expect(posts[0][0]['tags']).toBeDefined();
+    expect(posts[0][0].get('tags')).toBeDefined();
   });
 
   test('without filter params', async () => {

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

@@ -176,7 +176,7 @@ describe('find with associations', () => {
       },
     });
 
-    expect(filterResult[0].user.department).toBeDefined();
+    expect(filterResult[0].get('user').get('department')).toBeDefined();
   });
 
   it('should filter by association field', async () => {
@@ -440,6 +440,15 @@ describe('repository find', () => {
       expect(Object.keys(data)).toEqual(['id', 'posts']);
       expect(Object.keys(data['posts'])).not.toContain('id');
     });
+
+    test('find one with appends', async () => {
+      const profile = await Profile.repository.findOne({
+        filterByTk: 1,
+        appends: ['user.name'],
+      });
+
+      expect(profile.get('user').get('name')).toEqual('u1');
+    });
   });
 
   describe('find', () => {

package/src/__tests__/repository.test.ts

@@ -54,6 +54,7 @@ describe('repository.find', () => {
   let User: Collection;
   let Post: Collection;
   let Comment: Collection;
+  let Tag: Collection;
 
   beforeEach(async () => {
     db = mockDatabase();
@@ -70,8 +71,18 @@ describe('repository.find', () => {
         { type: 'string', name: 'name' },
         { type: 'belongsTo', name: 'user' },
         { type: 'hasMany', name: 'comments' },
+        { type: 'belongsToMany', name: 'tags' },
       ],
     });
+
+    Tag = db.collection({
+      name: 'tags',
+      fields: [
+        { type: 'string', name: 'name' },
+        { type: 'belongsToMany', name: 'posts' },
+      ],
+    });
+
     Comment = db.collection({
       name: 'comments',
       fields: [
@@ -80,6 +91,10 @@ describe('repository.find', () => {
       ],
     });
     await db.sync();
+
+    const tags = await Tag.repository.create({
+      values: [{ name: 't1' }, { name: 't2' }],
+    });
     await User.repository.createMany({
       records: [
         {
@@ -88,18 +103,22 @@ describe('repository.find', () => {
             {
               name: 'post11',
               comments: [{ name: 'comment111' }, { name: 'comment112' }, { name: 'comment113' }],
+              tags: [{ id: tags[0].get('id') }],
             },
             {
               name: 'post12',
               comments: [{ name: 'comment121' }, { name: 'comment122' }, { name: 'comment123' }],
+              tags: [{ id: tags[1].get('id') }, { id: tags[0].get('id') }],
             },
             {
               name: 'post13',
               comments: [{ name: 'comment131' }, { name: 'comment132' }, { name: 'comment133' }],
+              tags: [{ id: tags[0].get('id') }],
             },
             {
               name: 'post14',
               comments: [{ name: 'comment141' }, { name: 'comment142' }, { name: 'comment143' }],
+              tags: [{ id: tags[1].get('id') }],
             },
           ],
         },
@@ -109,6 +128,7 @@ describe('repository.find', () => {
             {
               name: 'post21',
               comments: [{ name: 'comment211' }, { name: 'comment212' }, { name: 'comment213' }],
+              tags: [{ id: tags[0].get('id') }, { id: tags[1].get('id') }],
             },
             {
               name: 'post22',
@@ -144,6 +164,16 @@ describe('repository.find', () => {
     await db.close();
   });
 
+  it('should appends with belongs to association', async () => {
+    const posts = await Post.repository.find({
+      appends: ['user'],
+    });
+
+    posts.forEach((post) => {
+      expect(post.get('user')).toBeDefined();
+    });
+  });
+
   test('find pk with filter', async () => {
     const Test = db.collection({
       name: 'tests',

package/src/__tests__/update-guard.test.ts

@@ -108,6 +108,19 @@ describe('update-guard', () => {
     });
   });
 
+  test('association with null array', () => {
+    const values = {
+      name: 'u1',
+      posts: [null],
+    };
+
+    const guard = new UpdateGuard();
+    guard.setModel(User.model);
+    const sanitized = guard.sanitize(values);
+
+    expect(sanitized).toEqual({ name: 'u1', posts: [null] });
+  });
+
   test('association black list', () => {
     const values = {
       name: 'username123',

package/src/collection.ts

@@ -79,6 +79,31 @@ export class Collection<
   model: ModelStatic<Model>;
   repository: Repository<TModelAttributes, TCreationAttributes>;
 
+  constructor(options: CollectionOptions, context: CollectionContext) {
+    super();
+    this.context = context;
+    this.options = options;
+
+    this.checkOptions(options);
+
+    this.bindFieldEventListener();
+    this.modelInit();
+
+    this.db.modelCollection.set(this.model, this);
+
+    // set tableName to collection map
+    // the form of key is `${schema}.${tableName}` if schema exists
+    // otherwise is `${tableName}`
+    this.db.tableNameCollectionMap.set(this.getTableNameWithSchemaAsString(), this);
+
+    if (!options.inherits) {
+      this.setFields(options.fields);
+    }
+
+    this.setRepository(options.repository);
+    this.setSortable(options.sortable);
+  }
+
   get filterTargetKey() {
     const targetKey = lodash.get(this.options, 'filterTargetKey', this.model.primaryKeyAttribute);
     if (!targetKey && this.model.rawAttributes['id']) {
@@ -116,65 +141,12 @@ export class Collection<
     }
   }
 
-  constructor(options: CollectionOptions, context: CollectionContext) {
-    super();
-    this.context = context;
-    this.options = options;
-
-    this.checkOptions(options);
-
-    this.bindFieldEventListener();
-    this.modelInit();
-
-    this.db.modelCollection.set(this.model, this);
-
-    // set tableName to collection map
-    // the form of key is `${schema}.${tableName}` if schema exists
-    // otherwise is `${tableName}`
-    this.db.tableNameCollectionMap.set(this.getTableNameWithSchemaAsString(), this);
-
-    if (!options.inherits) {
-      this.setFields(options.fields);
-    }
-
-    this.setRepository(options.repository);
-    this.setSortable(options.sortable);
-  }
-
-  private checkOptions(options: CollectionOptions) {
-    checkIdentifier(options.name);
-    this.checkTableName();
-  }
-
-  private checkTableName() {
-    const tableName = this.tableName();
-    for (const [k, collection] of this.db.collections) {
-      if (
-        collection.name != this.options.name &&
-        tableName === collection.tableName() &&
-        collection.collectionSchema() === this.collectionSchema()
-      ) {
-        throw new Error(`collection ${collection.name} and ${this.name} have same tableName "${tableName}"`);
-      }
-    }
-  }
-
   tableName() {
     const { name, tableName } = this.options;
     const tName = tableName || name;
     return this.options.underscored ? snakeCase(tName) : tName;
   }
 
-  protected sequelizeModelOptions() {
-    const { name } = this.options;
-    return {
-      ..._.omit(this.options, ['name', 'fields', 'model', 'targetKey']),
-      modelName: name,
-      sequelize: this.context.database.sequelize,
-      tableName: this.tableName(),
-    };
-  }
-
   /**
    * TODO
    */
@@ -232,17 +204,6 @@ export class Collection<
     this.repository = new repo(this);
   }
 
-  private bindFieldEventListener() {
-    this.on('field.afterAdd', (field: Field) => {
-      field.bind();
-    });
-
-    this.on('field.afterRemove', (field: Field) => {
-      field.unbind();
-      this.db.emit('field.afterRemove', field);
-    });
-  }
-
   forEachField(callback: (field: Field) => void) {
     return [...this.fields.values()].forEach(callback);
   }
@@ -299,12 +260,20 @@ export class Collection<
       const [sourceCollectionName, sourceFieldName] = options.source.split('.');
       const sourceCollection = this.db.collections.get(sourceCollectionName);
       if (!sourceCollection) {
-        throw new Error(
+        this.db.logger.warn(
           `source collection "${sourceCollectionName}" not found for field "${name}" at collection "${this.name}"`,
         );
       }
+
       const sourceField = sourceCollection.fields.get(sourceFieldName);
-      options = { ...sourceField.options, ...options };
+
+      if (!sourceField) {
+        this.db.logger.warn(
+          `source field "${sourceFieldName}" not found for field "${name}" at collection "${this.name}"`,
+        );
+      } else {
+        options = { ...sourceField.options, ...options };
+      }
     }
 
     this.emit('field.beforeAdd', name, options, { collection: this });
@@ -678,4 +647,43 @@ export class Collection<
   public isView() {
     return false;
   }
+
+  protected sequelizeModelOptions() {
+    const { name } = this.options;
+    return {
+      ..._.omit(this.options, ['name', 'fields', 'model', 'targetKey']),
+      modelName: name,
+      sequelize: this.context.database.sequelize,
+      tableName: this.tableName(),
+    };
+  }
+
+  private checkOptions(options: CollectionOptions) {
+    checkIdentifier(options.name);
+    this.checkTableName();
+  }
+
+  private checkTableName() {
+    const tableName = this.tableName();
+    for (const [k, collection] of this.db.collections) {
+      if (
+        collection.name != this.options.name &&
+        tableName === collection.tableName() &&
+        collection.collectionSchema() === this.collectionSchema()
+      ) {
+        throw new Error(`collection ${collection.name} and ${this.name} have same tableName "${tableName}"`);
+      }
+    }
+  }
+
+  private bindFieldEventListener() {
+    this.on('field.afterAdd', (field: Field) => {
+      field.bind();
+    });
+
+    this.on('field.afterRemove', (field: Field) => {
+      field.unbind();
+      this.db.emit('field.afterRemove', field);
+    });
+  }
 }