@nocobase/database 0.8.0-alpha.9 → 0.8.1-alpha.4

package/src/__tests__/inhertits/helper.ts

@@ -0,0 +1,3 @@
+const pgOnly = () => (process.env.DB_DIALECT == 'postgres' ? describe : describe.skip);
+
+export default pgOnly;

package/src/__tests__/inhertits/inherited-map.test.ts

@@ -0,0 +1,27 @@
+import InheritanceMap from '../../inherited-map';
+
+describe('InheritedMap', () => {
+  it('should setInherits', () => {
+    const map = new InheritanceMap();
+    map.setInheritance('b', 'a');
+
+    const nodeA = map.getNode('a');
+    const nodeB = map.getNode('b');
+
+    expect(nodeA.children.has(nodeB)).toBe(true);
+    expect(nodeB.parents.has(nodeA)).toBe(true);
+
+    expect(map.isParentNode('a')).toBe(true);
+  });
+
+  it('should get deep children', () => {
+    const map = new InheritanceMap();
+    map.setInheritance('b', 'a');
+    map.setInheritance('c', 'b');
+    map.setInheritance('c1', 'b');
+    map.setInheritance('d', 'c');
+
+    const children = map.getChildren('a');
+    expect(children.size).toBe(4);
+  });
+});

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

