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

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

@@ -8,6 +8,7 @@ import {
   Utils
 } from 'sequelize';
 import { Collection } from '../collection';
+import { checkIdentifier } from '../utils';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
 
 export interface HasOneFieldOptions extends HasOneOptions {
@@ -92,21 +93,33 @@ export class HasOneField extends RelationField {
       database.addPendingField(this);
       return false;
     }
+
     const association = collection.model.hasOne(Target, {
       constraints: false,
       ...omit(this.options, ['name', 'type', 'target']),
       as: this.name,
       foreignKey: this.foreignKey,
     });
+
     // 建立关系之后从 pending 列表中删除
     database.removePendingField(this);
+
     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;
     }
+
     let tcoll: Collection;
     if (this.target === collection.name) {
       tcoll = collection;

package/src/fields/index.ts

@@ -24,7 +24,8 @@ 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'
+import { FormulaFieldOptions } from './formula-field';
+import { SequenceFieldOptions } from './sequence-field';
 
 export * from './array-field';
 export * from './belongs-to-field';
@@ -48,6 +49,7 @@ export * from './uid-field';
 export * from './uuid-field';
 export * from './virtual-field';
 export * from './formula-field';
+export { SequenceField } from './sequence-field';
 
 export type FieldOptions =
   | BaseFieldOptions
@@ -75,4 +77,5 @@ export type FieldOptions =
   | BelongsToFieldOptions
   | HasOneFieldOptions
   | HasManyFieldOptions
-  | BelongsToManyFieldOptions;
+  | BelongsToManyFieldOptions
+  | SequenceFieldOptions;

package/src/fields/number-field.ts

@@ -11,6 +11,16 @@ export interface IntegerFieldOptions extends BaseColumnFieldOptions {
   type: 'integer';
 }
 
+export class BigIntField extends Field {
+  get dataType() {
+    return DataTypes.BIGINT;
+  }
+}
+
+export interface BigIntFieldOptions extends BaseColumnFieldOptions {
+  type: 'bigInt';
+}
+
 export class FloatField extends Field {
   get dataType() {
     return DataTypes.FLOAT;

package/src/fields/radio-field.ts

@@ -13,38 +13,36 @@ export class RadioField extends Field {
     return DataTypes.BOOLEAN;
   }
 
-  init() {
+  listener = async (model, { transaction }) => {
     const { name } = this.options;
-    this.listener = async (model, { transaction }) => {
-      if (!model.changed(name as any)) {
-        return;
-      }
-      const value = model.get(name) as boolean;
-      if (value) {
-        const M = this.collection.model;
-        await M.update(
-          { [name]: false },
-          {
-            where: {
-              [name]: true,
-            },
-            transaction,
-            hooks: false,
+    if (!model.changed(name as any)) {
+      return;
+    }
+    const value = model.get(name) as boolean;
+    if (value) {
+      const M = this.collection.model;
+      await M.update(
+        { [name]: false },
+        {
+          where: {
+            [name]: true,
           },
-        );
-      }
-    };
-  }
+          transaction,
+          hooks: false,
+        },
+      );
+    }
+  };
 
   bind() {
     super.bind();
-    this.on('beforeCreate', this.listener.bind(this));
-    this.on('beforeUpdate', this.listener.bind(this));
+    this.on('beforeCreate', this.listener);
+    this.on('beforeUpdate', this.listener);
   }
 
   unbind() {
     super.unbind();
-    this.off('beforeCreate', this.listener.bind(this));
-    this.off('beforeUpdate', this.listener.bind(this));
+    this.off('beforeCreate', this.listener);
+    this.off('beforeUpdate', this.listener);
   }
 }

package/src/fields/sequence-field.ts

@@ -0,0 +1,200 @@
+import { DataTypes, Transactionable } from 'sequelize';
+import parser from 'cron-parser';
+import moment from 'moment';
+import { escapeRegExp } from 'lodash';
+
+import { Registry } from '@nocobase/utils';
+
+import { Model } from '..';
+import { BaseColumnFieldOptions, Field, FieldContext } from './field';
+
+interface Pattern {
+  validate?(options): string | null;
+  generate(this: SequenceField, instance: Model, index: number): string;
+  getLength(options): number;
+  getMatcher(options): string;
+}
+
+export const sequencePatterns = new Registry<Pattern>();
+
+sequencePatterns.register('string', {
+  validate(options) {
+    if (!options?.value) {
+      return 'options.value should be configured as a non-empty string';
+    }
+    return null;
+  },
+  generate(instance, index) {
+    const { options } = this.options.patterns[index];
+    return options.value;
+  },
+  getLength(options) {
+    return options.value.length;
+  },
+  getMatcher(options) {
+    return escapeRegExp(options.value);
+  }
+});
+
+sequencePatterns.register('integer', {
+  generate(instance: Model, index) {
+    const { options = {} } = this.options.patterns[index];
+    const { digits = 1, start = 0, base = 10, cycle } = options;
+    const max = Math.pow(base, digits) - 1;
+    const { lastRecord = null } = this.options;
+
+    if (typeof options.current === 'undefined') {
+      if (lastRecord) {
+        // if match current pattern
+        const matcher = this.match(lastRecord.get(this.options.name));
+        if (matcher) {
+          const lastNumber = Number.parseInt(matcher[index + 1], base);
+          options.current = Number.isNaN(lastNumber) ? start : lastNumber + 1;
+        } else {
+          options.current = start;
+        }
+      } else {
+        options.current = start;
+      }
+    } else {
+      options.current += 1;
+    }
+
+    // cycle as cron string
+    if (cycle && lastRecord) {
+      const interval = parser.parseExpression(cycle, { currentDate: <Date>lastRecord.get('createdAt') });
+      const next = interval.next();
+      if ((<Date>instance.get('createdAt')).getTime() >= next.getTime()) {
+        options.current = start;
+      }
+    }
+
+    if (options.current > max) {
+      options.current = start;
+    }
+
+    // update options
+    Object.assign(this.options.patterns[index], { options });
+
+    return options.current.toString(base).padStart(digits, '0');
+  },
+
+  getLength({ digits = 1 } = {}) {
+    return digits;
+  },
+
+  getMatcher(options = {}) {
+    const { digits = 1, start = 0, base = 10 } = options;
+    const startLen = start ? start.toString(base).length : 1;
+    const chars = '0123456789abcdefghijklmnopqrstuvwxyz'.slice(0, base);
+    return `[${chars}]{${digits}}`;
+  }
+});
+
+sequencePatterns.register('date', {
+  generate(instance, index) {
+    const { options } = this.options.patterns[index];
+    return moment(instance.get(options?.field ?? 'createdAt')).format(options?.format ?? 'YYYYMMDD');
+  },
+  getLength(options) {
+    return options.format?.length ?? 8;
+  },
+  getMatcher(options = {}) {
+    return `.{${options?.format?.length ?? 8}}`;
+  }
+});
+
+interface PatternConfig {
+  type: string;
+  title?: string;
+  options?: any;
+}
+export interface SequenceFieldOptions extends BaseColumnFieldOptions {
+  type: 'sequence';
+  patterns: PatternConfig[]
+}
+
+export class SequenceField extends Field {
+  get dataType() {
+    return DataTypes.STRING;
+  }
+
+  constructor(options: SequenceFieldOptions, context: FieldContext) {
+    super(options, context);
+    if (!options.patterns || !options.patterns.length) {
+      throw new Error('at least one pattern should be defined for sequence type');
+    }
+    options.patterns.forEach(pattern => {
+      const P = sequencePatterns.get(pattern.type);
+      if (!P) {
+        throw new Error(`pattern type ${pattern.type} is not registered`);
+      }
+      if (P.validate) {
+        const error = P.validate(pattern.options);
+        if (error) {
+          throw new Error(error);
+        }
+      }
+    });
+
+    const patterns = options.patterns
+      .map(({ type, options }) => sequencePatterns.get(type).getMatcher(options));
+    this.matcher = new RegExp(`^${patterns.map(p => `(${p})`).join('')}$`, 'i');
+  }
+
+  setValue = async (instance: Model, options) => {
+    const { name, patterns } = this.options;
+    // NOTE: only load when value is not set, if null stand for no last record
+    if (typeof this.options.lastRecord === 'undefined') {
+      const model = <typeof Model>instance.constructor;
+      this.options.lastRecord = await model.findOne({
+        attributes: [model.primaryKeyAttribute, this.options.name, 'createdAt'],
+        order: [
+          ['createdAt', 'DESC'],
+          // TODO(bug): will cause problem if no auto-increment id
+          [model.primaryKeyAttribute, 'DESC']
+        ],
+        transaction: options.transaction
+      });
+    }
+
+    const results = patterns.reduce((result, p, i) => {
+      const item = sequencePatterns.get(p.type).generate.call(this, instance, i, options);
+      return result.concat(item);
+    }, []);
+    instance.set(name, results.join(''));
+  };
+
+  setLast = (instance: Model, options) => {
+    this.options.lastRecord = instance;
+  };
+
+  match(value) {
+    return value.match(this.matcher);
+  }
+
+  parse(value: string, patternIndex: number): string {
+    for (let i = 0, index = 0; i < this.options.patterns.length; i += 1) {
+      const { type, options } = this.options.patterns[i];
+      const { getLength } = sequencePatterns.get(type);
+      const length = getLength(options);
+      if (i === patternIndex) {
+        return value.substring(index, index + length);
+      }
+      index += length;
+    }
+    return '';
+  }
+
+  bind() {
+    super.bind();
+    this.on('beforeCreate', this.setValue);
+    this.on('afterCreate', this.setLast);
+  }
+
+  unbind() {
+    super.unbind();
+    this.off('beforeCreate', this.setValue);
+    this.off('afterCreate', this.setLast);
+  }
+}

package/src/fields/sort-field.ts

@@ -10,7 +10,7 @@ export class SortField extends Field {
     return DataTypes.INTEGER;
   }
 
-  async setSortValue(instance, options) {
+  setSortValue = async (instance, options) => {
     const { name, scopeKey } = this.options;
     const { model } = this.context.collection;
 
@@ -34,14 +34,14 @@ export class SortField extends Field {
     });
   }
 
-  async onScopeChange(instance, options) {
+  onScopeChange = async (instance, options) => {
     const { scopeKey } = this.options;
     if (scopeKey && !instance.isNewRecord && instance._previousDataValues[scopeKey] != instance[scopeKey]) {
       await this.setSortValue(instance, options);
     }
   }
 
-  async initRecordsSortValue({ transaction }) {
+  initRecordsSortValue = async ({ transaction }) => {
     const totalCount = await this.collection.repository.count({
       transaction,
     });
@@ -77,16 +77,16 @@ export class SortField extends Field {
 
   bind() {
     super.bind();
-    this.on('afterSync', this.initRecordsSortValue.bind(this));
-    this.on('beforeUpdate', this.onScopeChange.bind(this));
-    this.on('beforeCreate', this.setSortValue.bind(this));
+    this.on('afterSync', this.initRecordsSortValue);
+    this.on('beforeUpdate', this.onScopeChange);
+    this.on('beforeCreate', this.setSortValue);
   }
 
   unbind() {
     super.unbind();
-    this.off('beforeUpdate', this.onScopeChange.bind(this));
-    this.off('beforeCreate', this.setSortValue.bind(this));
-    this.off('afterSync', this.initRecordsSortValue.bind(this));
+    this.off('beforeUpdate', this.onScopeChange);
+    this.off('beforeCreate', this.setSortValue);
+    this.off('afterSync', this.initRecordsSortValue);
   }
 }
 

package/src/filter-parser.ts

@@ -124,12 +124,13 @@ export default class FilterParser {
               skipPrefix = origins.join('.');
 
               const queryValue = lodash.get(unflatten(originalFiler), skipPrefix);
-
+              const [fieldName, fullName] = this.getFieldNameFromQueryPath(skipPrefix);
               value = opKey(queryValue, {
                 app: this.context.app,
                 db: this.database,
                 path: skipPrefix,
-                fieldName: this.getFieldNameFromQueryPath(skipPrefix),
+                fullName,
+                fieldName,
                 model: this.model,
               });
               break;
@@ -230,14 +231,14 @@ export default class FilterParser {
   private getFieldNameFromQueryPath(queryPath: string) {
     const paths = queryPath.split('.');
     let fieldName;
+    let fullPaths = [];
     for (const path of paths) {
       if (path.startsWith('$') || !lodash.isNaN(parseInt(path))) {
         continue;
       }
-
+      fullPaths.push(path);
       fieldName = path;
     }
-
-    return fieldName;
+    return [fieldName, fullPaths.join('.')];
   }
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-export { ModelCtor, Op, SyncOptions } from 'sequelize';
+export { DataTypes, ModelCtor, Op, SyncOptions } from 'sequelize';
 export * from './collection';
 export * from './database';
 export { Database as default } from './database';

package/src/magic-attribute-model.ts

@@ -1,7 +1,9 @@
 import { merge } from '@nocobase/utils';
 import _ from 'lodash';
+import { Utils } from 'sequelize';
 import Database from './database';
 import { Model } from './model';
+const Dottie = require('dottie');
 
 export class MagicAttributeModel extends Model {
   get magicAttribute() {
@@ -14,25 +16,205 @@ export class MagicAttributeModel extends Model {
     if (typeof key === 'string') {
       const [column] = key.split('.');
       if ((this.constructor as any).hasAlias(column)) {
-        return super.set(key, value, options);
+        return this.setV1(key, value, options);
       }
       if ((this.constructor as any).rawAttributes[column]) {
-        return super.set(key, value, options);
+        return this.setV1(key, value, options);
       }
       if (_.isPlainObject(value)) {
         const opts = super.get(this.magicAttribute) || {};
-        return super.set(`${this.magicAttribute}.${key}`, merge(opts?.[key], value), options);
+        return this.setV1(`${this.magicAttribute}.${key}`, merge(opts?.[key], value), options);
       }
-      return super.set(`${this.magicAttribute}.${key}`, value, options);
+      return this.setV1(`${this.magicAttribute}.${key}`, value, options);
     } else {
       if (!key) {
         return;
       }
       Object.keys(key).forEach((k) => {
-        this.set(k, key[k], options);
+        this.setV1(k, key[k], options);
       });
     }
-    return super.set(key, value, options);
+    return this.setV1(key, value, options);
+  }
+
+  setV1(key?: any, value?: any, options?: any) {
+    let values;
+    let originalValue;
+
+    if (typeof key === 'object' && key !== null) {
+      values = key;
+      options = value || {};
+
+      if (options.reset) {
+        // @ts-ignore
+        this.dataValues = {};
+        for (const key in values) {
+          this.changed<any>(key, false);
+        }
+      }
+
+      // If raw, and we're not dealing with includes or special attributes, just set it straight on the dataValues object
+      // @ts-ignore
+      if (
+        options.raw &&
+        // @ts-ignore
+        !(this._options && this._options.include) &&
+        !(options && options.attributes) &&
+        // @ts-ignore
+        !this.constructor._hasDateAttributes &&
+        // @ts-ignore
+        !this.constructor._hasBooleanAttributes
+      ) {
+        // @ts-ignore
+        if (Object.keys(this.dataValues).length) {
+          // @ts-ignore
+          Object.assign(this.dataValues, values);
+        } else {
+          // @ts-ignore
+          this.dataValues = values;
+        }
+        // If raw, .changed() shouldn't be true
+        // @ts-ignore
+        this._previousDataValues = { ...this.dataValues };
+      } else {
+        // Loop and call set
+        if (options.attributes) {
+          const setKeys = (data) => {
+            for (const k of data) {
+              if (values[k] === undefined) {
+                continue;
+              }
+              this.set(k, values[k], options);
+            }
+          };
+          setKeys(options.attributes);
+          // @ts-ignore
+          if (this.constructor._hasVirtualAttributes) {
+            // @ts-ignore
+            setKeys(this.constructor._virtualAttributes);
+          }
+          // @ts-ignore
+          if (this._options.includeNames) {
+            // @ts-ignore
+            setKeys(this._options.includeNames);
+          }
+        } else {
+          for (const key in values) {
+            this.set(key, values[key], options);
+          }
+        }
+
+        if (options.raw) {
+          // If raw, .changed() shouldn't be true
+          // @ts-ignore
+          this._previousDataValues = { ...this.dataValues };
+        }
+      }
+      return this;
+    }
+    if (!options) options = {};
+    if (!options.raw) {
+      // @ts-ignore
+      originalValue = this.dataValues[key];
+    }
+
+    // If not raw, and there's a custom setter
+    // @ts-ignore
+    if (!options.raw && this._customSetters[key]) {
+      // @ts-ignore
+      this._customSetters[key].call(this, value, key);
+      // custom setter should have changed value, get that changed value
+      // TODO: v5 make setters return new value instead of changing internal store
+      // @ts-ignore
+      const newValue = this.dataValues[key];
+      if (!_.isEqual(newValue, originalValue)) {
+        // @ts-ignore
+        this._previousDataValues[key] = originalValue;
+        this.changed(key, true);
+      }
+    } else {
+      // Check if we have included models, and if this key matches the include model names/aliases
+      // @ts-ignore
+      if (this._options && this._options.include && this._options.includeNames.includes(key)) {
+        // Pass it on to the include handler
+        // @ts-ignore
+        this._setInclude(key, value, options);
+        return this;
+      }
+      // Bunch of stuff we won't do when it's raw
+      if (!options.raw) {
+        // If attribute is not in model definition, return
+        // @ts-ignore
+        if (!this._isAttribute(key)) {
+          // @ts-ignore
+          if (key.includes('.') && this.constructor._jsonAttributes.has(key.split('.')[0])) {
+            // @ts-ignore
+            const previousNestedValue = Dottie.get(this.dataValues, key);
+            if (!_.isEqual(previousNestedValue, value)) {
+              // @ts-ignore
+              this._previousDataValues = _.cloneDeep(this._previousDataValues);
+              // @ts-ignore
+              Dottie.set(this.dataValues, key, value);
+              this.changed(key.split('.')[0], true);
+            }
+          }
+          return this;
+        }
+
+        // If attempting to set primary key and primary key is already defined, return
+        // @ts-ignore
+        if (this.constructor._hasPrimaryKeys && originalValue && this.constructor._isPrimaryKey(key)) {
+          return this;
+        }
+
+        // If attempting to set read only attributes, return
+        // @ts-ignore
+        if (
+          !this.isNewRecord &&
+          // @ts-ignore
+          this.constructor._hasReadOnlyAttributes &&
+          // @ts-ignore
+          this.constructor._readOnlyAttributes.has(key)
+        ) {
+          return this;
+        }
+      }
+
+      // If there's a data type sanitizer
+      if (
+        !(value instanceof Utils.SequelizeMethod) &&
+        // @ts-ignore
+        Object.prototype.hasOwnProperty.call(this.constructor._dataTypeSanitizers, key)
+      ) {
+        // @ts-ignore
+        value = this.constructor._dataTypeSanitizers[key].call(this, value, options);
+      }
+
+      // Set when the value has changed and not raw
+      if (
+        !options.raw &&
+        // True when sequelize method
+        (value instanceof Utils.SequelizeMethod ||
+          // Check for data type type comparators
+          // @ts-ignore
+          (!(value instanceof Utils.SequelizeMethod) &&
+            // @ts-ignore
+            this.constructor._dataTypeChanges[key] &&
+            // @ts-ignore
+            this.constructor._dataTypeChanges[key].call(this, value, originalValue, options)) || // Check default
+          // @ts-ignore
+          (!this.constructor._dataTypeChanges[key] && !_.isEqual(value, originalValue)))
+      ) {
+        // @ts-ignore
+        this._previousDataValues[key] = originalValue;
+        this.changed(key, true);
+      }
+
+      // set data value
+      // @ts-ignore
+      this.dataValues[key] = value;
+    }
+    return this;
   }
 
   get(key?: any, value?: any): any {

package/src/mock-database.ts

@@ -20,7 +20,7 @@ export function getConfigByEnv() {
     database: process.env.DB_DATABASE,
     host: process.env.DB_HOST,
     port: process.env.DB_PORT,
-    dialect: process.env.DB_DIALECT,
+    dialect: process.env.DB_DIALECT || 'sqlite',
     logging: process.env.DB_LOGGING === 'on' ? console.log : false,
     storage:
       process.env.DB_STORAGE && process.env.DB_STORAGE !== ':memory:'