@nocobase/database 0.5.0-alpha.37 → 0.7.0-alpha.1

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

@@ -0,0 +1,5 @@
+import { Field } from './field';
+
+export interface HasInverseField {
+  inverseField: () => Field;
+}

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

@@ -0,0 +1,143 @@
+import { omit } from 'lodash';
+import {
+  AssociationScope,
+  DataType,
+  ForeignKeyOptions,
+  HasManyOptions,
+  HasManyOptions as SequelizeHasManyOptions,
+  Utils,
+} from 'sequelize';
+
+import { BaseRelationFieldOptions, MultipleRelationFieldOptions, RelationField } from './relation-field';
+
+export interface HasManyFieldOptions extends HasManyOptions {
+  /**
+   * The name of the field to use as the key for the association in the source table. Defaults to the primary
+   * key of the source table
+   */
+  sourceKey?: string;
+
+  /**
+   * A string or a data type to represent the identifier in the table
+   */
+  keyType?: DataType;
+
+  scope?: AssociationScope;
+
+  /**
+   * The alias of this model, in singular form. See also the `name` option passed to `sequelize.define`. If
+   * you create multiple associations between the same tables, you should provide an alias to be able to
+   * distinguish between them. If you provide an alias when creating the assocition, you should provide the
+   * same alias when eager loading and when getting associated models. Defaults to the singularized name of
+   * target
+   */
+  as?: string | { singular: string; plural: string };
+
+  /**
+   * The name of the foreign key in the target table or an object representing the type definition for the
+   * foreign column (see `Sequelize.define` for syntax). When using an object, you can add a `name` property
+   * to set the name of the column. Defaults to the name of source + primary key of source
+   */
+  foreignKey?: string | ForeignKeyOptions;
+
+  /**
+   * What happens when delete occurs.
+   *
+   * Cascade if this is a n:m, and set null if it is a 1:m
+   *
+   * @default 'SET NULL' or 'CASCADE'
+   */
+  onDelete?: string;
+
+  /**
+   * What happens when update occurs
+   *
+   * @default 'CASCADE'
+   */
+  onUpdate?: string;
+
+  /**
+   * Should on update and on delete constraints be enabled on the foreign key.
+   */
+  constraints?: boolean;
+  foreignKeyConstraint?: boolean;
+
+  // scope?: AssociationScope;
+
+  /**
+   * If `false` the applicable hooks will not be called.
+   * The default value depends on the context.
+   */
+  hooks?: boolean;
+}
+
+export class HasManyField extends RelationField {
+  get foreignKey() {
+    if (this.options.foreignKey) {
+      return this.options.foreignKey;
+    }
+    const { model } = this.context.collection;
+    return Utils.camelize([model.options.name.singular, this.sourceKey || model.primaryKeyAttribute].join('_'));
+  }
+
+  bind() {
+    const { database, collection } = this.context;
+    const Target = this.TargetModel;
+    if (!Target) {
+      database.addPendingField(this);
+      return false;
+    }
+
+    if (collection.model.associations[this.name]) {
+      delete collection.model.associations[this.name];
+    }
+
+    const association = collection.model.hasMany(Target, {
+      as: this.name,
+      foreignKey: this.foreignKey,
+      ...omit(this.options, ['name', 'type', 'target']),
+    });
+
+    // inverse relation
+    // this.TargetModel.belongsTo(collection.model);
+
+    // 建立关系之后从 pending 列表中删除
+    database.removePendingField(this);
+
+    if (!this.options.foreignKey) {
+      this.options.foreignKey = association.foreignKey;
+    }
+    if (!this.options.sourceKey) {
+      // @ts-ignore
+      this.options.sourceKey = association.sourceKey;
+    }
+    return true;
+  }
+
+  unbind() {
+    const { database, collection } = this.context;
+    // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
+    database.removePendingField(this);
+    // 如果关系表内没有显式的创建外键字段，删除关系时，外键也删除掉
+    const tcoll = database.collections.get(this.target);
+    const foreignKey = this.options.foreignKey;
+    const field = tcoll.findField((field) => {
+      if (field.name === foreignKey) {
+        return true;
+      }
+      return field.type === 'belongsTo' && field.foreignKey === foreignKey;
+    });
+    if (!field) {
+      tcoll.model.removeAttribute(foreignKey);
+    }
+    // 删掉 model 的关联字段
+    delete collection.model.associations[this.name];
+    // @ts-ignore
+    collection.model.refreshAttributes();
+  }
+}
+
+export interface HasManyFieldOptions extends MultipleRelationFieldOptions, SequelizeHasManyOptions {
+  type: 'hasMany';
+  target?: string;
+}

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

