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

package/src/database.ts

@@ -0,0 +1,340 @@
+import { applyMixins, AsyncEmitter } from '@nocobase/utils';
+import merge from 'deepmerge';
+import { EventEmitter } from 'events';
+import lodash from 'lodash';
+import { ModelCtor, Op, Options, QueryInterfaceDropAllTablesOptions, Sequelize, SyncOptions, Utils } from 'sequelize';
+import { Collection, CollectionOptions, RepositoryType } from './collection';
+import { ImporterReader, ImportFileExtension } from './collection-importer';
+import * as FieldTypes from './fields';
+import { Field, FieldContext, RelationField } from './fields';
+import { Model } from './model';
+import { ModelHook } from './model-hook';
+import extendOperators from './operators';
+import { RelationRepository } from './relation-repository/relation-repository';
+import { Repository } from './repository';
+
+export interface MergeOptions extends merge.Options {}
+
+export interface PendingOptions {
+  field: RelationField;
+  model: ModelCtor<Model>;
+}
+
+interface MapOf<T> {
+  [key: string]: T;
+}
+
+export interface IDatabaseOptions extends Options {
+  tablePrefix?: string;
+}
+
+export type DatabaseOptions = IDatabaseOptions | Sequelize;
+
+interface RegisterOperatorsContext {
+  db?: Database;
+  path?: string;
+  field?: Field;
+  app?: any;
+}
+
+export interface CleanOptions extends QueryInterfaceDropAllTablesOptions {
+  drop?: boolean;
+}
+
+type OperatorFunc = (value: any, ctx?: RegisterOperatorsContext) => any;
+
+export class Database extends EventEmitter implements AsyncEmitter {
+  sequelize: Sequelize;
+  fieldTypes = new Map();
+  options: IDatabaseOptions;
+  models = new Map<string, ModelCtor<Model>>();
+  repositories = new Map<string, RepositoryType>();
+  operators = new Map();
+  collections = new Map<string, Collection>();
+  pendingFields = new Map<string, RelationField[]>();
+  modelCollection = new Map<ModelCtor<any>, Collection>();
+
+  modelHook: ModelHook;
+
+  delayCollectionExtend = new Map<string, { collectionOptions: CollectionOptions; mergeOptions?: any }[]>();
+
+  constructor(options: DatabaseOptions) {
+    super();
+
+    if (options instanceof Sequelize) {
+      this.sequelize = options;
+    } else {
+      this.sequelize = new Sequelize(options);
+      this.options = options;
+    }
+
+    this.collections = new Map();
+    this.modelHook = new ModelHook(this);
+
+    this.on('afterDefineCollection', (collection: Collection) => {
+      // after collection defined, call bind method on pending fields
+      this.pendingFields.get(collection.name)?.forEach((field) => field.bind());
+      this.delayCollectionExtend.get(collection.name)?.forEach((collectionExtend) => {
+        collection.updateOptions(collectionExtend.collectionOptions, collectionExtend.mergeOptions);
+      });
+    });
+
+    // register database field types
+    for (const [name, field] of Object.entries(FieldTypes)) {
+      if (['Field', 'RelationField'].includes(name)) {
+        continue;
+      }
+      let key = name.replace(/Field$/g, '');
+      key = key.substring(0, 1).toLowerCase() + key.substring(1);
+      this.registerFieldTypes({
+        [key]: field,
+      });
+    }
+
+    this.initOperators();
+  }
+
+  /**
+   * Add collection to database
+   * @param options
+   */
+  collection<Attributes = any, CreateAttributes = Attributes>(
+    options: CollectionOptions,
+  ): Collection<Attributes, CreateAttributes> {
+    this.emit('beforeDefineCollection', options);
+
+    const collection = new Collection(options, {
+      database: this,
+    });
+
+    this.collections.set(collection.name, collection);
+    this.modelCollection.set(collection.model, collection);
+
+    this.emit('afterDefineCollection', collection);
+
+    return collection;
+  }
+
+  getTablePrefix() {
+    return this.options.tablePrefix || '';
+  }
+
+  /**
+   * get exists collection by its name
+   * @param name
+   */
+  getCollection(name: string): Collection {
+    return this.collections.get(name);
+  }
+
+  hasCollection(name: string): boolean {
+    return this.collections.has(name);
+  }
+
+  removeCollection(name: string) {
+    const collection = this.collections.get(name);
+    this.emit('beforeRemoveCollection', collection);
+
+    const result = this.collections.delete(name);
+
+    if (result) {
+      this.emit('afterRemoveCollection', collection);
+    }
+  }
+
+  getModel<M extends Model>(name: string) {
+    return this.getCollection(name).model as ModelCtor<M>;
+  }
+
+  getRepository<R extends Repository>(name: string): R;
+  getRepository<R extends RelationRepository>(name: string, relationId: string | number): R;
+
+  getRepository<R extends RelationRepository>(name: string, relationId?: string | number): Repository | R {
+    if (relationId) {
+      const [collection, relation] = name.split('.');
+      return this.getRepository(collection)?.relation(relation)?.of(relationId) as R;
+    }
+
+    return this.getCollection(name)?.repository;
+  }
+
+  addPendingField(field: RelationField) {
+    const associating = this.pendingFields;
+    const items = this.pendingFields.get(field.target) || [];
+    items.push(field);
+    associating.set(field.target, items);
+  }
+
+  removePendingField(field: RelationField) {
+    const items = this.pendingFields.get(field.target) || [];
+    const index = items.indexOf(field);
+    if (index !== -1) {
+      delete items[index];
+      this.pendingFields.set(field.target, items);
+    }
+  }
+
+  registerFieldTypes(fieldTypes: MapOf<typeof Field>) {
+    for (const [type, fieldType] of Object.entries(fieldTypes)) {
+      this.fieldTypes.set(type, fieldType);
+    }
+  }
+
+  registerModels(models: MapOf<ModelCtor<any>>) {
+    for (const [type, schemaType] of Object.entries(models)) {
+      this.models.set(type, schemaType);
+    }
+  }
+
+  registerRepositories(repositories: MapOf<RepositoryType>) {
+    for (const [type, schemaType] of Object.entries(repositories)) {
+      this.repositories.set(type, schemaType);
+    }
+  }
+
+  initOperators() {
+    const operators = new Map();
+
+    // Sequelize 内置
+    for (const key in Op) {
+      operators.set('$' + key, Op[key]);
+      const val = Utils.underscoredIf(key, true);
+      operators.set('$' + val, Op[key]);
+      operators.set('$' + val.replace(/_/g, ''), Op[key]);
+    }
+
+    this.operators = operators;
+
+    this.registerOperators({
+      ...extendOperators,
+    });
+  }
+
+  registerOperators(operators: MapOf<OperatorFunc>) {
+    for (const [key, operator] of Object.entries(operators)) {
+      this.operators.set(key, operator);
+    }
+  }
+
+  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);
+  }
+
+  async sync(options?: SyncOptions) {
+    const isMySQL = this.sequelize.getDialect() === 'mysql';
+    if (isMySQL) {
+      await this.sequelize.query('SET FOREIGN_KEY_CHECKS = 0', null);
+    }
+    const result = await this.sequelize.sync(options);
+    if (isMySQL) {
+      await this.sequelize.query('SET FOREIGN_KEY_CHECKS = 1', null);
+    }
+    return result;
+  }
+
+  async clean(options: CleanOptions) {
+    const { drop, ...others } = options;
+    if (drop) {
+      await this.sequelize.getQueryInterface().dropAllTables(others);
+    }
+  }
+
+  public isSqliteMemory() {
+    return this.sequelize.getDialect() === 'sqlite' && lodash.get(this.options, 'storage') == ':memory:';
+  }
+
+  async reconnect() {
+    if (this.isSqliteMemory()) {
+      return;
+    }
+    // @ts-ignore
+    const ConnectionManager = this.sequelize.dialect.connectionManager.constructor;
+    // @ts-ignore
+    const connectionManager = new ConnectionManager(this.sequelize.dialect, this.sequelize);
+    // @ts-ignore
+    this.sequelize.dialect.connectionManager = connectionManager;
+    // @ts-ignore
+    this.sequelize.connectionManager = connectionManager;
+  }
+
+  closed() {
+    // @ts-ignore
+    return this.sequelize.connectionManager.pool._draining;
+  }
+
+  async close() {
+    if (this.isSqliteMemory()) {
+      return;
+    }
+
+    return this.sequelize.close();
+  }
+
+  on(event: string | symbol, listener: (...args: any[]) => void): this {
+    const modelEventName = this.modelHook.isModelHook(event);
+
+    if (modelEventName && !this.modelHook.hasBindEvent(modelEventName)) {
+      this.sequelize.addHook(modelEventName, this.modelHook.sequelizeHookBuilder(modelEventName));
+
+      this.modelHook.bindEvent(modelEventName);
+    }
+
+    return super.on(event, listener);
+  }
+
+  async import(options: { directory: string; extensions?: ImportFileExtension[] }): Promise<Map<string, Collection>> {
+    const reader = new ImporterReader(options.directory, options.extensions);
+    const modules = await reader.read();
+    const result = new Map<string, Collection>();
+
+    for (const module of modules) {
+      if (module.extend) {
+        const collectionName = module.collectionOptions.name;
+        const existCollection = this.getCollection(collectionName);
+        if (existCollection) {
+          existCollection.updateOptions(module.collectionOptions, module.mergeOptions);
+        } else {
+          const existDelayExtends = this.delayCollectionExtend.get(collectionName) || [];
+
+          this.delayCollectionExtend.set(collectionName, [...existDelayExtends, module]);
+        }
+      } else {
+        const collection = this.collection(module);
+        result.set(collection.name, collection);
+      }
+    }
+
+    return result;
+  }
+
+  emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
+}
+
+export function extend(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions) {
+  return {
+    collectionOptions,
+    mergeOptions,
+    extend: true,
+  };
+}
+
+export const defineCollection = (collectionOptions: CollectionOptions) => {
+  return collectionOptions;
+};
+
+export const extendCollection = (collectionOptions: CollectionOptions, mergeOptions?: MergeOptions) => {
+  return {
+    collectionOptions,
+    mergeOptions,
+    extend: true,
+  };
+};
+
+applyMixins(Database, [AsyncEmitter]);
+
+export default Database;

