@nocobase/database 0.5.0-alpha.38 → 0.7.0-alpha.0

package/src/fields/string-field.ts

@@ -0,0 +1,12 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class StringField extends Field {
+  get dataType() {
+    return DataTypes.STRING;
+  }
+}
+
+export interface StringFieldOptions extends BaseColumnFieldOptions {
+  type: 'string';
+}

package/src/fields/text-field.ts

@@ -0,0 +1,12 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class TextField extends Field {
+  get dataType() {
+    return DataTypes.TEXT;
+  }
+}
+
+export interface TextFieldOptions extends BaseColumnFieldOptions {
+  type: 'text';
+}

package/src/fields/time-field.ts

@@ -0,0 +1,12 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class TimeField extends Field {
+  get dataType() {
+    return DataTypes.TIME;
+  }
+}
+
+export interface TimeFieldOptions extends BaseColumnFieldOptions {
+  type: 'time';
+}

package/src/fields/uid-field.ts

@@ -0,0 +1,24 @@
+import { uid } from '@nocobase/utils';
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class UidField extends Field {
+  get dataType() {
+    return DataTypes.STRING;
+  }
+
+  init() {
+    const { name, prefix = '' } = this.options;
+    const { model } = this.context.collection;
+    model.beforeCreate(async (instance) => {
+      if (!instance.get(name)) {
+        instance.set(name, `${prefix}${uid()}`);
+      }
+    });
+  }
+}
+
+export interface UidFieldOptions extends BaseColumnFieldOptions {
+  type: 'uid';
+  prefix?: string;
+}

package/src/fields/virtual-field.ts

@@ -0,0 +1,12 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+
+export class VirtualField extends Field {
+  get dataType() {
+    return DataTypes.VIRTUAL;
+  }
+}
+
+export interface VirtualFieldOptions extends BaseColumnFieldOptions {
+  type: 'virtual';
+}

package/src/filter-parser.ts