@@ -0,0 +1,136 @@
+import { omit } from 'lodash';
+import {
+  AssociationScope,
+  DataType,
+  ForeignKeyOptions,
+  HasOneOptions,
+  HasOneOptions as SequelizeHasOneOptions,
+  Utils
+} from 'sequelize';
+import { BaseRelationFieldOptions, RelationField } from './relation-field';
+
+export interface HasOneFieldOptions extends HasOneOptions {
+  /**
+   * The name of the field to use as the key for the association in the source table. Defaults to the primary
+   * key of the source table
+   */
+  sourceKey?: string;
+
+  /**
+   * A string or a data type to represent the identifier in the table
+   */
+  keyType?: DataType;
+
+  scope?: AssociationScope;
+
+  /**
+   * The alias of this model, in singular form. See also the `name` option passed to `sequelize.define`. If
+   * you create multiple associations between the same tables, you should provide an alias to be able to
+   * distinguish between them. If you provide an alias when creating the assocition, you should provide the
+   * same alias when eager loading and when getting associated models. Defaults to the singularized name of
+   * target
+   */
+  as?: string | { singular: string; plural: string };
+
+  /**
+   * The name of the foreign key in the target table or an object representing the type definition for the
+   * foreign column (see `Sequelize.define` for syntax). When using an object, you can add a `name` property
+   * to set the name of the column. Defaults to the name of source + primary key of source
+   */
+  foreignKey?: string | ForeignKeyOptions;
+
+  /**
+   * What happens when delete occurs.
+   *
+   * Cascade if this is a n:m, and set null if it is a 1:m
+   *
+   * @default 'SET NULL' or 'CASCADE'
+   */
+  onDelete?: string;
+
+  /**
+   * What happens when update occurs
+   *
+   * @default 'CASCADE'
+   */
+  onUpdate?: string;
+
+  /**
+   * Should on update and on delete constraints be enabled on the foreign key.
+   */
+  constraints?: boolean;
+  foreignKeyConstraint?: boolean;
+
+  // scope?: AssociationScope;
+
+  /**
+   * If `false` the applicable hooks will not be called.
+   * The default value depends on the context.
+   */
+  hooks?: boolean;
+}
+
+export class HasOneField extends RelationField {
+  get target() {
+    const { target, name } = this.options;
+    return target || Utils.pluralize(name);
+  }
+
+  get foreignKey() {
+    if (this.options.foreignKey) {
+      return this.options.foreignKey;
+    }
+    const { model } = this.context.collection;
+    return Utils.camelize([model.options.name.singular, model.primaryKeyAttribute].join('_'));
+  }
+
+  bind() {
+    const { database, collection } = this.context;
+    const Target = this.TargetModel;
+    if (!Target) {
+      database.addPendingField(this);
+      return false;
+    }
+    const association = collection.model.hasOne(Target, {
+      as: this.name,
+      foreignKey: this.foreignKey,
+      ...omit(this.options, ['name', 'type', 'target']),
+    });
+    // 建立关系之后从 pending 列表中删除
+    database.removePendingField(this);
+    if (!this.options.foreignKey) {
+      this.options.foreignKey = association.foreignKey;
+    }
+    if (!this.options.sourceKey) {
+      // @ts-ignore
+      this.options.sourceKey = association.sourceKey;
+    }
+    return true;
+  }
+
+  unbind() {
+    const { database, collection } = this.context;
+    // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
+    database.removePendingField(this);
+    // 如果关系表内没有显式的创建外键字段，删除关系时，外键也删除掉
+    const tcoll = database.collections.get(this.target);
+    const foreignKey = this.options.foreignKey;
+    const field = tcoll.findField((field) => {
+      if (field.name === foreignKey) {
+        return true;
+      }
+      return field.type === 'belongsTo' && field.foreignKey === foreignKey;
+    });
+    if (!field) {
+      tcoll.model.removeAttribute(foreignKey);
+    }
+    // 删掉 model 的关联字段
+    delete collection.model.associations[this.name];
+    // @ts-ignore
+    collection.model.refreshAttributes();
+  }
+}
+
+export interface HasOneFieldOptions extends BaseRelationFieldOptions, SequelizeHasOneOptions {
+  type: 'hasOne';
+}