package/src/fields/array-field.ts

@@ -0,0 +1,35 @@
+import { BaseColumnFieldOptions, Field } from './field';
+import { DataTypes } from 'sequelize';
+
+export class ArrayField extends Field {
+  get dataType() {
+    if (this.database.sequelize.getDialect() === 'postgres') {
+      return DataTypes.JSONB;
+    }
+
+    return DataTypes.JSON;
+  }
+
+  sortValue(model) {
+    const oldValue = model.get(this.options.name);
+
+    if (oldValue) {
+      const newValue = oldValue.sort();
+      model.set(this.options.name, newValue);
+    }
+  }
+
+  bind() {
+    super.bind();
+    this.on('beforeSave', this.sortValue.bind(this));
+  }
+
+  unbind() {
+    super.unbind();
+    this.off('beforeSave', this.sortValue.bind(this));
+  }
+}
+
+export interface ArrayFieldOptions extends BaseColumnFieldOptions {
+  type: 'array';
+}

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

@@ -0,0 +1,76 @@
+import { omit } from 'lodash';
+import { BelongsToOptions as SequelizeBelongsToOptions, Utils } from 'sequelize';
+import { BaseRelationFieldOptions, RelationField } from './relation-field';
+
+export class BelongsToField extends RelationField {
+  static type = 'belongsTo';
+
+  get target() {
+    const { target, name } = this.options;
+    return target || Utils.pluralize(name);
+  }
+
+  bind() {
+    const { database, collection } = this.context;
+    const Target = this.TargetModel;
+
+    // if target model not exists, add it to pending field,
+    // it will bind later
+    if (!Target) {
+      database.addPendingField(this);
+      return false;
+    }
+
+    if (collection.model.associations[this.name]) {
+      delete collection.model.associations[this.name];
+    }
+
+    // define relation on sequelize model
+    const association = collection.model.belongsTo(Target, {
+      as: this.name,
+      ...omit(this.options, ['name', 'type', 'target']),
+    });
+
+    // inverse relation
+    // this.TargetModel.hasMany(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 field1 = collection.getField(foreignKey);
+    const field2 = tcoll.findField((field) => {
+      return field.type === 'hasMany' && field.foreignKey === foreignKey;
+    });
+    if (!field1 && !field2) {
+      collection.model.removeAttribute(foreignKey);
+    }
+    // 删掉 model 的关联字段
+    delete collection.model.associations[this.name];
+    // @ts-ignore
+    collection.model.refreshAttributes();
+  }
+}
+
+export interface BelongsToFieldOptions extends BaseRelationFieldOptions, SequelizeBelongsToOptions {
+  type: 'belongsTo';
+  target?: string;
+}

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