@@ -12,6 +12,7 @@ describe('belongs to many with target key', function () {
   beforeEach(async () => {
     db = mockDatabase();
 
+    await db.clean({ drop: true });
     Post = db.collection({
       name: 'posts',
       filterTargetKey: 'title',
@@ -121,6 +122,7 @@ describe('belongs to many', () => {
 
   beforeEach(async () => {
     db = mockDatabase();
+    await db.clean({ drop: true });
     PostTag = db.collection({
       name: 'posts_tags',
       fields: [{ type: 'string', name: 'tagged_at' }],

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

@@ -249,7 +249,7 @@ describe('has many repository', () => {
     expect(p1.title).toEqual('u1t1');
   });
 
-  test('find', async () => {
+  test('find with has many', async () => {
     const u1 = await User.repository.create({ values: { name: 'u1' } });
 
     const t1 = await Tag.repository.create({ values: { name: 't1' } });

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

@@ -13,6 +13,7 @@ describe('destroy with targetKey', function () {
 
   beforeEach(async () => {
     db = mockDatabase();
+
     User = db.collection({
       name: 'users',
       autoGenId: false,
@@ -76,7 +77,7 @@ describe('destroy with targetKey', function () {
 });
 
 describe('destroy', () => {
-  let db;
+  let db: Database;
   let User: Collection;
   let Post: Collection;
 
@@ -86,6 +87,10 @@ describe('destroy', () => {
 
   beforeEach(async () => {
     db = mockDatabase();
+    await db.clean({
+      drop: true,
+    });
+
     User = db.collection({
       name: 'users',
       fields: [
@@ -105,6 +110,122 @@ describe('destroy', () => {
     await db.sync();
   });
 
+  test('destroy records from no pk tables that filterTargetKey configured', async () => {
+    const Test = db.collection({
+      name: 'test',
+      timestamps: false,
+      autoGenId: false,
+      filterTargetKey: 'test',
+      fields: [
+        {
+          type: 'string',
+          name: 'test',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const t1 = await Test.repository.create({
+      values: {
+        test: 't1',
+      },
+    });
+
+    await Test.repository.create({
+      values: {
+        test: 't2',
+      },
+    });
+
+    await Test.repository.destroy({
+      filterByTk: 't2',
+    });
+
+    expect(await Test.repository.count()).toEqual(1);
+    expect((await Test.repository.findOne()).get('test')).toEqual('t1');
+  });
+
+  test('destroy records from tables without primary keys', async () => {
+    const Test = db.collection({
+      name: 'test',
+      timestamps: false,
+      autoGenId: false,
+      fields: [
+        {
+          type: 'string',
+          name: 'test',
+        },
+      ],
+    });
+
+    await db.sync();
+
+    const t1 = await Test.repository.create({
+      values: {
+        test: 't1',
+      },
+    });
+
+    await Test.repository.create({
+      values: {
+        test: 't2',
+      },
+    });
+
+    const destroy = async () => {
+      await Test.repository.destroy({
+        filterByTk: 111,
+      });
+    };
+
+    await expect(destroy()).rejects.toThrowError('filterByTk is not supported for collection that has no primary key');
+
+    await Test.repository.destroy({
+      filter: {
+        test: 't2',
+      },
+    });
+
+    expect(await Test.repository.count()).toEqual(1);
+    expect((await Test.repository.findOne()).get('test')).toEqual('t1');
+  });
+
+  test('destroy record has no primary key', async () => {
+    Post.addField('tags', {
+      type: 'belongsToMany',
+    });
+
+    const tags = db.collection({
+      name: 'tags',
+      fields: [
+        { type: 'belongsToMany', name: 'posts' },
+        { type: 'string', name: 'name' },
+      ],
+    });
+
+    await db.sync();
+
+    const post = await Post.repository.create({
+      values: {
+        title: 'p1',
+        tags: [{ name: 't1' }],
+      },
+    });
+
+    const throughCollection = db.getCollection(tags.getField('posts').options.through);
+
+    expect(await throughCollection.repository.count()).toEqual(1);
+
+    await throughCollection.repository.destroy({
+      filter: {
+        postId: post.get('id'),
+      },
+    });
+
+    expect(await throughCollection.repository.count()).toEqual(0);
+  });
+
   test('destroy with filter and filterByPk', async () => {
     const p1 = await Post.repository.create({
       values: {

package/src/__tests__/repository/update-many.test.ts

@@ -0,0 +1,57 @@
+import { Database, mockDatabase } from '@nocobase/database';
+
+describe('update many', () => {
+  let db: Database;
+  afterEach(async () => {
+    await db.close();
+  });
+
+  beforeEach(async () => {
+    db = mockDatabase();
+    db.collection({
+      name: 't1',
+      fields: [{ type: 'string', name: 'title' }],
+    });
+    await db.sync();
+  });
+
+  it('should update values', async () => {
+    const repository = db.getRepository('t1');
+    await repository.create({
+      values: [
+        { id: 1, title: 't1' },
+        { id: 2, title: 't2' },
+      ],
+    });
+    await repository.update({
+      values: [
+        { id: 1, title: 't11' },
+        { id: 2, title: 't22' },
+      ],
+    });
+    const items = await repository.find({
+      fields: ['title'],
+      sort: 'id',
+    });
+    expect(items.map((i) => i.title)).toEqual(['t11', 't22']);
+  });
+
+  it('should filterByTk invalid', async () => {
+    const repository = db.getRepository('t1');
+    await repository.create({
+      values: [
+        { id: 1, title: 't1' },
+        { id: 2, title: 't2' },
+      ],
+    });
+    let err;
+    try {
+      await repository.update({
+        values: [{ id: 1, title: 't11' }, { title: 't22' }],
+      });
+    } catch (error) {
+      err = error;
+    }
+    expect(err?.message).toBe('filterByTk invalid');
+  });
+});

package/src/__tests__/update-association-values.test.ts

@@ -0,0 +1,232 @@
+import { Database } from '../database';
+import { mockDatabase } from './';
+
+describe('update associations', () => {
+  let db: Database;
+  beforeEach(async () => {
+    db = mockDatabase();
+    await db.clean({ drop: true });
+  });
+
+  afterEach(async () => {
+    await db.close();
+  });
+
+  it('hasOne', async () => {
+    db.collection({
+      name: 'a',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasOne',
+          name: 'b',
+          target: 'b',
+        },
+      ],
+    });
+    db.collection({
+      name: 'b',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasOne',
+          name: 'c',
+          target: 'c',
+        },
+      ],
+    });
+    db.collection({
+      name: 'c',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasOne',
+          name: 'd',
+          target: 'd',
+        },
+      ],
+    });
+    db.collection({
+      name: 'd',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+      ],
+    });
+    await db.sync();
+    const b = await db.getRepository('b').create({
+      values: {},
+    });
+    const c = await db.getRepository('c').create({
+      values: {},
+    });
+    const d = await db.getRepository('d').create({
+      values: {},
+    });
+    await db.getRepository('a').create({
+      updateAssociationValues: ['b'],
+      values: {
+        name: 'a1',
+        b: {
+          id: b.id,
+          c: {
+            id: c.id,
+            d: {
+              id: d.id,
+            },
+          },
+        },
+      },
+    });
+    const d1 = await d.reload();
+    expect(d1.cId).toBe(c.id);
+
+    const b2 = await db.getRepository('b').create({
+      values: {},
+    });
+    const c2 = await db.getRepository('c').create({
+      values: {},
+    });
+    const d2 = await db.getRepository('d').create({
+      values: {},
+    });
+    await db.getRepository('a').create({
+      values: {
+        name: 'a1',
+        b: {
+          id: b2.id,
+          c: {
+            id: c2.id,
+            d: {
+              id: d2.id,
+            },
+          },
+        },
+      },
+    });
+    const c22 = await c2.reload();
+    expect(c22.bId).toBeNull();
+    const d22 = await d2.reload();
+    expect(d22.cId).toBeNull();
+  });
+
+  it('hasMany', async () => {
+    db.collection({
+      name: 'a',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasMany',
+          name: 'b',
+          target: 'b',
+        },
+      ],
+    });
+    db.collection({
+      name: 'b',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasMany',
+          name: 'c',
+          target: 'c',
+        },
+      ],
+    });
+    db.collection({
+      name: 'c',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+        {
+          type: 'hasMany',
+          name: 'd',
+          target: 'd',
+        },
+      ],
+    });
+    db.collection({
+      name: 'd',
+      fields: [
+        {
+          type: 'string',
+          name: 'name',
+        },
+      ],
+    });
+
+    await db.sync();
+    const b = await db.getRepository('b').create({
+      values: {},
+    });
+    const c = await db.getRepository('c').create({
+      values: {},
+    });
+    const d = await db.getRepository('d').create({
+      values: {},
+    });
+    await db.getRepository('a').create({
+      updateAssociationValues: ['b'],
+      values: {
+        name: 'a1',
+        b: {
+          id: b.id,
+          c: {
+            id: c.id,
+            d: {
+              id: d.id,
+            },
+          },
+        },
+      },
+    });
+    const d1 = await d.reload();
+    expect(d1.cId).toBe(c.id);
+    const b2 = await db.getRepository('b').create({
+      values: {},
+    });
+    const c2 = await db.getRepository('c').create({
+      values: {},
+    });
+    const d2 = await db.getRepository('d').create({
+      values: {},
+    });
+    await db.getRepository('a').create({
+      values: {
+        name: 'a1',
+        b: {
+          id: b2.id,
+          c: {
+            id: c2.id,
+            d: {
+              id: d2.id,
+            },
+          },
+        },
+      },
+    });
+    const c22 = await c2.reload();
+    expect(c22.bId).toBeNull();
+    const d22 = await d2.reload();
+    expect(d22.cId).toBeNull();
+  });
+});

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

@@ -83,7 +83,12 @@ describe('update associations', () => {
         },
       });
 
-      expect(post4.toJSON()).toMatchObject({
+      const p4 = await db.getRepository('posts').findOne({
+        filterByTk: post4.id,
+        appends: ['user'],
+      });
+
+      expect(p4?.toJSON()).toMatchObject({
         id: 4,
         name: 'post4',
         userId: 1,

package/src/collection.ts

@@ -2,11 +2,11 @@ import merge from 'deepmerge';
 import { EventEmitter } from 'events';
 import { default as lodash, default as _ } from 'lodash';
 import {
-  ModelCtor,
   ModelOptions,
   QueryInterfaceDropTableOptions,
   SyncOptions,
   Transactionable,
+  ModelStatic,
   Utils,
 } from 'sequelize';
 import { Database } from './database';
@@ -22,9 +22,10 @@ export type CollectionSortable = string | boolean | { name?: string; scopeKey?:
 export interface CollectionOptions extends Omit<ModelOptions, 'name' | 'hooks'> {
   name: string;
   tableName?: string;
+  inherits?: string[] | string;
   filterTargetKey?: string;
   fields?: FieldOptions[];
-  model?: string | ModelCtor<Model>;
+  model?: string | ModelStatic<Model>;
   repository?: string | RepositoryType;
   sortable?: CollectionSortable;
   /**
@@ -50,7 +51,7 @@ export class Collection<
   context: CollectionContext;
   isThrough?: boolean;
   fields: Map<string, any> = new Map<string, any>();
-  model: ModelCtor<Model>;
+  model: ModelStatic<Model>;
   repository: Repository<TModelAttributes, TCreationAttributes>;
 
   get filterTargetKey() {
@@ -74,9 +75,14 @@ export class Collection<
 
     this.bindFieldEventListener();
     this.modelInit();
+
     this.db.modelCollection.set(this.model, this);
+    this.db.tableNameCollectionMap.set(this.model.tableName, this);
+
+    if (!options.inherits) {
+      this.setFields(options.fields);
+    }
 
-    this.setFields(options.fields);
     this.setRepository(options.repository);
     this.setSortable(options.sortable);
   }
@@ -103,7 +109,7 @@ export class Collection<
       return;
     }
     const { name, model, autoGenId = true } = this.options;
-    let M: ModelCtor<Model> = Model;
+    let M: ModelStatic<Model> = Model;
     if (this.context.database.sequelize.isDefined(name)) {
       const m = this.context.database.sequelize.model(name);
       if ((m as any).isThrough) {
@@ -144,8 +150,13 @@ export class Collection<
   }
 
   private bindFieldEventListener() {
-    this.on('field.afterAdd', (field: Field) => field.bind());
-    this.on('field.afterRemove', (field: Field) => field.unbind());
+    this.on('field.afterAdd', (field: Field) => {
+      field.bind();
+    });
+
+    this.on('field.afterRemove', (field: Field) => {
+      field.unbind();
+    });
   }
 
   forEachField(callback: (field: Field) => void) {
@@ -181,9 +192,39 @@ export class Collection<
       },
     );
 
+    const oldField = this.fields.get(name);
+
+    if (oldField && oldField.options.inherit && field.typeToString() != oldField.typeToString()) {
+      throw new Error(
+        `Field type conflict: cannot set "${name}" on "${this.name}" to ${options.type}, parent "${name}" type is ${oldField.options.type}`,
+      );
+    }
+
+    if (this.options.autoGenId !== false && options.primaryKey) {
+      this.model.removeAttribute('id');
+    }
+
     this.removeField(name);
     this.fields.set(name, field);
     this.emit('field.afterAdd', field);
+
+    // refresh children models
+    if (this.isParent()) {
+      for (const child of this.context.database.inheritanceMap.getChildren(this.name, {
+        deep: false,
+      })) {
+        const childCollection = this.db.getCollection(child);
+        const existField = childCollection.getField(name);
+
+        if (!existField || existField.options.inherit) {
+          childCollection.setField(name, {
+            ...options,
+            inherit: true,
+          });
+        }
+      }
+    }
+
     return field;
   }
 
@@ -232,11 +273,27 @@ export class Collection<
     if (!this.fields.has(name)) {
       return;
     }
+
     const field = this.fields.get(name);
+
     const bool = this.fields.delete(name);
+
     if (bool) {
+      if (this.isParent()) {
+        for (const child of this.db.inheritanceMap.getChildren(this.name, {
+          deep: false,
+        })) {
+          const childCollection = this.db.getCollection(child);
+          const existField = childCollection.getField(name);
+          if (existField && existField.options.inherit) {
+            childCollection.removeField(name);
+          }
+        }
+      }
+
       this.emit('field.afterRemove', field);
     }
+
     return field as Field;
   }
 
@@ -349,6 +406,7 @@ export class Collection<
         }
         return item;
       });
+    this.refreshIndexes();
   }
 
   removeIndex(fields: any) {
@@ -361,6 +419,21 @@ export class Collection<
     this.model._indexes = indexes.filter((item) => {
       return !lodash.isEqual(item.fields, fields);
     });
+    this.refreshIndexes();
+  }
+
+  refreshIndexes() {
+    // @ts-ignore
+    const indexes: any[] = this.model._indexes;
+    // @ts-ignore
+    this.model._indexes = indexes.filter((item) => {
+      for (const field of item.fields) {
+        if (!this.model.rawAttributes[field]) {
+          return false;
+        }
+      }
+      return true;
+    });
   }
 
   async sync(syncOptions?: SyncOptions) {
@@ -371,12 +444,13 @@ export class Collection<
     for (const associationKey in associations) {
       const association = associations[associationKey];
       modelNames.add(association.target.name);
+
       if ((<any>association).through) {
         modelNames.add((<any>association).through.model.name);
       }
     }
 
-    const models: ModelCtor<Model>[] = [];
+    const models: ModelStatic<Model>[] = [];
     // @ts-ignore
     this.context.database.sequelize.modelManager.forEachModel((model) => {
       if (modelNames.has(model.name)) {
@@ -388,4 +462,12 @@ export class Collection<
       await model.sync(syncOptions);
     }
   }
+
+  public isInherited() {
+    return false;
+  }
+
+  public isParent() {
+    return this.context.database.inheritanceMap.isParentNode(this.name);
+  }
 }