@nocobase/database 0.8.0-alpha.9 → 0.8.1-alpha.4

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

@@ -8,9 +8,9 @@ import {
   Utils,
 } from 'sequelize';
 import { Collection } from '../collection';
+import { Reference } from '../features/ReferencesMap';
 import { checkIdentifier } from '../utils';
 import { MultipleRelationFieldOptions, RelationField } from './relation-field';
-import { Reference } from '../features/ReferencesMap';
 
 export interface HasManyFieldOptions extends HasManyOptions {
   /**
@@ -74,6 +74,10 @@ export interface HasManyFieldOptions extends HasManyOptions {
 }
 
 export class HasManyField extends RelationField {
+  get dataType(): any {
+    return 'HasMany';
+  }
+
   get foreignKey() {
     if (this.options.foreignKey) {
       return this.options.foreignKey;
@@ -155,15 +159,18 @@ export class HasManyField extends RelationField {
     database.removePendingField(this);
     // 如果关系表内没有显式的创建外键字段，删除关系时，外键也删除掉
     const tcoll = database.getCollection(this.target);
-    const foreignKey = this.options.foreignKey;
-    const field = tcoll.findField((field) => {
-      if (field.name === foreignKey) {
-        return true;
+
+    if (tcoll) {
+      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);
       }
-      return field.type === 'belongsTo' && field.foreignKey === foreignKey;
-    });
-    if (!field) {
-      tcoll.model.removeAttribute(foreignKey);
     }
 
     const association = collection.model.associations[this.name];
@@ -172,6 +179,7 @@ export class HasManyField extends RelationField {
       this.database.referenceMap.removeReference(this.reference(association));
     }
 
+    this.clearAccessors();
     // 删掉 model 的关联字段
     delete collection.model.associations[this.name];
     // @ts-ignore

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

@@ -74,6 +74,10 @@ export interface HasOneFieldOptions extends HasOneOptions {
 }
 
 export class HasOneField extends RelationField {
+  get dataType(): any {
+    return 'HasOne';
+  }
+
   get target() {
     const { target, name } = this.options;
     return target || Utils.pluralize(name);
@@ -154,20 +158,30 @@ export class HasOneField extends RelationField {
     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;
+
+    if (tcoll && !this.options.inherit) {
+      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);
       }
-      return field.type === 'belongsTo' && field.foreignKey === foreignKey;
-    });
-    if (!field) {
-      tcoll.model.removeAttribute(foreignKey);
     }
 
     const association = collection.model.associations[this.name];
-    this.database.referenceMap.removeReference(this.reference(association));
 
+    if (association) {
+      this.database.referenceMap.removeReference(this.reference(association));
+    }
+
+    this.clearAccessors();
     // 删掉 model 的关联字段
     delete collection.model.associations[this.name];
     // @ts-ignore

package/src/fields/index.ts

@@ -13,7 +13,7 @@ import {
   DoubleFieldOptions,
   FloatFieldOptions,
   IntegerFieldOptions,
-  RealFieldOptions
+  RealFieldOptions,
 } from './number-field';
 import { PasswordFieldOptions } from './password-field';
 import { RadioFieldOptions } from './radio-field';
@@ -25,9 +25,10 @@ import { UidFieldOptions } from './uid-field';
 import { UUIDFieldOptions } from './uuid-field';
 import { VirtualFieldOptions } from './virtual-field';
 import { FormulaFieldOptions } from './formula-field';
-import { SequenceFieldOptions } from './sequence-field';
+import { SetFieldOptions } from './set-field';
 
 export * from './array-field';
+export * from './set-field';
 export * from './belongs-to-field';
 export * from './belongs-to-many-field';
 export * from './boolean-field';
@@ -49,7 +50,6 @@ 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
@@ -68,6 +68,7 @@ export type FieldOptions =
   | VirtualFieldOptions
   | FormulaFieldOptions
   | ArrayFieldOptions
+  | SetFieldOptions
   | TimeFieldOptions
   | DateFieldOptions
   | UidFieldOptions
@@ -77,5 +78,4 @@ export type FieldOptions =
   | BelongsToFieldOptions
   | HasOneFieldOptions
   | HasManyFieldOptions
-  | BelongsToManyFieldOptions
-  | SequenceFieldOptions;
+  | BelongsToManyFieldOptions;

package/src/fields/relation-field.ts

@@ -34,4 +34,20 @@ export abstract class RelationField extends Field {
   get TargetModel() {
     return this.context.database.sequelize.models[this.target];
   }
+
+  protected clearAccessors() {
+    const { collection } = this.context;
+    const association = collection.model.associations[this.name];
+    if (!association) {
+      return;
+    }
+
+    // @ts-ignore
+    const accessors = Object.values(association.accessors);
+
+    accessors.forEach((accessor) => {
+      // @ts-ignore
+      delete collection.model.prototype[accessor];
+    });
+  }
 }

package/src/fields/set-field.ts

@@ -0,0 +1,25 @@
+import { ArrayField } from './array-field';
+import { BaseColumnFieldOptions } from './field';
+
+export interface SetFieldOptions extends BaseColumnFieldOptions {
+  type: 'set';
+}
+
+export class SetField extends ArrayField {
+  beforeSave = (model) => {
+    const oldValue = model.get(this.options.name);
+    if (oldValue) {
+      model.set(this.options.name, [...new Set(oldValue)]);
+    }
+  };
+
+  bind() {
+    super.bind();
+    this.on('beforeSave', this.beforeSave);
+  }
+
+  unbind() {
+    super.unbind();
+    this.off('beforeSave', this.beforeSave);
+  }
+}

package/src/fields/sort-field.ts

@@ -7,7 +7,7 @@ const sortFieldMutex = new Mutex();
 
 export class SortField extends Field {
   get dataType() {
-    return DataTypes.INTEGER;
+    return DataTypes.BIGINT;
   }
 
   setSortValue = async (instance, options) => {
@@ -32,19 +32,20 @@ export class SortField extends Field {
       const newValue = (max || 0) + 1;
       instance.set(name, newValue);
     });
-  }
+  };
 
   onScopeChange = async (instance, options) => {
     const { scopeKey } = this.options;
     if (scopeKey && !instance.isNewRecord && instance._previousDataValues[scopeKey] != instance[scopeKey]) {
       await this.setSortValue(instance, options);
     }
-  }
+  };
 
   initRecordsSortValue = async ({ transaction }) => {
     const totalCount = await this.collection.repository.count({
       transaction,
     });
+
     const emptyCount = await this.collection.repository.count({
       filter: {
         [this.name]: null,
@@ -73,7 +74,7 @@ export class SortField extends Field {
         start += 1;
       }
     }
-  }
+  };
 
   bind() {
     super.bind();

package/src/filter-match.ts

@@ -0,0 +1,49 @@
+import { filter } from 'mathjs';
+
+export function filterMatch(model, where) {
+  if (where.filter !== undefined) {
+    where = filter;
+  }
+
+  // Create an object that maps operator names to functions
+  const operatorFunctions = {
+    $eq: (value, condition) => value === condition,
+    $not: (value, condition) => !filterMatch(model, condition),
+    $gt: (value, condition) => value > condition,
+    $gte: (value, condition) => value >= condition,
+    $lt: (value, condition) => value < condition,
+    $lte: (value, condition) => value <= condition,
+    $ne: (value, condition) => value !== condition,
+    $in: (value, condition) => condition.includes(value),
+    $or: (model, conditions) => Object.values(conditions).some((condition) => filterMatch(model, condition)),
+    $and: (model, conditions) => Object.values(conditions).every((condition) => filterMatch(model, condition)),
+  };
+
+  for (const [key, value] of Object.entries(where)) {
+    // Check if the property value contains a logical operator
+    if (operatorFunctions[key] !== undefined) {
+      // Check if the conditions specified in the property value are satisfied
+      if (!operatorFunctions[key](model, value)) {
+        return false;
+      }
+    } else {
+      // Check if the property value is an object (which would contain operators)
+      if (typeof value === 'object') {
+        // Loop through each operator in the property value
+        for (const [operator, condition] of Object.entries(value)) {
+          // Check if the property value satisfies the condition
+          if (!operatorFunctions[operator](model[key], condition)) {
+            return false;
+          }
+        }
+      } else {
+        // Assume the default operator is "eq"
+        if (!operatorFunctions['$eq'](model[key], value)) {
+          return false;
+        }
+      }
+    }
+  }
+
+  return true;
+}

package/src/filter-parser.ts

@@ -1,6 +1,6 @@
 import { flatten, unflatten } from 'flat';
 import { default as lodash, default as _ } from 'lodash';
-import { ModelCtor } from 'sequelize';
+import { ModelStatic } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
 import { Model } from './model';
@@ -17,7 +17,7 @@ interface FilterParserContext {
 export default class FilterParser {
   collection: Collection;
   database: Database;
-  model: ModelCtor<Model>;
+  model: ModelStatic<Model>;
   filter: FilterType;
   context: FilterParserContext;
 

package/src/index.ts

@@ -1,5 +1,6 @@
-export { DataTypes, ModelCtor, Op, SyncOptions } from 'sequelize';
+export { DataTypes, ModelStatic, Op, SyncOptions } from 'sequelize';
 export * from './collection';
+export * from './inherited-collection';
 export * from './database';
 export { Database as default } from './database';
 export * from './fields';
@@ -14,4 +15,6 @@ export * from './relation-repository/multiple-relation-repository';
 export * from './relation-repository/single-relation-repository';
 export * from './repository';
 export * from './update-associations';
-
+export * from './collection-importer';
+export * from './filter-match';
+export * from './field-repository/array-field-repository';

package/src/inherited-collection.ts

@@ -0,0 +1,112 @@
+import { Collection, CollectionContext, CollectionOptions } from './collection';
+import { default as lodash } from 'lodash';
+import { Field } from '.';
+
+export class InheritedCollection extends Collection {
+  parents?: Collection[];
+  constructor(options: CollectionOptions, context: CollectionContext) {
+    if (!options.inherits) {
+      throw new Error('InheritedCollection must have inherits option');
+    }
+
+    options.inherits = lodash.castArray(options.inherits);
+
+    super(options, context);
+
+    try {
+      this.bindParents();
+    } catch (err) {
+      if (err instanceof ParentCollectionNotFound) {
+        const listener = (collection) => {
+          if (
+            options.inherits.includes(collection.name) &&
+            (options.inherits as Array<string>).every((name) => this.db.collections.has(name))
+          ) {
+            this.bindParents();
+            this.db.removeListener('afterDefineCollection', listener);
+          }
+        };
+
+        this.db.addListener('afterDefineCollection', listener);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  protected bindParents() {
+    this.setParents(this.options.inherits);
+    this.setParentFields();
+    this.setFields(this.options.fields, false);
+    this.db.inheritanceMap.setInheritance(this.name, this.options.inherits);
+  }
+
+  protected setParents(inherits: string | string[]) {
+    this.parents = lodash.castArray(inherits).map((name) => {
+      const existCollection = this.db.collections.get(name);
+      if (!existCollection) {
+        throw new ParentCollectionNotFound(name);
+      }
+
+      return existCollection;
+    });
+  }
+
+  protected setParentFields() {
+    for (const [name, fieldOptions] of this.parentFields()) {
+      this.setField(name, {
+        ...fieldOptions,
+        inherit: true,
+      });
+    }
+  }
+
+  getParents() {
+    return this.parents;
+  }
+
+  parentFields() {
+    const fields = new Map<string, Field>();
+
+    for (const parent of this.parents) {
+      if (parent.isInherited()) {
+        for (const [name, field] of (<InheritedCollection>parent).parentFields()) {
+          fields.set(name, field.options);
+        }
+      }
+
+      const parentFields = parent.fields;
+      for (const [name, field] of parentFields) {
+        fields.set(name, field.options);
+      }
+    }
+
+    return fields;
+  }
+
+  parentAttributes() {
+    const attributes = {};
+
+    for (const parent of this.parents) {
+      if (parent.isInherited()) {
+        Object.assign(attributes, (<InheritedCollection>parent).parentAttributes());
+      }
+
+      const parentAttributes = (<any>parent.model).tableAttributes;
+
+      Object.assign(attributes, parentAttributes);
+    }
+
+    return attributes;
+  }
+
+  isInherited() {
+    return true;
+  }
+}
+
+class ParentCollectionNotFound extends Error {
+  constructor(name: string) {
+    super(`parent collection ${name} not found`);
+  }
+}

package/src/inherited-map.ts

@@ -0,0 +1,97 @@
+import lodash from 'lodash';
+import Database from './database';
+
+class TableNode {
+  name: string;
+  parents: Set<TableNode>;
+  children: Set<TableNode>;
+  constructor(name: string) {
+    this.name = name;
+    this.parents = new Set();
+    this.children = new Set();
+  }
+}
+
+export default class InheritanceMap {
+  nodes: Map<string, TableNode> = new Map<string, TableNode>();
+
+  removeNode(name: string) {
+    const node = this.nodes.get(name);
+    if (!node) return;
+
+    for (const parent of node.parents) {
+      parent.children.delete(node);
+    }
+
+    for (const child of node.children) {
+      child.parents.delete(node);
+    }
+
+    this.nodes.delete(name);
+  }
+
+  getOrCreateNode(name: string) {
+    if (!this.nodes.has(name)) {
+      this.nodes.set(name, new TableNode(name));
+    }
+    return this.getNode(name);
+  }
+
+  getNode(name: string) {
+    return this.nodes.get(name);
+  }
+
+  setInheritance(name: string, inherits: string | string[]) {
+    const node = this.getOrCreateNode(name);
+    const parents = lodash.castArray(inherits).map((name) => this.getOrCreateNode(name));
+
+    node.parents = new Set(parents);
+
+    for (const parent of parents) {
+      parent.children.add(node);
+    }
+  }
+
+  isParentNode(name: string) {
+    const node = this.getNode(name);
+    return node && node.children.size > 0;
+  }
+
+  getChildren(name: string, options: { deep: boolean } = { deep: true }): Set<string> {
+    const results = new Set<string>();
+    const node = this.getNode(name);
+    if (!node) return results;
+
+    for (const child of node.children) {
+      results.add(child.name);
+      if (!options.deep) {
+        continue;
+      }
+
+      for (const grandchild of this.getChildren(child.name)) {
+        results.add(grandchild);
+      }
+    }
+
+    return results;
+  }
+
+  getParents(name: string, options: { deep: boolean } = { deep: true }): Set<string> {
+    const results = new Set<string>();
+    const node = this.getNode(name);
+    if (!node) return results;
+
+    for (const parent of node.parents) {
+      results.add(parent.name);
+      if (!options.deep) {
+        continue;
+      }
+
+      for (const grandparent of this.getParents(parent.name)) {
+        results.add(grandparent);
+      }
+    }
+
+    return results;
+  }
+}

package/src/model-hook.ts

@@ -1,12 +1,11 @@
 import lodash from 'lodash';
-import type { SequelizeHooks } from 'sequelize/types/lib/hooks';
+import { SequelizeHooks } from 'sequelize/types/hooks';
+
 import Database from './database';
 import { Model } from './model';
 
 const { hooks } = require('sequelize/lib/hooks');
 
-
-
 export class ModelHook {
   database: Database;
 

package/src/model.ts

@@ -1,15 +1,19 @@
 import lodash from 'lodash';
-import { Model as SequelizeModel, ModelCtor } from 'sequelize';
+import { DataTypes, Model as SequelizeModel, ModelStatic } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
 import { Field } from './fields';
+import type { InheritedCollection } from './inherited-collection';
+import { SyncRunner } from './sync-runner';
+
+const _ = lodash;
 
 interface IModel {
   [key: string]: any;
 }
 
 interface JSONTransformerOptions {
-  model: ModelCtor<any>;
+  model: ModelStatic<any>;
   collection: Collection;
   db: Database;
   key?: string;
@@ -78,7 +82,7 @@ export class Model<TModelAttributes extends {} = any, TCreationAttributes extend
     };
 
     const opts = {
-      model: this.constructor as ModelCtor<any>,
+      model: this.constructor as ModelStatic<any>,
       collection: (this.constructor as any).collection,
       db: (this.constructor as any).database as Database,
     };
@@ -145,4 +149,40 @@ export class Model<TModelAttributes extends {} = any, TCreationAttributes extend
 
     return lodash.orderBy(data, orderItems, orderDirections);
   }
+
+  static async sync(options) {
+    const model = this as any;
+
+    // fix sequelize sync with model that not have any column
+    if (Object.keys(model.tableAttributes).length === 0) {
+      if (this.database.inDialect('sqlite', 'mysql')) {
+        throw new Error(`Zero-column tables aren't supported in ${this.database.sequelize.getDialect()}`);
+      }
+
+      // @ts-ignore
+      const queryInterface = this.sequelize.queryInterface;
+
+      if (!queryInterface.patched) {
+        const oldDescribeTable = queryInterface.describeTable;
+        queryInterface.describeTable = async function (...args) {
+          try {
+            return await oldDescribeTable.call(this, ...args);
+          } catch (err) {
+            if (err.message.includes('No description found for')) {
+              return [];
+            } else {
+              throw err;
+            }
+          }
+        };
+        queryInterface.patched = true;
+      }
+    }
+
+    if (this.collection.isInherited()) {
+      return SyncRunner.syncInheritModel(model, options);
+    }
+
+    return SequelizeModel.sync.call(this, options);
+  }
 }

package/src/operators/array.ts

@@ -149,4 +149,4 @@ export default {
       [Op.and]: [Sequelize.literal(`${subQuery}`)],
     };
   },
-};
+} as Record<string, any>;

package/src/operators/association.ts

@@ -11,4 +11,4 @@ export default {
       [Op.is]: null,
     };
   },
-};
+} as Record<string, any>;

package/src/operators/boolean.ts

@@ -15,4 +15,4 @@ export default {
       [Op.eq]: true,
     };
   },
-};
+} as Record<string, any>;

package/src/operators/date.ts

@@ -38,4 +38,4 @@ export default {
   $dateNotAfter(value) {
     return { [Op.lt]: getNextDay(value) };
   },
-};
+} as Record<string, any>;

package/src/operators/empty.ts

@@ -1,4 +1,4 @@
-import { DataTypes, Op } from 'sequelize';
+import { Op } from 'sequelize';
 import { ArrayField, StringField } from '../fields';
 import arrayOperators from './array';
 import lodash, { parseInt } from 'lodash';

package/src/operators/ne.ts

@@ -13,4 +13,4 @@ export default {
         },
       };
   },
-};
+} as Record<string, any>;

package/src/operators/notIn.ts

@@ -9,4 +9,5 @@ export default {
       },
     };
   },
-};
+} as Record<string, any>;
+