@@ -0,0 +1,77 @@
+import { omit } from 'lodash';
+import { BelongsToManyOptions as SequelizeBelongsToManyOptions, Utils } from 'sequelize';
+import { Collection } from '../collection';
+import { MultipleRelationFieldOptions, RelationField } from './relation-field';
+
+export class BelongsToManyField extends RelationField {
+  get through() {
+    return (
+      this.options.through ||
+      Utils.camelize(
+        [this.context.collection.model.name, this.target]
+          .map((name) => name.toLowerCase())
+          .sort()
+          .join('_'),
+      )
+    );
+  }
+
+  bind() {
+    const { database, collection } = this.context;
+    const Target = this.TargetModel;
+    if (!Target) {
+      database.addPendingField(this);
+      return false;
+    }
+    const through = this.through;
+
+    let Through: Collection;
+
+    if (database.hasCollection(through)) {
+      Through = database.getCollection(through);
+    } else {
+      Through = database.collection({
+        name: through,
+      });
+      Object.defineProperty(Through.model, 'isThrough', { value: true });
+    }
+
+    const association = collection.model.belongsToMany(Target, {
+      ...omit(this.options, ['name', 'type', 'target']),
+      as: this.name,
+      through: Through.model,
+    });
+
+    // 建立关系之后从 pending 列表中删除
+    database.removePendingField(this);
+
+    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;
+    }
+    if (!this.options.through) {
+      this.options.through = this.through;
+    }
+    return true;
+  }
+
+  unbind() {
+    const { database, collection } = this.context;
+    // 如果关系字段还没建立就删除了，也同步删除待建立关联的关系字段
+    database.removePendingField(this);
+    // 删掉 model 的关联字段
+    delete collection.model.associations[this.name];
+  }
+}
+
+export interface BelongsToManyFieldOptions
+  extends MultipleRelationFieldOptions,
+    Omit<SequelizeBelongsToManyOptions, 'through'> {
+  type: 'belongsToMany';
+  through?: string;
+}