@@ -0,0 +1,243 @@
+import { flatten, unflatten } from 'flat';
+import { default as lodash, default as _ } from 'lodash';
+import { ModelCtor } from 'sequelize';
+import { Collection } from './collection';
+import { Database } from './database';
+import { Model } from './model';
+
+const debug = require('debug')('noco-database');
+
+type FilterType = any;
+
+interface FilterParserContext {
+  collection: Collection;
+  app?: any;
+}
+
+export default class FilterParser {
+  collection: Collection;
+  database: Database;
+  model: ModelCtor<Model>;
+  filter: FilterType;
+  context: FilterParserContext;
+
+  constructor(filter: FilterType, context: FilterParserContext) {
+    const { collection } = context;
+    this.collection = collection;
+    this.context = context;
+    this.model = collection.model;
+    this.filter = this.prepareFilter(filter);
+    this.database = collection.context.database;
+  }
+
+  prepareFilter(filter: FilterType) {
+    if (lodash.isPlainObject(filter)) {
+      const renamedKey = {};
+
+      for (const key of Object.keys(filter)) {
+        if (key.endsWith('.$exists') || key.endsWith('.$notExists')) {
+          const keyArr = key.split('.');
+          if (keyArr[keyArr.length - 2] == 'id') {
+            continue;
+          }
+
+          keyArr.splice(keyArr.length - 1, 0, 'id');
+          renamedKey[key] = keyArr.join('.');
+        }
+      }
+
+      for (const [oldKey, newKey] of Object.entries(renamedKey)) {
+        // @ts-ignore
+        filter[newKey] = filter[oldKey];
+        delete filter[oldKey];
+      }
+    }
+
+    return filter;
+  }
+
+  toSequelizeParams() {
+    debug('filter %o', this.filter);
+
+    if (!this.filter) {
+      return {};
+    }
+
+    const filter = this.filter;
+
+    const model = this.model;
+
+    // supported operators
+    const operators = this.database.operators;
+
+    const originalFiler = lodash.cloneDeep(filter || {});
+
+    const flattenedFilter = flatten(filter || {});
+
+    debug('flattened filter %o', flattenedFilter);
+
+    const include = {};
+    const where = {};
+    const filter2 = lodash.cloneDeep(flattenedFilter);
+
+    let skipPrefix = null;
+    const associations = model.associations;
+
+    debug('associations %O', associations);
+
+    for (let [key, value] of Object.entries(flattenedFilter)) {
+      // 处理 filter 条件
+      if (skipPrefix && key.startsWith(skipPrefix)) {
+        continue;
+      }
+
+      debug('handle filter key "%s: "%s"', key, value);
+      let keys = key.split('.');
+
+      // paths ?
+      const paths = [];
+
+      // origins ?
+      const origins = [];
+
+      while (keys.length) {
+        debug('keys: %o, paths: %o, origins: %o', keys, paths, origins);
+
+        // move key from keys to origins
+        const firstKey = keys.shift();
+        origins.push(firstKey);
+
+        debug('origins: %o', origins);
+
+        if (firstKey.startsWith('$')) {
+          if (operators.has(firstKey)) {
+            debug('%s is operator', firstKey);
+            // if firstKey is operator
+            const opKey = operators.get(firstKey);
+            debug('operator key %s, operator: %o', firstKey, opKey);
+
+            // 默认操作符
+            if (typeof opKey === 'symbol') {
+              paths.push(opKey);
+              continue;
+            } else if (typeof opKey === 'function') {
+              skipPrefix = origins.join('.');
+
+              const queryValue = lodash.get(unflatten(originalFiler), skipPrefix);
+
+              value = opKey(queryValue, {
+                app: this.context.app,
+                db: this.database,
+                path: skipPrefix,
+                fieldName: this.getFieldNameFromQueryPath(skipPrefix),
+                model: this.model,
+              });
+              break;
+            }
+          } else {
+            paths.push(firstKey);
+            continue;
+          }
+        }
+
+        // firstKey is number
+        if (!lodash.isNaN(parseInt(firstKey))) {
+          paths.push(firstKey);
+          continue;
+        }
+
+        // firstKey is not association
+        if (!associations[firstKey]) {
+          paths.push(firstKey);
+          continue;
+        }
+
+        const associationKeys = [];
+
+        associationKeys.push(firstKey);
+
+        debug('associationKeys %o', associationKeys);
+
+        // set sequelize include option
+        _.set(include, firstKey, {
+          association: firstKey,
+          attributes: [], // out put empty fields by default
+        });
+
+        // association target model
+        let target = associations[firstKey].target;
+        debug('association target %o', target);
+
+        while (target) {
+          const attr = keys.shift();
+          origins.push(attr);
+          // if it is target model attribute
+          if (target.rawAttributes[attr]) {
+            associationKeys.push(attr);
+            target = null;
+          } else if (target.associations[attr]) {
+            // if it is target model association (nested association filter)
+            associationKeys.push(attr);
+            const assoc = [];
+            associationKeys.forEach((associationKey, index) => {
+              if (index > 0) {
+                assoc.push('include');
+              }
+              assoc.push(associationKey);
+            });
+
+            _.set(include, assoc, {
+              association: attr,
+              attributes: [],
+            });
+            target = target.associations[attr].target;
+          } else {
+            throw new Error(`${attr} neither ${firstKey}'s association nor ${firstKey}'s attribute`);
+          }
+        }
+
+        debug('associationKeys %o', associationKeys);
+
+        if (associationKeys.length > 1) {
+          paths.push(`$${associationKeys.join('.')}$`);
+        } else {
+          paths.push(firstKey);
+        }
+      }
+
+      debug('where %o, paths %o, value, %o', where, paths, value);
+
+      const values = _.get(where, paths);
+
+      if (values && typeof values === 'object' && value && typeof value === 'object') {
+        value = { ...value, ...values };
+      }
+      _.set(where, paths, value);
+    }
+
+    const toInclude = (items) => {
+      return Object.values(items).map((item: any) => {
+        if (item.include) {
+          item.include = toInclude(item.include);
+        }
+        return item;
+      });
+    };
+    debug('where %o, include %o', where, include);
+    return { where, include: toInclude(include) };
+  }
+
+  private getFieldNameFromQueryPath(queryPath: string) {
+    const paths = queryPath.split('.');
+    let fieldName;
+    for (const path of paths) {
+      if (path.startsWith('$') || !lodash.isNaN(parseInt(path))) {
+        continue;
+      }
+
+      fieldName = path;
+    }
+
+    return fieldName;
+  }
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+export { ModelCtor, Op, SyncOptions } from 'sequelize';
+export * from './collection';
+export * from './database';
+export { Database as default } from './database';
+export * from './fields';
+export * from './magic-attribute-model';
+export * from './mock-database';
+export * from './model';
+export * from './relation-repository/belongs-to-many-repository';
+export * from './relation-repository/belongs-to-repository';
+export * from './relation-repository/hasmany-repository';
+export * from './relation-repository/multiple-relation-repository';
+export * from './relation-repository/single-relation-repository';
+export * from './repository';
+export * from './update-associations';
+

package/src/magic-attribute-model.ts

@@ -0,0 +1,62 @@
+import { merge } from '@nocobase/utils';
+import _ from 'lodash';
+import Database from './database';
+import { Model } from './model';
+
+export class MagicAttributeModel extends Model {
+  get magicAttribute() {
+    const db: Database = (<any>this.constructor).database;
+    const collection = db.getCollection(this.constructor.name);
+    return collection.options.magicAttribute || 'options';
+  }
+
+  set(key: any, value?: any, options?: any) {
+    if (typeof key === 'string') {
+      const [column] = key.split('.');
+      if ((this.constructor as any).hasAlias(column)) {
+        return super.set(key, value, options);
+      }
+      if ((this.constructor as any).rawAttributes[column]) {
+        return super.set(key, value, options);
+      }
+      if (_.isPlainObject(value)) {
+        const opts = super.get(this.magicAttribute) || {};
+        return super.set(`${this.magicAttribute}.${key}`, merge(opts?.[key], value), options);
+      }
+      return super.set(`${this.magicAttribute}.${key}`, value, options);
+    } else {
+      if (!key) {
+        return;
+      }
+      Object.keys(key).forEach((k) => {
+        this.set(k, key[k], options);
+      });
+    }
+    return super.set(key, value, options);
+  }
+
+  get(key?: any, value?: any): any {
+    if (typeof key === 'string') {
+      const [column] = key.split('.');
+      if ((this.constructor as any).hasAlias(column)) {
+        return super.get(key, value);
+      }
+      if ((this.constructor as any).rawAttributes[column]) {
+        return super.get(key, value);
+      }
+      const options = super.get(this.magicAttribute, value);
+      return _.get(options, key);
+    }
+    const data = super.get(key, value);
+    return {
+      ..._.omit(data, this.magicAttribute),
+      ...data[this.magicAttribute],
+    };
+  }
+
+  async update(values?: any, options?: any) {
+    // @ts-ignore
+    this._changed = new Set();
+    return super.update(values, options);
+  }
+}

package/src/mock-database.ts

@@ -0,0 +1,42 @@
+import { merge, uid } from '@nocobase/utils';
+import { resolve } from 'path';
+import { Database, IDatabaseOptions } from './database';
+
+export class MockDatabase extends Database {
+  constructor(options: IDatabaseOptions) {
+    super({
+      storage: ':memory:',
+      tablePrefix: `mock_${uid(6)}_`,
+      dialect: 'sqlite',
+      ...options,
+    });
+    this.sequelize.beforeDefine((model, opts) => {
+      opts.tableName = `${this.getTablePrefix()}${opts.tableName || opts.modelName || opts.name.plural}`;
+    });
+  }
+}
+
+export function getConfigByEnv() {
+  return {
+    username: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    database: process.env.DB_DATABASE,
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    dialect: process.env.DB_DIALECT,
+    logging: process.env.DB_LOG_SQL === 'on' ? console.log : false,
+    storage:
+      process.env.DB_STORAGE && process.env.DB_STORAGE !== ':memory:'
+        ? resolve(process.cwd(), process.env.DB_STORAGE)
+        : ':memory:',
+    define: {
+      charset: 'utf8mb4',
+      collate: 'utf8mb4_unicode_ci',
+    },
+  };
+}
+
+export function mockDatabase(options: IDatabaseOptions = {}): MockDatabase {
+  const dbOptions = merge(getConfigByEnv(), options);
+  return new MockDatabase(dbOptions);
+}

package/src/model-hook.ts

@@ -0,0 +1,69 @@
+import lodash from 'lodash';
+import type { SequelizeHooks } from 'sequelize/types/lib/hooks';
+import Database from './database';
+import { Model } from './model';
+
+const { hooks } = require('sequelize/lib/hooks');
+
+export class ModelHook {
+  database: Database;
+  boundEvent = 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;
+      }
+    }
+
+    return false;
+  }
+
+  findModelName(hookArgs) {
+    for (const arg of hookArgs) {
+      if (arg instanceof Model) {
+        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');
+        }
+      }
+    }
+
+    return null;
+  }
+
+  bindEvent(eventName) {
+    this.boundEvent.add(eventName);
+  }
+
+  hasBindEvent(eventName) {
+    return this.boundEvent.has(eventName);
+  }
+
+  sequelizeHookBuilder(eventName) {
+    return async (...args: any[]) => {
+      const modelName = this.findModelName(args);
+
+      if (modelName) {
+        // emit model event
+        await this.database.emitAsync(`${modelName}.${eventName}`, ...args);
+      }
+
+      // emit sequelize global event
+      await this.database.emitAsync(eventName, ...args);
+    };
+  }
+}