package/src/fields/index.ts

@@ -0,0 +1,72 @@
+import { ArrayFieldOptions } from './array-field';
+import { BelongsToFieldOptions } from './belongs-to-field';
+import { BelongsToManyFieldOptions } from './belongs-to-many-field';
+import { BooleanFieldOptions } from './boolean-field';
+import { ContextFieldOptions } from './context-field';
+import { DateFieldOptions } from './date-field';
+import { BaseFieldOptions } from './field';
+import { HasManyFieldOptions } from './has-many-field';
+import { HasOneFieldOptions } from './has-one-field';
+import { JsonbFieldOptions, JsonFieldOptions } from './json-field';
+import {
+  DecimalFieldOptions,
+  DoubleFieldOptions,
+  FloatFieldOptions,
+  IntegerFieldOptions,
+  RealFieldOptions
+} from './number-field';
+import { PasswordFieldOptions } from './password-field';
+import { RadioFieldOptions } from './radio-field';
+import { SortFieldOptions } from './sort-field';
+import { StringFieldOptions } from './string-field';
+import { TextFieldOptions } from './text-field';
+import { TimeFieldOptions } from './time-field';
+import { UidFieldOptions } from './uid-field';
+import { VirtualFieldOptions } from './virtual-field';
+
+export * from './array-field';
+export * from './belongs-to-field';
+export * from './belongs-to-many-field';
+export * from './boolean-field';
+export * from './context-field';
+export * from './date-field';
+export * from './field';
+export * from './has-many-field';
+export * from './has-one-field';
+export * from './json-field';
+export * from './number-field';
+export * from './password-field';
+export * from './radio-field';
+export * from './relation-field';
+export * from './sort-field';
+export * from './string-field';
+export * from './text-field';
+export * from './time-field';
+export * from './uid-field';
+export * from './virtual-field';
+
+export type FieldOptions =
+  | BaseFieldOptions
+  | StringFieldOptions
+  | IntegerFieldOptions
+  | FloatFieldOptions
+  | DecimalFieldOptions
+  | DoubleFieldOptions
+  | RealFieldOptions
+  | JsonFieldOptions
+  | JsonbFieldOptions
+  | BooleanFieldOptions
+  | RadioFieldOptions
+  | SortFieldOptions
+  | TextFieldOptions
+  | VirtualFieldOptions
+  | ArrayFieldOptions
+  | TimeFieldOptions
+  | DateFieldOptions
+  | UidFieldOptions
+  | PasswordFieldOptions
+  | ContextFieldOptions
+  | BelongsToFieldOptions
+  | HasOneFieldOptions
+  | HasManyFieldOptions
+  | BelongsToManyFieldOptions;

package/src/fields/json-field.ts

@@ -0,0 +1,25 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class JsonField extends Field {
+  get dataType() {
+    return DataTypes.JSON;
+  }
+}
+
+export interface JsonFieldOptions extends BaseColumnFieldOptions {
+  type: 'json';
+}
+
+export class JsonbField extends Field {
+  get dataType() {
+    const dialect = this.context.database.sequelize.getDialect();
+    if (dialect === 'postgres') {
+      return DataTypes.JSONB;
+    }
+    return DataTypes.JSON;
+  }
+}
+export interface JsonbFieldOptions extends BaseColumnFieldOptions {
+  type: 'jsonb';
+}