package/src/fields/boolean-field.ts

@@ -0,0 +1,12 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class BooleanField extends Field {
+  get dataType() {
+    return DataTypes.BOOLEAN;
+  }
+}
+
+export interface BooleanFieldOptions extends BaseColumnFieldOptions {
+  type: 'boolean';
+}

package/src/fields/context-field.ts

@@ -0,0 +1,45 @@
+import { lodash } from '@umijs/utils';
+import { DataTypes } from 'sequelize';
+import { Model } from '../model';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class ContextField extends Field {
+  get dataType() {
+    const type: string = this.options.dataType || 'string';
+    return DataTypes[type.toUpperCase()] || DataTypes.STRING;
+  }
+
+  init() {
+    const { name, dataIndex } = this.options;
+    this.listener = async (model: Model, options) => {
+      const { context } = options;
+      model.set(name, lodash.get(context, dataIndex));
+      model.changed(name, true);
+    };
+  }
+
+  bind() {
+    super.bind();
+    const { createOnly } = this.options;
+    this.on('beforeCreate', this.listener);
+    if (!createOnly) {
+      this.on('beforeUpdate', this.listener);
+    }
+  }
+
+  unbind() {
+    super.unbind();
+    const { createOnly } = this.options;
+    this.off('beforeCreate', this.listener);
+    if (!createOnly) {
+      this.off('beforeUpdate', this.listener);
+    }
+  }
+}
+
+export interface ContextFieldOptions extends BaseColumnFieldOptions {
+  type: 'context';
+  dataIndex: string;
+  dataType?: string;
+  createOnly?: boolean;
+}