package/src/model.ts

@@ -0,0 +1,114 @@
+import { Model as SequelizeModel, ModelCtor } from 'sequelize';
+import { Collection } from './collection';
+import { Database } from './database';
+import lodash from 'lodash';
+import { Field } from './fields';
+
+interface IModel {
+  [key: string]: any;
+}
+
+interface JSONTransformerOptions {
+  model: ModelCtor<any>;
+  collection: Collection;
+  db: Database;
+  key?: string;
+  field?: Field;
+}
+
+export class Model<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes>
+  extends SequelizeModel<TModelAttributes, TCreationAttributes>
+  implements IModel
+{
+  public static database: Database;
+  public static collection: Collection;
+
+  public toJSON<T extends TModelAttributes>(): T {
+    const handleObj = (obj, options: JSONTransformerOptions) => {
+      const handles = [
+        (data) => {
+          if (data instanceof Model) {
+            return data.toJSON();
+          }
+
+          return data;
+        },
+        this.hiddenObjKey,
+      ];
+      return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), obj);
+    };
+
+    const handleArray = (arrayOfObj, options: JSONTransformerOptions) => {
+      const handles = [this.sortAssociations];
+      return handles.reduce((carry, fn) => fn.apply(this, [carry, options]), arrayOfObj || []);
+    };
+
+    const opts = {
+      model: this.constructor as ModelCtor<any>,
+      collection: (this.constructor as any).collection,
+      db: (this.constructor as any).database as Database,
+    };
+
+    const traverseJSON = (data: T, options: JSONTransformerOptions): T => {
+      const { model, db, collection } = options;
+      // handle Object
+      data = handleObj(data, options);
+
+      const result = {};
+      for (const key of Object.keys(data)) {
+        // @ts-ignore
+        if (model.hasAlias(key)) {
+          const association = model.associations[key];
+          const opts = {
+            model: association.target,
+            collection: db.getCollection(association.target.name),
+            db,
+            key,
+            field: collection.getField(key),
+          };
+
+          if (['HasMany', 'BelongsToMany'].includes(association.associationType)) {
+            result[key] = handleArray(data[key], opts).map((item) => traverseJSON(item, opts));
+          } else {
+            result[key] = data[key] ? traverseJSON(data[key], opts) : null;
+          }
+        } else {
+          result[key] = data[key];
+        }
+      }
+
+      return result as T;
+    };
+
+    return traverseJSON(super.toJSON(), opts);
+  }
+
+  private hiddenObjKey(obj, options: JSONTransformerOptions) {
+    const hiddenFields = Array.from(options.collection.fields.values())
+      .filter((field) => field.options.hidden)
+      .map((field) => field.options.name);
+
+    return lodash.omit(obj, hiddenFields);
+  }
+
+  private sortAssociations(data, { field }: JSONTransformerOptions): any {
+    const sortBy = field.options.sortBy;
+    return sortBy ? this.sortArray(data, sortBy) : data;
+  }
+
+  private sortArray(data, sortBy: string | string[]) {
+    if (!lodash.isArray(sortBy)) {
+      sortBy = [sortBy];
+    }
+
+    const orderItems = [];
+    const orderDirections = [];
+
+    sortBy.forEach((sortItem) => {
+      orderDirections.push(sortItem.startsWith('-') ? 'desc' : 'asc');
+      orderItems.push(sortItem.replace('-', ''));
+    });
+
+    return lodash.orderBy(data, orderItems, orderDirections);
+  }
+}