@nocobase/database 0.7.0-alpha.82 → 0.7.1-alpha.4

package/src/fields/formula-field.ts

@@ -0,0 +1,106 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+import * as math from 'mathjs';
+
+export class FormulaField extends Field {
+  get dataType() {
+    return DataTypes.FLOAT;
+  }
+
+  caculate(expression, scope) {
+    let result = null;
+    try {
+      result = math.evaluate(expression, scope);
+      result = math.round(result, 9);
+    } catch {}
+    return result;
+  }
+
+  async initFieldData({ transaction }) {
+    const { expression, name } = this.options;
+
+    const records = await this.collection.repository.find({
+      order: [this.collection.model.primaryKeyAttribute],
+      transaction,
+    });
+
+    for (const record of records) {
+      const scope = record.toJSON();
+      const result = this.caculate(expression, scope);
+      if (result) {
+        await record.update(
+          {
+            [name]: result,
+          },
+          {
+            transaction,
+            silent: true,
+            hooks: false,
+          },
+        );
+      }
+    }
+  }
+
+  async caculateField(instance) {
+    const { expression, name } = this.options;
+    const scope = instance.toJSON();
+    let result;
+    try {
+      result = math.evaluate(expression, scope);
+      result = math.round(result, 9);
+    } catch {}
+    if (result) {
+      instance.set(name, result);
+    }
+  }
+
+  async updateFieldData(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;
+
+      const records = await this.collection.repository.find({
+        order: [this.collection.model.primaryKeyAttribute],
+        transaction,
+      });
+  
+      for (const record of records) {
+        const scope = record.toJSON();
+        const result = this.caculate(expression, scope);
+        await record.update(
+          {
+            [name]: result,
+          },
+          {
+            transaction,
+            silent: true,
+            hooks: false,
+          },
+        );
+      }
+    }
+  }
+
+  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));
+  }
+
+  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));
+  }
+}
+
+export interface FormulaFieldOptions extends BaseColumnFieldOptions {
+  type: 'formula';
+
+  expression: string;
+}

package/src/fields/index.ts

@@ -24,6 +24,7 @@ import { TimeFieldOptions } from './time-field';
 import { UidFieldOptions } from './uid-field';
 import { UUIDFieldOptions } from './uuid-field';
 import { VirtualFieldOptions } from './virtual-field';
+import { FormulaFieldOptions } from './formula-field'
 
 export * from './array-field';
 export * from './belongs-to-field';
@@ -46,6 +47,7 @@ export * from './time-field';
 export * from './uid-field';
 export * from './uuid-field';
 export * from './virtual-field';
+export * from './formula-field';
 
 export type FieldOptions =
   | BaseFieldOptions
@@ -62,6 +64,7 @@ export type FieldOptions =
   | SortFieldOptions
   | TextFieldOptions
   | VirtualFieldOptions
+  | FormulaFieldOptions
   | ArrayFieldOptions
   | TimeFieldOptions
   | DateFieldOptions

package/src/index.ts

@@ -4,6 +4,7 @@ export * from './database';
 export { Database as default } from './database';
 export * from './fields';
 export * from './magic-attribute-model';
+export * from './migration';
 export * from './mock-database';
 export * from './model';
 export * from './relation-repository/belongs-to-many-repository';

package/src/migration.ts

@@ -0,0 +1,76 @@
+import { QueryInterface, Sequelize } from 'sequelize';
+import Database from './database';
+
+export interface MigrationContext {
+  db: Database;
+  queryInterface: QueryInterface;
+  sequelize: Sequelize;
+}
+
+export class Migration {
+  public name: string;
+
+  public context: { db: Database; [key: string]: any };
+
+  constructor(context: MigrationContext) {
+    this.context = context;
+  }
+
+  get db() {
+    return this.context.db;
+  }
+
+  get sequelize() {
+    return this.context.db.sequelize;
+  }
+
+  get queryInterface() {
+    return this.context.db.sequelize.getQueryInterface();
+  }
+
+  async up() {
+    // todo
+  }
+
+  async down() {
+    // todo
+  }
+}
+
+export interface MigrationItem {
+  name: string;
+  migration?: typeof Migration;
+  context?: any;
+  up?: any;
+  down?: any;
+}
+
+export class Migrations {
+  items = [];
+  context: any;
+
+  constructor(context: any) {
+    this.context = context;
+  }
+
+  clear() {
+    this.items = [];
+  }
+
+  add(item: MigrationItem) {
+    const Migration = item.migration;
+    if (Migration) {
+      const migration = new Migration({ ...this.context, ...item.context });
+      migration.name = item.name;
+      this.items.push(migration);
+    } else {
+      this.items.push(item);
+    }
+  }
+
+  callback() {
+    return async (ctx) => {
+      return this.items;
+    };
+  }
+}