package/src/fields/date-field.ts

@@ -0,0 +1,12 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class DateField extends Field {
+  get dataType() {
+    return DataTypes.DATE;
+  }
+}
+
+export interface DateFieldOptions extends BaseColumnFieldOptions {
+  type: 'date';
+}

package/src/fields/field.ts

@@ -0,0 +1,105 @@
+import _ from 'lodash';
+import { DataType, ModelAttributeColumnOptions, ModelIndexesOptions, SyncOptions } from 'sequelize';
+import { Collection } from '../collection';
+import { Database } from '../database';
+
+export interface FieldContext {
+  database: Database;
+  collection: Collection;
+}
+
+export interface BaseFieldOptions {
+  name?: string;
+  hidden?: boolean;
+  [key: string]: any;
+}
+
+export interface BaseColumnFieldOptions extends BaseFieldOptions, Omit<ModelAttributeColumnOptions, 'type'> {
+  dataType?: DataType;
+  index?: boolean | ModelIndexesOptions;
+}
+
+export abstract class Field {
+  options: any;
+  context: FieldContext;
+  database: Database;
+  collection: Collection;
+  [key: string]: any;
+
+  get name() {
+    return this.options.name;
+  }
+
+  get type() {
+    return this.options.type;
+  }
+
+  get dataType() {
+    return this.options.dataType;
+  }
+
+  constructor(options?: any, context?: FieldContext) {
+    this.context = context;
+    this.database = context.database;
+    this.collection = context.collection;
+    this.options = options || {};
+    this.init();
+  }
+
+  // TODO
+  async sync(syncOptions: SyncOptions) {
+    await this.collection.sync({
+      ...syncOptions,
+      force: false,
+      alter: {
+        drop: false,
+      },
+    });
+  }
+
+  init() {
+    // code
+  }
+
+  on(eventName: string, listener: (...args: any[]) => void) {
+    this.database.on(`${this.collection.name}.${eventName}`, listener);
+    return this;
+  }
+
+  off(eventName: string, listener: (...args: any[]) => void) {
+    this.database.off(`${this.collection.name}.${eventName}`, listener);
+    return this;
+  }
+
+  get(name: string) {
+    return this.options[name];
+  }
+
+  merge(obj: any) {
+    Object.assign(this.options, obj);
+  }
+
+  bind() {
+    const { model } = this.context.collection;
+    model.rawAttributes[this.name] = this.toSequelize();
+    // @ts-ignore
+    model.refreshAttributes();
+  }
+
+  unbind() {
+    const { model } = this.context.collection;
+    model.removeAttribute(this.name);
+  }
+
+  toSequelize(): any {
+    const opts = _.omit(this.options, ['name']);
+    if (this.dataType) {
+      Object.assign(opts, { type: this.dataType });
+    }
+    return opts;
+  }
+
+  isSqlite() {
+    return this.database.sequelize.getDialect() === 'sqlite';
+  }
+}