package/src/fields/number-field.ts

@@ -0,0 +1,52 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class IntegerField extends Field {
+  get dataType() {
+    return DataTypes.INTEGER;
+  }
+}
+
+export interface IntegerFieldOptions extends BaseColumnFieldOptions {
+  type: 'integer';
+}
+
+export class FloatField extends Field {
+  get dataType() {
+    return DataTypes.FLOAT;
+  }
+}
+
+export interface FloatFieldOptions extends BaseColumnFieldOptions {
+  type: 'float';
+}
+
+export class DoubleField extends Field {
+  get dataType() {
+    return DataTypes.DOUBLE;
+  }
+}
+
+export interface DoubleFieldOptions extends BaseColumnFieldOptions {
+  type: 'double';
+}
+
+export class RealField extends Field {
+  get dataType() {
+    return DataTypes.REAL;
+  }
+}
+
+export interface RealFieldOptions extends BaseColumnFieldOptions {
+  type: 'real';
+}
+
+export class DecimalField extends Field {
+  get dataType() {
+    return DataTypes.DECIMAL;
+  }
+}
+
+export interface DecimalFieldOptions extends BaseColumnFieldOptions {
+  type: 'decimal';
+}

package/src/fields/password-field.ts

@@ -0,0 +1,72 @@
+import crypto from 'crypto';
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export interface PasswordFieldOptions extends BaseColumnFieldOptions {
+  type: 'password';
+  /**
+   * @default 64
+   */
+  length?: number;
+  /**
+   * @default 8
+   */
+  randomBytesSize?: number;
+}
+
+export class PasswordField extends Field {
+  get dataType() {
+    return DataTypes.STRING;
+  }
+
+  async verify(password: string, hash: string) {
+    const { length = 64, randomBytesSize = 8 } = this.options;
+    return new Promise((resolve, reject) => {
+      const salt = hash.substring(0, randomBytesSize * 2);
+      const key = hash.substring(randomBytesSize * 2);
+      crypto.scrypt(password, salt, length / 2 - randomBytesSize, (err, derivedKey) => {
+        if (err) reject(err);
+        resolve(key == derivedKey.toString('hex'));
+      });
+    });
+  }
+
+  async hash(password: string) {
+    const { length = 64, randomBytesSize = 8 } = this.options;
+    return new Promise((resolve, reject) => {
+      const salt = crypto.randomBytes(randomBytesSize).toString('hex');
+      crypto.scrypt(password, salt, length / 2 - randomBytesSize, (err, derivedKey) => {
+        if (err) reject(err);
+        resolve(salt + derivedKey.toString('hex'));
+      });
+    });
+  }
+
+  init() {
+    const { name } = this.options;
+    this.listener = async (model) => {
+      if (!model.changed(name as any)) {
+        return;
+      }
+      const value = model.get(name) as string;
+      if (value) {
+        const hash = await this.hash(value);
+        model.set(name, hash);
+      } else {
+        model.set(name, null);
+      }
+    };
+  }
+
+  bind() {
+    super.bind();
+    this.on('beforeCreate', this.listener);
+    this.on('beforeUpdate', this.listener);
+  }
+
+  unbind() {
+    super.unbind();
+    this.off('beforeCreate', this.listener);
+    this.off('beforeUpdate', this.listener);
+  }
+}

package/src/fields/radio-field.ts

@@ -0,0 +1,50 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export interface RadioFieldOptions extends BaseColumnFieldOptions {
+  type: 'radio';
+}
+
+/**
+ * 暂时只支持全局，不支持批量
+ */
+export class RadioField extends Field {
+  get dataType() {
+    return DataTypes.BOOLEAN;
+  }
+
+  init() {
+    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,
+          },
+        );
+      }
+    };
+  }
+
+  bind() {
+    super.bind();
+    this.on('beforeCreate', this.listener.bind(this));
+    this.on('beforeUpdate', this.listener.bind(this));
+  }
+
+  unbind() {
+    super.unbind();
+    this.off('beforeCreate', this.listener.bind(this));
+    this.off('beforeUpdate', this.listener.bind(this));
+  }
+}