package/src/mock-database.ts

@@ -33,6 +33,7 @@ export function getConfigByEnv() {
       charset: 'utf8mb4',
       collate: 'utf8mb4_unicode_ci',
     },
+    timezone: process.env.DB_TIMEZONE,
   };
 }
 

package/src/model-hook.ts

@@ -5,24 +5,26 @@ import { Model } from './model';
 
 const { hooks } = require('sequelize/lib/hooks');
 
+
+
 export class ModelHook {
   database: Database;
-  boundEvent = new Set<string>();
+
+  boundEvents = new Set<string>();
 
   constructor(database: Database) {
     this.database = database;
   }
 
-  isModelHook(eventName: string | symbol): keyof SequelizeHooks | false {
-    if (lodash.isString(eventName)) {
-      const hookType = eventName.split('.').pop();
-
-      if (hooks[hookType]) {
-        return <keyof SequelizeHooks>hookType;
-      }
+  match(event: string | Symbol): keyof SequelizeHooks | null {
+    // NOTE: skip Symbol event
+    if (!lodash.isString(event)) {
+      return null;
     }
 
-    return false;
+    const type = event.split('.').pop();
+
+    return type in hooks ? <keyof SequelizeHooks>type : null;
   }
 
   findModelName(hookArgs) {
@@ -30,40 +32,42 @@ export class ModelHook {
       if (arg?._previousDataValues) {
         return (<Model>arg).constructor.name;
       }
-
       if (lodash.isPlainObject(arg)) {
         if (arg['model']) {
           return arg['model'].name;
         }
-
-        if (lodash.get(arg, 'name.plural')) {
-          return lodash.get(arg, 'name.plural');
+        const plural = arg?.name?.plural;
+        if (this.database.sequelize.isDefined(plural)) {
+          return plural;
+        }
+        const singular = arg?.name?.singular;
+        if (this.database.sequelize.isDefined(singular)) {
+          return singular;
         }
       }
     }
-
     return null;
   }
 
-  bindEvent(eventName) {
-    this.boundEvent.add(eventName);
+  bindEvent(type) {
+    this.boundEvents.add(type);
   }
 
-  hasBindEvent(eventName) {
-    return this.boundEvent.has(eventName);
+  hasBoundEvent(type): boolean {
+    return this.boundEvents.has(type);
   }
 
-  sequelizeHookBuilder(eventName) {
+  buildSequelizeHook(type) {
     return async (...args: any[]) => {
       const modelName = this.findModelName(args);
 
       if (modelName) {
         // emit model event
-        await this.database.emitAsync(`${modelName}.${eventName}`, ...args);
+        await this.database.emitAsync(`${modelName}.${type}`, ...args);
       }
 
       // emit sequelize global event
-      await this.database.emitAsync(eventName, ...args);
+      await this.database.emitAsync(type, ...args);
     };
   }
 }

package/src/options-parser.ts

@@ -1,4 +1,4 @@
-import { FindAttributeOptions, ModelCtor, Op } from 'sequelize';
+import { FindAttributeOptions, ModelCtor, Op, Sequelize } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
 import FilterParser from './filter-parser';
@@ -70,24 +70,28 @@ export class OptionsParser {
     if (typeof sort === 'string') {
       sort = sort.split(',');
     }
-    const orderParams = sort.map((sortKey: string) => {
-      const direction = sortKey.startsWith('-') ? 'DESC' : 'ASC';
-      const sortField: Array<any> = sortKey.replace('-', '').split('.');
-
+    const orderParams = [];
+    for (const sortKey of sort) {
+      let direction = sortKey.startsWith('-') ? 'DESC' : 'ASC';
+      let sortField: Array<any> = sortKey.replace('-', '').split('.');
+      if (this.database.inDialect('postgres', 'sqlite')) {
+        direction = `${direction} NULLS LAST`;
+      }
       // handle sort by association
       if (sortField.length > 1) {
         let associationModel = this.model;
-
         for (let i = 0; i < sortField.length - 1; i++) {
           const associationKey = sortField[i];
           sortField[i] = associationModel.associations[associationKey].target;
           associationModel = sortField[i];
         }
       }
-
       sortField.push(direction);
-      return sortField;
-    });
+      if (this.database.inDialect('mysql')) {
+        orderParams.push([Sequelize.fn('ISNULL', Sequelize.col(`${this.model.name}.${sortField[0]}`))]);
+      }
+      orderParams.push(sortField);
+    }
 
     if (orderParams.length > 0) {
       return {

package/src/relation-repository/multiple-relation-repository.ts

@@ -165,8 +165,14 @@ export abstract class MultipleRelationRepository extends RelationRepository {
 
     for (const instance of instances) {
       if (options.hooks !== false) {
-        await this.db.emitAsync(`${this.targetCollection.name}.afterUpdateWithAssociations`, instance, {...options, transaction});
-        await this.db.emitAsync(`${this.targetCollection.name}.afterSaveWithAssociations`, instance, {...options, transaction});
+        await this.db.emitAsync(`${this.targetCollection.name}.afterUpdateWithAssociations`, instance, {
+          ...options,
+          transaction,
+        });
+        await this.db.emitAsync(`${this.targetCollection.name}.afterSaveWithAssociations`, instance, {
+          ...options,
+          transaction,
+        });
       }
     }
 

package/src/relation-repository/relation-repository.ts

@@ -48,6 +48,7 @@ export abstract class RelationRepository {
     return (<BelongsTo | HasOne | HasMany | BelongsToMany>this.association).accessors;
   }
 
+  @transaction()
   async create(options?: CreateOptions): Promise<any> {
     const createAccessor = this.accessors().create;
 

package/src/relation-repository/single-relation-repository.ts

@@ -59,7 +59,7 @@ export abstract class SingleRelationRepository extends RelationRepository {
   }
 
   async findOne(options?: SingleRelationFindOption): Promise<Model<any>> {
-    return this.find(options);
+    return this.find({ ...options, filterByTk: null } as any);
   }
 
   @transaction()
@@ -85,6 +85,10 @@ export abstract class SingleRelationRepository extends RelationRepository {
       transaction,
     });
 
+    if (!target) {
+      throw new Error('The record does not exist');
+    }
+
     await updateModelByValues(target, options?.values, {
       ...lodash.omit(options, 'values'),
       transaction,

package/src/repository.ts

@@ -307,8 +307,14 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     });
 
     if (options.hooks !== false) {
-      await this.database.emitAsync(`${this.collection.name}.afterCreateWithAssociations`, instance, options);
-      await this.database.emitAsync(`${this.collection.name}.afterSaveWithAssociations`, instance, options);
+      await this.database.emitAsync(`${this.collection.name}.afterCreateWithAssociations`, instance, {
+        ...options,
+        transaction,
+      });
+      await this.database.emitAsync(`${this.collection.name}.afterSaveWithAssociations`, instance, {
+        ...options,
+        transaction,
+      });
     }
 
     return instance;
@@ -362,8 +368,14 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
 
     if (options.hooks !== false) {
       for (const instance of instances) {
-        await this.database.emitAsync(`${this.collection.name}.afterUpdateWithAssociations`, instance, options);
-        await this.database.emitAsync(`${this.collection.name}.afterSaveWithAssociations`, instance, options);
+        await this.database.emitAsync(`${this.collection.name}.afterUpdateWithAssociations`, instance, {
+          ...options,
+          transaction,
+        });
+        await this.database.emitAsync(`${this.collection.name}.afterSaveWithAssociations`, instance, {
+          ...options,
+          transaction,
+        });
       }
     }
 

package/src/update-associations.ts

@@ -297,7 +297,7 @@ export async function updateSingleAssociation(
       // @ts-ignore
       dataKey = association.targetKey;
     } else {
-      M = association.source as ModelCtor<Model>;
+      M = association.target as ModelCtor<Model>;
       dataKey = M.primaryKeyAttribute;
     }