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

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

@@ -9,6 +9,9 @@ describe('has one repository', () => {
   let User: Collection;
   let Profile: Collection;
 
+  let A1: Collection;
+  let A2: Collection;
+
   afterEach(async () => {
     await db.close();
   });
@@ -25,12 +28,75 @@ describe('has one repository', () => {
 
     Profile = db.collection({
       name: 'profiles',
-      fields: [{ type: 'string', name: 'avatar' }],
+      fields: [
+        { type: 'string', name: 'avatar' },
+        {
+          type: 'hasMany',
+          name: 'a1',
+        },
+        {
+          type: 'hasMany',
+          name: 'a2',
+        },
+      ],
+    });
+
+    A1 = db.collection({
+      name: 'a1',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    A2 = db.collection({
+      name: 'a2',
+      fields: [{ type: 'string', name: 'name' }],
     });
 
     await db.sync();
   });
 
+  test('find with appends', async () => {
+    const user = await User.repository.create({
+      values: {
+        name: 'u1',
+        profile: {
+          avatar: 'avatar',
+          a1: [
+            {
+              name: 'a11',
+            },
+            {
+              name: 'a12',
+            },
+            {
+              name: 'a13',
+            },
+          ],
+          a2: [
+            {
+              name: 'a21',
+            },
+            {
+              name: 'a22',
+            },
+            {
+              name: 'a23',
+            },
+          ],
+        },
+      },
+    });
+
+    const UserProfileRepository = new HasOneRepository(User, 'profile', user['id']);
+
+    const profile = await UserProfileRepository.find({
+      appends: ['a1', 'a2'],
+    });
+
+    const data = profile.toJSON();
+    expect(data['a1']).toBeDefined();
+    expect(data['a2']).toBeDefined();
+  });
+
   test('find', async () => {
     const user = await User.repository.create({
       values: { name: 'u1' },
@@ -70,6 +136,7 @@ describe('has one repository', () => {
         avatar: 'new_updated_avatar',
       },
     });
+
     expect((await UserProfileRepository.find())['avatar']).toEqual('new_updated_avatar');
     await UserProfileRepository.destroy();
     expect(await UserProfileRepository.find()).toBeNull();

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

@@ -10,6 +10,9 @@ describe('repository find', () => {
   let Comment: Collection;
   let Tag: Collection;
 
+  let A1: Collection;
+  let A2: Collection;
+
   afterEach(async () => {
     await db.close();
   });
@@ -23,9 +26,21 @@ describe('repository find', () => {
         { type: 'string', name: 'name' },
         { type: 'integer', name: 'age' },
         { type: 'hasMany', name: 'posts' },
+        { type: 'belongsToMany', name: 'a1' },
+        { type: 'belongsToMany', name: 'a2' },
       ],
     });
 
+    A1 = db.collection({
+      name: 'a1',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
+    A2 = db.collection({
+      name: 'a2',
+      fields: [{ type: 'string', name: 'name' }],
+    });
+
     Post = db.collection({
       name: 'posts',
       fields: [
@@ -73,11 +88,15 @@ describe('repository find', () => {
           name: 'u1',
           age: 10,
           posts: [{ title: 'u1t1', comments: [{ content: 'u1t1c1' }], abc1: [{ name: 't1' }] }],
+          a1: [{ name: 'u1a11' }, { name: 'u1a12' }],
+          a2: [{ name: 'u1a21' }, { name: 'u1a22' }],
         },
         {
           name: 'u2',
           age: 20,
           posts: [{ title: 'u2t1', comments: [{ content: 'u2t1c1' }] }],
+          a1: [{ name: 'u2a11' }, { name: 'u2a12' }],
+          a2: [{ name: 'u2a21' }, { name: 'u2a22' }],
         },
         {
           name: 'u3',
@@ -161,6 +180,22 @@ describe('repository find', () => {
     });
 
     describe('find with appends', () => {
+      test('toJSON', async () => {
+        const user = await User.repository.findOne({
+          filter: {
+            name: 'u1',
+          },
+          appends: ['a1', 'a2'],
+        });
+
+        const data = user.toJSON();
+
+        expect(user['a1']).toBeDefined();
+        expect(user['a2']).toBeDefined();
+        expect(data['a1'][0].createdAt).toBeDefined();
+        expect(data['a2'][0].createdAt).toBeDefined();
+      });
+
       test('filter attribute', async () => {
         const user = await User.repository.findOne({
           filter: {

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

@@ -57,4 +57,39 @@ describe('update', () => {
 
     expect(p1.toJSON()['tags']).toEqual([]);
   });
+
+  it('should not update items without filter or filterByPk', async () => {
+    await db.getRepository('posts').create({
+      values: {
+        title: 'p1',
+      },
+    });
+
+    let error;
+
+    try {
+      await db.getRepository('posts').update({
+        values: {
+          title: 'p3',
+        },
+      });
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error).not.toBeUndefined();
+
+    const p1 = await db.getRepository('posts').findOne();
+    expect(p1.toJSON()['title']).toEqual('p1');
+
+    await db.getRepository('posts').update({
+      values: {
+        title: 'p3',
+      },
+      filterByTk: p1.get('id') as number,
+    });
+
+    await p1.reload();
+    expect(p1.toJSON()['title']).toEqual('p3');
+  });
 });

package/src/__tests__/repository.test.ts

@@ -234,6 +234,21 @@ describe('repository.create', () => {
     const comments = await Comment.model.findAll();
     expect(comments.map((m) => m.get('postId'))).toEqual([post.get('id'), post.get('id'), post.get('id')]);
   });
+
+  it('can create with array of values', async () => {
+    const users = await User.repository.create({
+      values: [
+        {
+          name: 'u1',
+        },
+        {
+          name: 'u2',
+        },
+      ],
+    });
+
+    expect(users.length).toEqual(2);
+  });
 });
 
 describe('repository.update', () => {

package/src/collection.ts

@@ -7,12 +7,13 @@ import {
   QueryInterfaceDropTableOptions,
   SyncOptions,
   Transactionable,
-  Utils
+  Utils,
 } from 'sequelize';
 import { Database } from './database';
 import { Field, FieldOptions } from './fields';
 import { Model } from './model';
 import { Repository } from './repository';
+import { checkIdentifier, md5 } from './utils';
 
 export type RepositoryType = typeof Repository;
 
@@ -66,8 +67,11 @@ export class Collection<
 
   constructor(options: CollectionOptions, context?: CollectionContext) {
     super();
+    this.checkOptions(options);
+
     this.context = context;
     this.options = options;
+
     this.bindFieldEventListener();
     this.modelInit();
     this.setFields(options.fields);
@@ -75,6 +79,10 @@ export class Collection<
     this.setSortable(options.sortable);
   }
 
+  private checkOptions(options: CollectionOptions) {
+    checkIdentifier(options.name);
+  }
+
   private sequelizeModelOptions() {
     const { name, tableName } = this.options;
     return {
@@ -134,10 +142,8 @@ export class Collection<
   }
 
   private bindFieldEventListener() {
-    this.on('field.afterAdd', (field: Field) => {
-      field.bind();
-    });
-    this.on('field.afterRemove', (field) => field.unbind());
+    this.on('field.afterAdd', (field: Field) => field.bind());
+    this.on('field.afterRemove', (field: Field) => field.unbind());
   }
 
   forEachField(callback: (field: Field) => void) {
@@ -161,6 +167,8 @@ export class Collection<
   }
 
   setField(name: string, options: FieldOptions): Field {
+    checkIdentifier(name);
+
     const { database } = this.context;
 
     const field = database.buildField(
@@ -170,6 +178,7 @@ export class Collection<
         collection: this,
       },
     );
+
     this.removeField(name);
     this.fields.set(name, field);
     this.emit('field.afterAdd', field);
@@ -217,7 +226,7 @@ export class Collection<
     return this.db.collectionExistsInDb(this.name, options);
   }
 
-  removeField(name) {
+  removeField(name: string): void | Field {
     if (!this.fields.has(name)) {
       return;
     }
@@ -285,7 +294,7 @@ export class Collection<
     this.setField(options.name || name, options);
   }
 
-  addIndex(index: any) {
+  addIndex(index: string | string[] | { fields: string[]; unique?: boolean; [key: string]: any }) {
     if (!index) {
       return;
     }
@@ -331,7 +340,13 @@ export class Collection<
     // @ts-ignore
     this.model._indexes = this.model.options.indexes
       // @ts-ignore
-      .map((index) => Utils.nameIndex(this.model._conformIndex(index), tableName));
+      .map((index) => Utils.nameIndex(this.model._conformIndex(index), tableName))
+      .map((item) => {
+        if (item.name && item.name.length > 63) {
+          item.name = 'i_' + md5(item.name);
+        }
+        return item;
+      });
   }
 
   removeIndex(fields: any) {
@@ -347,22 +362,22 @@ export class Collection<
   }
 
   async sync(syncOptions?: SyncOptions) {
-    const modelNames = [this.model.name];
+    const modelNames = new Set([this.model.name]);
 
-    const associations = this.model.associations;
+    const { associations } = this.model;
 
     for (const associationKey in associations) {
       const association = associations[associationKey];
-      modelNames.push(association.target.name);
+      modelNames.add(association.target.name);
       if ((<any>association).through) {
-        modelNames.push((<any>association).through.model.name);
+        modelNames.add((<any>association).through.model.name);
       }
     }
 
     const models: ModelCtor<Model>[] = [];
     // @ts-ignore
     this.context.database.sequelize.modelManager.forEachModel((model) => {
-      if (modelNames.includes(model.name)) {
+      if (modelNames.has(model.name)) {
         models.push(model);
       }
     });

package/src/database.ts

@@ -21,7 +21,7 @@ import { Collection, CollectionOptions, RepositoryType } from './collection';
 import { ImporterReader, ImportFileExtension } from './collection-importer';
 import * as FieldTypes from './fields';
 import { Field, FieldContext, RelationField } from './fields';
-import { Migrations } from './migration';
+import { MigrationItem, Migrations } from './migration';
 import { Model } from './model';
 import { ModelHook } from './model-hook';
 import extendOperators from './operators';
@@ -81,14 +81,16 @@ class DatabaseVersion {
       },
       mysql: {
         sql: 'select version() as version',
-        get: (v) => v,
+        get: (v) => {
+          const m = /([\d+\.]+)/.exec(v);
+          return m[0];
+        },
       },
       postgres: {
         sql: 'select version() as version',
         get: (v) => {
-          const keys = v.split(/\s|,/);
-          keys.shift();
-          return semver.minVersion(keys.shift()).version;
+          const m = /([\d+\.]+)/.exec(v);
+          return semver.minVersion(m[0]).version;
         },
       },
     };
@@ -203,9 +205,17 @@ export class Database extends EventEmitter implements AsyncEmitter {
         opts.tableName = `${this.options.tablePrefix}${opts.tableName || opts.modelName || opts.name.plural}`;
       }
     });
+
+    this.on('afterCreate', async (instance) => {
+      instance?.toChangedWithAssociations?.();
+    });
+
+    this.on('afterUpdate', async (instance) => {
+      instance?.toChangedWithAssociations?.();
+    });
   }
 
-  addMigration(item) {
+  addMigration(item: MigrationItem) {
     return this.migrations.add(item);
   }
 
@@ -369,9 +379,11 @@ export class Database extends EventEmitter implements AsyncEmitter {
   buildField(options, context: FieldContext) {
     const { type } = options;
     const Field = this.fieldTypes.get(type);
+
     if (!Field) {
       throw Error(`unsupported field type ${type}`);
     }
+
     return new Field(options, context);
   }
 

package/src/decorators/must-have-filter-decorator.ts

@@ -0,0 +1,17 @@
+const mustHaveFilter = () => (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+  const oldValue = descriptor.value;
+
+  descriptor.value = function () {
+    const options = arguments[0];
+
+    if (!options?.filter && !options?.filterByTk && !options?.forceUpdate) {
+      throw new Error(`must provide filter or filterByTk for ${propertyKey} call, or set forceUpdate to true`);
+    }
+
+    return oldValue.apply(this, arguments);
+  };
+
+  return descriptor;
+};
+
+export default mustHaveFilter;

package/src/{transaction-decorator.ts → decorators/transaction-decorator.ts}

@@ -37,13 +37,12 @@ export function transactionWrapperBuilder(transactionGenerator) {
               throw new Error(`please provide transactionInjector for ${name} call`);
             }
 
-            const results = await oldValue.apply(this, [callArguments]);
+            const results = await oldValue.call(this, callArguments);
 
             await transaction.commit();
 
             return results;
           } catch (err) {
-            console.error({ err });
             await transaction.rollback();
             throw err;
           }

package/src/errors/identifier-error.ts

@@ -0,0 +1,6 @@
+export class IdentifierError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'IdentifierError';
+  }
+}

package/src/fields/belongs-to-field.ts

@@ -1,5 +1,6 @@
 import { omit } from 'lodash';
 import { BelongsToOptions as SequelizeBelongsToOptions, Utils } from 'sequelize';
+import { checkIdentifier } from '../utils';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
 
 export class BelongsToField extends RelationField {
@@ -42,10 +43,18 @@ export class BelongsToField extends RelationField {
       this.options.foreignKey = association.foreignKey;
     }
 
+    try {
+      checkIdentifier(this.options.foreignKey);
+    } catch (error) {
+      this.unbind();
+      throw error;
+    }
+
     if (!this.options.sourceKey) {
       // @ts-ignore
       this.options.sourceKey = association.sourceKey;
     }
+
     this.collection.addIndex([this.options.foreignKey]);
     return true;
   }

package/src/fields/belongs-to-many-field.ts

@@ -1,6 +1,7 @@
 import { omit } from 'lodash';
 import { BelongsToManyOptions as SequelizeBelongsToManyOptions, Utils } from 'sequelize';
 import { Collection } from '../collection';
+import { checkIdentifier } from '../utils';
 import { MultipleRelationFieldOptions, RelationField } from './relation-field';
 
 export class BelongsToManyField extends RelationField {
@@ -23,6 +24,7 @@ export class BelongsToManyField extends RelationField {
       database.addPendingField(this);
       return false;
     }
+
     const through = this.through;
 
     let Through: Collection;
@@ -33,6 +35,7 @@ export class BelongsToManyField extends RelationField {
       Through = database.collection({
         name: through,
       });
+
       Object.defineProperty(Through.model, 'isThrough', { value: true });
     }
 
@@ -49,15 +52,27 @@ export class BelongsToManyField extends RelationField {
     if (!this.options.foreignKey) {
       this.options.foreignKey = association.foreignKey;
     }
+
     if (!this.options.sourceKey) {
       this.options.sourceKey = association.sourceKey;
     }
+
     if (!this.options.otherKey) {
       this.options.otherKey = association.otherKey;
     }
+
+    try {
+      checkIdentifier(this.options.foreignKey);
+      checkIdentifier(this.options.otherKey);
+    } catch (error) {
+      this.unbind();
+      throw error;
+    }
+
     if (!this.options.through) {
       this.options.through = this.through;
     }
+
     Through.addIndex([this.options.foreignKey]);
     Through.addIndex([this.options.otherKey]);
     return true;

package/src/fields/date-field.ts

@@ -3,7 +3,7 @@ import { BaseColumnFieldOptions, Field } from './field';
 
 export class DateField extends Field {
   get dataType() {
-    return DataTypes.DATE;
+    return DataTypes.DATE(3);
   }
 }
 

package/src/fields/field.ts

@@ -5,10 +5,11 @@ import {
   ModelIndexesOptions,
   QueryInterfaceOptions,
   SyncOptions,
-  Transactionable
+  Transactionable,
 } from 'sequelize';
 import { Collection } from '../collection';
 import { Database } from '../database';
+import { checkIdentifier } from '../utils';
 
 export interface FieldContext {
   database: Database;
@@ -53,7 +54,6 @@ export abstract class Field {
     this.init();
   }
 
-  // TODO
   async sync(syncOptions: SyncOptions) {
     await this.collection.sync({
       ...syncOptions,
@@ -179,7 +179,7 @@ export abstract class Field {
   unbind() {
     const { model } = this.context.collection;
     model.removeAttribute(this.name);
-    if (this.options.index) {
+    if (this.options.index || this.options.unique) {
       this.context.collection.removeIndex([this.name]);
     }
   }

package/src/fields/formula-field.ts

@@ -16,7 +16,7 @@ export class FormulaField extends Field {
     return result;
   }
 
-  async initFieldData({ transaction }) {
+  initFieldData = async ({ transaction }) => {
     const { expression, name } = this.options;
 
     const records = await this.collection.repository.find({
@@ -42,7 +42,7 @@ export class FormulaField extends Field {
     }
   }
 
-  async caculateField(instance) {
+  caculateField = async (instance) => {
     const { expression, name } = this.options;
     const scope = instance.toJSON();
     let result;
@@ -55,7 +55,7 @@ export class FormulaField extends Field {
     }
   }
 
-  async updateFieldData(instance, { transaction }) {
+  updateFieldData = async (instance, { transaction }) => {
     if (this.collection.name === instance.collectionName && instance.name === this.options.name) {
       this.options = Object.assign(this.options, instance.options);
       const { name, expression } = this.options;
@@ -64,7 +64,7 @@ export class FormulaField extends Field {
         order: [this.collection.model.primaryKeyAttribute],
         transaction,
       });
-  
+
       for (const record of records) {
         const scope = record.toJSON();
         const result = this.caculate(expression, scope);
@@ -84,18 +84,18 @@ export class FormulaField extends Field {
 
   bind() {
     super.bind();
-    this.on('afterSync', this.initFieldData.bind(this));
-    this.database.on('fields.afterUpdate', this.updateFieldData.bind(this));
-    this.on('beforeCreate', this.caculateField.bind(this));
-    this.on('beforeUpdate', this.caculateField.bind(this));
+    this.on('afterSync', this.initFieldData);
+    // TODO: should not depends on fields table (which is defined by other plugin)
+    this.database.on('fields.afterUpdate', this.updateFieldData);
+    this.on('beforeSave', this.caculateField);
   }
 
   unbind() {
     super.unbind();
-    this.off('beforeCreate', this.caculateField.bind(this));
-    this.off('beforeUpdate', this.caculateField.bind(this));
-    this.database.off('fields.afterUpdate', this.updateFieldData.bind(this));
-    this.off('afterSync', this.initFieldData.bind(this));
+    this.off('beforeSave', this.caculateField);
+    // TODO: should not depends on fields table
+    this.database.off('fields.afterUpdate', this.updateFieldData);
+    this.off('afterSync', this.initFieldData);
   }
 }
 
@@ -103,4 +103,4 @@ export interface FormulaFieldOptions extends BaseColumnFieldOptions {
   type: 'formula';
 
   expression: string;
-}
+}

package/src/fields/has-many-field.ts

@@ -8,6 +8,7 @@ import {
   Utils
 } from 'sequelize';
 import { Collection } from '../collection';
+import { checkIdentifier } from '../utils';
 import { MultipleRelationFieldOptions, RelationField } from './relation-field';
 
 export interface HasManyFieldOptions extends HasManyOptions {
@@ -98,6 +99,7 @@ export class HasManyField extends RelationField {
       as: this.name,
       foreignKey: this.foreignKey,
     });
+
     // inverse relation
     // this.TargetModel.belongsTo(collection.model);
 
@@ -107,6 +109,14 @@ export class HasManyField extends RelationField {
     if (!this.options.foreignKey) {
       this.options.foreignKey = association.foreignKey;
     }
+
+    try {
+      checkIdentifier(this.options.foreignKey);
+    } catch (error) {
+      this.unbind();
+      throw error;
+    }
+
     if (!this.options.sourceKey) {
       // @ts-ignore
       this.options.sourceKey = association.sourceKey;