package/src/fields/relation-field.ts

@@ -0,0 +1,37 @@
+import { BaseFieldOptions, Field } from './field';
+
+export interface BaseRelationFieldOptions extends BaseFieldOptions {}
+
+export interface MultipleRelationFieldOptions extends BaseRelationFieldOptions {
+  sortBy?: string | string[];
+}
+
+export abstract class RelationField extends Field {
+  /**
+   * target relation name
+   */
+  get target() {
+    const { target, name } = this.options;
+    return target || name;
+  }
+
+  get foreignKey() {
+    return this.options.foreignKey;
+  }
+
+  get sourceKey() {
+    return this.options.sourceKey || this.collection.model.primaryKeyAttribute;
+  }
+
+  get targetKey() {
+    return this.options.targetKey || this.TargetModel.primaryKeyAttribute;
+  }
+
+  /**
+   * get target model from database by it's name
+   * @constructor
+   */
+  get TargetModel() {
+    return this.context.database.sequelize.models[this.target];
+  }
+}

package/src/fields/sort-field.ts

@@ -0,0 +1,96 @@
+import { Mutex } from 'async-mutex';
+import { isNumber } from 'lodash';
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+const sortFieldMutex = new Mutex();
+
+export class SortField extends Field {
+  get dataType() {
+    return DataTypes.INTEGER;
+  }
+
+  async setSortValue(instance, options) {
+    const { name, scopeKey } = this.options;
+    const { model } = this.context.collection;
+
+    if (isNumber(instance.get(name)) && instance._previousDataValues[scopeKey] == instance[scopeKey]) {
+      return;
+    }
+
+    const where = {};
+
+    if (scopeKey) {
+      const value = instance.get(scopeKey);
+      if (value !== undefined && value !== null) {
+        where[scopeKey] = value;
+      }
+    }
+
+    await sortFieldMutex.runExclusive(async () => {
+      const max = await model.max<number, any>(name, { ...options, where });
+      const newValue = (max || 0) + 1;
+      instance.set(name, newValue);
+    });
+  }
+
+  async onScopeChange(instance, options) {
+    const { scopeKey } = this.options;
+    if (scopeKey && !instance.isNewRecord && instance._previousDataValues[scopeKey] != instance[scopeKey]) {
+      await this.setSortValue(instance, options);
+    }
+  }
+
+  async initRecordsSortValue({ transaction }) {
+    const totalCount = await this.collection.repository.count({
+      transaction,
+    });
+    const emptyCount = await this.collection.repository.count({
+      filter: {
+        [this.name]: null,
+      },
+      transaction,
+    });
+
+    if (emptyCount === totalCount && emptyCount > 0) {
+      const records = await this.collection.repository.find({
+        order: [this.collection.model.primaryKeyAttribute],
+        transaction,
+      });
+
+      let start = 1;
+      for (const record of records) {
+        await record.update(
+          {
+            sort: start,
+          },
+          {
+            transaction,
+            silent: true,
+          },
+        );
+
+        start += 1;
+      }
+    }
+  }
+
+  bind() {
+    super.bind();
+    this.on('afterSync', this.initRecordsSortValue.bind(this));
+    this.on('beforeUpdate', this.onScopeChange.bind(this));
+    this.on('beforeCreate', this.setSortValue.bind(this));
+  }
+
+  unbind() {
+    super.unbind();
+    this.off('beforeUpdate', this.onScopeChange.bind(this));
+    this.off('beforeCreate', this.setSortValue.bind(this));
+    this.off('afterSync', this.initRecordsSortValue.bind(this));
+  }
+}
+
+export interface SortFieldOptions extends BaseColumnFieldOptions {
+  type: 'sort';
+  scopeKey?: string;
+}