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

package/src/options-parser.ts

@@ -1,4 +1,4 @@
-import { FindAttributeOptions, ModelCtor, Op, Sequelize } from 'sequelize';
+import { FindAttributeOptions, ModelStatic, Op, Sequelize } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
 import FilterParser from './filter-parser';
@@ -15,7 +15,7 @@ export class OptionsParser {
   options: FindOptions;
   database: Database;
   collection: Collection;
-  model: ModelCtor<any>;
+  model: ModelStatic<any>;
   filterParser: FilterParser;
   context: OptionsParserContext;
 
@@ -104,6 +104,13 @@ export class OptionsParser {
     return filterParams;
   }
 
+  protected inheritFromSubQuery(): any {
+    return [
+      Sequelize.literal(`(select relname from pg_class where pg_class.oid = "${this.collection.name}".tableoid)`),
+      '__tableName',
+    ];
+  }
+
   protected parseFields(filterParams: any) {
     const appends = this.options?.appends || [];
     const except = [];
@@ -113,6 +120,10 @@ export class OptionsParser {
       exclude: [],
     }; // out put all fields by default
 
+    if (this.collection.isParent()) {
+      attributes.include.push(this.inheritFromSubQuery());
+    }
+
     if (this.options?.fields) {
       // 将fields拆分为 attributes 和 appends
       for (const field of this.options.fields) {
@@ -121,7 +132,12 @@ export class OptionsParser {
           appends.push(field);
         } else {
           // field is model attribute, change attributes to array type
-          if (!Array.isArray(attributes)) attributes = [];
+          if (!Array.isArray(attributes)) {
+            attributes = [];
+            if (this.collection.isParent()) {
+              attributes.push(this.inheritFromSubQuery());
+            }
+          }
 
           attributes.push(field);
         }
@@ -196,7 +212,7 @@ export class OptionsParser {
      * @param queryParams
      * @param append
      */
-    const setInclude = (model: ModelCtor<any>, queryParams: any, append: string) => {
+    const setInclude = (model: ModelStatic<any>, queryParams: any, append: string) => {
       const appendFields = append.split('.');
       const appendAssociation = appendFields[0];
 

package/src/relation-repository/relation-repository.ts

@@ -1,5 +1,5 @@
 import lodash from 'lodash';
-import { Association, BelongsTo, BelongsToMany, HasMany, HasOne, ModelCtor, Transaction } from 'sequelize';
+import { Association, BelongsTo, BelongsToMany, HasMany, HasOne, ModelStatic, Transaction } from 'sequelize';
 import { Collection } from '../collection';
 import Database from '../database';
 import { transactionWrapperBuilder } from '../decorators/transaction-decorator';
@@ -18,7 +18,7 @@ export const transaction = transactionWrapperBuilder(function () {
 export abstract class RelationRepository {
   sourceCollection: Collection;
   association: Association;
-  targetModel: ModelCtor<any>;
+  targetModel: ModelStatic<any>;
   targetCollection: Collection;
   associationName: string;
   associationField: RelationField;

package/src/relation-repository/single-relation-repository.ts

@@ -1,10 +1,10 @@
-import lodash, { omit } from 'lodash';
+import lodash from 'lodash';
 import { SingleAssociationAccessors, Transactionable } from 'sequelize';
 import { Model } from '../model';
 import { Appends, Except, Fields, Filter, TargetKey, UpdateOptions } from '../repository';
 import { updateModelByValues } from '../update-associations';
-import { RelationRepository, transaction } from './relation-repository';
 import { handleAppendsQuery } from '../utils';
+import { RelationRepository, transaction } from './relation-repository';
 
 export interface SingleRelationFindOption extends Transactionable {
   fields?: Fields;

package/src/repository.ts

@@ -7,17 +7,18 @@ import {
   DestroyOptions as SequelizeDestroyOptions,
   FindAndCountOptions as SequelizeAndCountOptions,
   FindOptions as SequelizeFindOptions,
-  ModelCtor,
+  ModelStatic,
   Op,
   Transactionable,
   UpdateOptions as SequelizeUpdateOptions,
+  WhereOperators,
 } from 'sequelize';
-import { WhereOperators } from 'sequelize/types/lib/model';
 import { Collection } from './collection';
 import { Database } from './database';
 import mustHaveFilter from './decorators/must-have-filter-decorator';
 import { transactionWrapperBuilder } from './decorators/transaction-decorator';
-import { RelationField } from './fields';
+import { ArrayFieldRepository } from './field-repository/array-field-repository';
+import { ArrayField, RelationField } from './fields';
 import FilterParser from './filter-parser';
 import { Model } from './model';
 import operators from './operators';
@@ -86,10 +87,11 @@ export type AssociationKeysToBeUpdate = string[];
 
 export type Values = any;
 
-export interface CountOptions extends Omit<SequelizeCountOptions, 'distinct' | 'where' | 'include'>, Transactionable {
-  filter?: Filter;
-  context?: any;
-}
+export type CountOptions = Omit<SequelizeCountOptions, 'distinct' | 'where' | 'include'> &
+  Transactionable & {
+    filter?: Filter;
+    context?: any;
+  } & FilterByTk;
 
 export interface FilterByTk {
   filterByTk?: TargetKey;
@@ -135,6 +137,10 @@ export interface UpdateOptions extends Omit<SequelizeUpdateOptions, 'where'> {
   context?: any;
 }
 
+interface UpdateManyOptions extends UpdateOptions {
+  records: Values[];
+}
+
 interface RelatedQueryOptions {
   database: Database;
   field: RelationField;
@@ -157,19 +163,29 @@ const transaction = transactionWrapperBuilder(function () {
 class RelationRepositoryBuilder<R extends RelationRepository> {
   collection: Collection;
   associationName: string;
-  association: Association;
+  association: Association | { associationType: string };
 
   builderMap = {
     HasOne: HasOneRepository,
     BelongsTo: BelongsToRepository,
     BelongsToMany: BelongsToManyRepository,
     HasMany: HasManyRepository,
+    ArrayField: ArrayFieldRepository,
   };
 
   constructor(collection: Collection, associationName: string) {
     this.collection = collection;
     this.associationName = associationName;
     this.association = this.collection.model.associations[this.associationName];
+
+    if (!this.association) {
+      const field = collection.getField(associationName);
+      if (field && field instanceof ArrayField) {
+        this.association = {
+          associationType: 'ArrayField',
+        };
+      }
+    }
   }
 
   protected builder() {
@@ -187,7 +203,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
 {
   database: Database;
   collection: Collection;
-  model: ModelCtor<Model>;
+  model: ModelStatic<Model>;
 
   constructor(collection: Collection) {
     this.database = collection.context.database;
@@ -210,12 +226,32 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
       };
     }
 
-    const count = await this.collection.model.count({
+    if (countOptions?.filterByTk) {
+      options['where'] = {
+        [Op.and]: [
+          options['where'] || {},
+          {
+            [this.collection.filterTargetKey]: options.filterByTk,
+          },
+        ],
+      };
+    }
+
+    const queryOptions: any = {
       ...options,
-      distinct: true,
+      distinct: Boolean(this.collection.model.primaryKeyAttribute),
+    };
+
+    if (queryOptions.include?.length === 0) {
+      delete queryOptions.include;
+    }
+
+    const count = await this.collection.model.count({
+      ...queryOptions,
       transaction,
     });
 
+    // @ts-ignore
     return count;
   }
 
@@ -232,6 +268,8 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
       ...this.buildQueryOptions(options),
     };
 
+    let rows;
+
     if (opts.include && opts.include.length > 0) {
       // @ts-ignore
       const primaryKeyField = model.primaryKeyField || model.primaryKeyAttribute;
@@ -243,7 +281,12 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
           attributes: [primaryKeyField],
           group: `${model.name}.${primaryKeyField}`,
           transaction,
-        })
+          include: opts.include.filter((include) => {
+            return (
+              Object.keys(include.where || {}).length > 0 || JSON.stringify(opts?.filter)?.includes(include.association)
+            );
+          }),
+        } as any)
       ).map((row) => {
         return { row, pk: row.get(primaryKeyField) };
       });
@@ -252,33 +295,54 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
         return [];
       }
 
+      const templateModel = await model.findOne({
+        ...opts,
+        includeIgnoreAttributes: false,
+        attributes: [primaryKeyField],
+        group: `${model.name}.${primaryKeyField}`,
+        transaction,
+        limit: 1,
+        offset: 0,
+      } as any);
+
       const where = {
         [primaryKeyField]: {
           [Op.in]: ids.map((id) => id['pk']),
         },
       };
 
-      return await handleAppendsQuery({
+      rows = await handleAppendsQuery({
         queryPromises: opts.include.map((include) => {
-          return model
-            .findAll({
-              ...omit(opts, ['limit', 'offset']),
-              include: include,
-              where,
-              transaction,
-            })
-            .then((rows) => {
-              return { rows, include };
-            });
+          const options = {
+            ...omit(opts, ['limit', 'offset']),
+            include: include,
+            where,
+            transaction,
+          };
+
+          return model.findAll(options).then((rows) => {
+            return { rows, include };
+          });
         }),
-        templateModel: ids[0].row,
+        templateModel: templateModel,
+      });
+    } else {
+      rows = await model.findAll({
+        ...opts,
+        transaction,
       });
     }
 
-    return await model.findAll({
-      ...opts,
-      transaction,
-    });
+    if (this.collection.isParent()) {
+      for (const row of rows) {
+        const rowCollectionName = this.database.tableNameCollectionMap.get(row.get('__tableName')).name;
+        row.set('__collection', rowCollectionName, {
+          raw: true,
+        });
+      }
+    }
+
+    return rows;
   }
 
   /**
@@ -338,7 +402,6 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     const guard = UpdateGuard.fromOptions(this.model, { ...options, action: 'create' });
     const values = guard.sanitize(options.values || {});
 
-
     const instance = await this.model.create<any>(values, {
       ...options,
       transaction,
@@ -397,7 +460,14 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
   @transaction()
   @mustHaveFilter()
   async update(options: UpdateOptions & { forceUpdate?: boolean }) {
+    if (Array.isArray(options.values)) {
+      return this.updateMany({
+        ...options,
+        records: options.values,
+      });
+    }
     const transaction = await this.getTransaction(options);
+
     const guard = UpdateGuard.fromOptions(this.model, options);
 
     const values = guard.sanitize(options.values);
@@ -434,6 +504,24 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     return instances;
   }
 
+  @transaction()
+  async updateMany(options: UpdateManyOptions) {
+    const transaction = await this.getTransaction(options);
+    const { records } = options;
+    const instances = [];
+
+    for (const values of records) {
+      const filterByTk = values[this.model.primaryKeyAttribute];
+      if (!filterByTk) {
+        throw new Error('filterByTk invalid');
+      }
+      const instance = await this.update({ values, filterByTk, transaction });
+      instances.push(instance);
+    }
+
+    return instances;
+  }
+
   @transaction((args, transaction) => {
     return {
       filterByTk: args[0],
@@ -456,6 +544,18 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
         ? [options.filterByTk]
         : (options.filterByTk as TargetKey[] | undefined);
 
+    if (
+      this.collection.model.primaryKeyAttributes.length !== 1 &&
+      filterByTk &&
+      !lodash.get(this.collection.options, 'filterTargetKey')
+    ) {
+      if (this.collection.model.primaryKeyAttributes.length > 1) {
+        throw new Error(`filterByTk is not supported for composite primary key`);
+      } else {
+        throw new Error(`filterByTk is not supported for collection that has no primary key`);
+      }
+    }
+
     if (filterByTk && !options.filter) {
       return await this.model.destroy({
         ...options,
@@ -469,6 +569,20 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     }
 
     if (options.filter) {
+      if (
+        this.collection.model.primaryKeyAttributes.length !== 1 &&
+        !lodash.get(this.collection.options, 'filterTargetKey')
+      ) {
+        const queryOptions = {
+          ...this.buildQueryOptions(options),
+        };
+
+        return await this.model.destroy({
+          ...queryOptions,
+          transaction,
+        });
+      }
+
       let pks = (
         await this.find({
           filter: options.filter,
@@ -506,7 +620,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
     return new RelationRepositoryBuilder<R>(this.collection, association);
   }
 
-  protected buildQueryOptions(options: any) {
+  public buildQueryOptions(options: any) {
     const parser = new OptionsParser(options, {
       collection: this.collection,
     });

package/src/sync-runner.ts

@@ -0,0 +1,162 @@
+import { InheritedCollection } from './inherited-collection';
+import lodash from 'lodash';
+import { Sequelize } from 'sequelize';
+
+export class SyncRunner {
+  static async syncInheritModel(model: any, options: any) {
+    const { transaction } = options;
+
+    const inheritedCollection = model.collection as InheritedCollection;
+    const db = inheritedCollection.context.database;
+    const dialect = db.sequelize.getDialect();
+
+    const queryInterface = db.sequelize.getQueryInterface();
+
+    if (dialect != 'postgres') {
+      throw new Error('Inherit model is only supported on postgres');
+    }
+
+    const parents = inheritedCollection.parents;
+
+    if (!parents) {
+      throw new Error(
+        `Inherit model ${inheritedCollection.name} can't be created without parents, parents option is ${lodash
+          .castArray(inheritedCollection.options.inherits)
+          .join(', ')}`,
+      );
+    }
+
+    const parentTables = parents.map((parent) => parent.model.tableName);
+
+    const tableName = model.getTableName();
+
+    const attributes = model.tableAttributes;
+
+    const childAttributes = lodash.pickBy(attributes, (value) => {
+      return !value.inherit;
+    });
+
+    let maxSequenceVal = 0;
+    let maxSequenceName;
+
+    if (childAttributes.id && childAttributes.id.autoIncrement) {
+      for (const parent of parentTables) {
+        const sequenceNameResult = await queryInterface.sequelize.query(
+          `SELECT column_default FROM information_schema.columns WHERE 
+          table_name='${parent}' and "column_name" = 'id';`,
+          {
+            transaction,
+          },
+        );
+
+        if (!sequenceNameResult[0].length) {
+          continue;
+        }
+
+        const columnDefault = sequenceNameResult[0][0]['column_default'];
+
+        if (!columnDefault) {
+          throw new Error(`Can't find sequence name of ${parent}`);
+        }
+
+        const regex = new RegExp(/nextval\('("?\w+"?)\'.*\)/);
+        const match = regex.exec(columnDefault);
+
+        const sequenceName = match[1];
+
+        const sequenceCurrentValResult = await queryInterface.sequelize.query(
+          `select last_value from ${sequenceName}`,
+          {
+            transaction,
+          },
+        );
+
+        const sequenceCurrentVal = parseInt(sequenceCurrentValResult[0][0]['last_value']);
+
+        if (sequenceCurrentVal > maxSequenceVal) {
+          maxSequenceName = sequenceName;
+          maxSequenceVal = sequenceCurrentVal;
+        }
+      }
+    }
+
+    await this.createTable(tableName, childAttributes, options, model, parentTables);
+
+    if (maxSequenceName) {
+      const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(
+        (parent) => db.getCollection(parent).model.tableName,
+      );
+
+      const sequenceTables = [...parentsDeep, tableName];
+
+      for (const sequenceTable of sequenceTables) {
+        const queryName = Boolean(sequenceTable.match(/[A-Z]/)) ? `"${sequenceTable}"` : sequenceTable;
+
+        const idColumnQuery = await queryInterface.sequelize.query(
+          `
+SELECT true
+FROM   pg_attribute 
+WHERE  attrelid = '${queryName}'::regclass  -- cast to a registered class (table)
+AND    attname = 'id'
+AND    NOT attisdropped 
+`,
+          {
+            transaction,
+          },
+        );
+
+        if (idColumnQuery[0].length == 0) {
+          continue;
+        }
+
+        await queryInterface.sequelize.query(
+          `alter table "${sequenceTable}" alter column id set default nextval('${maxSequenceName}')`,
+          {
+            transaction,
+          },
+        );
+      }
+    }
+
+    if (options.alter) {
+      const columns = await queryInterface.describeTable(tableName, options);
+
+      for (const columnName in childAttributes) {
+        if (!columns[columnName]) {
+          await queryInterface.addColumn(tableName, columnName, childAttributes[columnName], options);
+        }
+      }
+    }
+  }
+
+  static async createTable(tableName, attributes, options, model, parentTables) {
+    let sql = '';
+
+    options = { ...options };
+
+    if (options && options.uniqueKeys) {
+      lodash.forOwn(options.uniqueKeys, (uniqueKey) => {
+        if (uniqueKey.customIndex === undefined) {
+          uniqueKey.customIndex = true;
+        }
+      });
+    }
+
+    if (model) {
+      options.uniqueKeys = options.uniqueKeys || model.uniqueKeys;
+    }
+
+    const queryGenerator = model.queryGenerator;
+
+    attributes = lodash.mapValues(attributes, (attribute) => model.sequelize.normalizeAttribute(attribute));
+
+    attributes = queryGenerator.attributesToSQL(attributes, { table: tableName, context: 'createTable' });
+
+    sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(
+      ';',
+      ` INHERITS (${parentTables.map((t) => `"${t}"`).join(', ')});`,
+    );
+
+    return await model.sequelize.query(sql, options);
+  }
+}

package/src/types.ts

@@ -1,8 +1,8 @@
 import type { Model } from './model';
-import type { ValidationOptions } from 'sequelize/types/lib/instance-validator';
-import type { HookReturn } from 'sequelize/types/lib/hooks';
 import type { CreateOptions, DestroyOptions, SaveOptions, SyncOptions, UpdateOptions } from 'sequelize/types';
 import { Collection, CollectionOptions } from './collection';
+import { HookReturn } from 'sequelize/types/hooks';
+import { ValidationOptions } from 'sequelize/types/instance-validator';
 
 export type CollectionNameType = string;
 

package/src/update-associations.ts

@@ -5,8 +5,8 @@ import {
   HasMany,
   HasOne,
   Hookable,
-  ModelCtor,
-  Transactionable
+  ModelStatic,
+  Transactionable,
 } from 'sequelize';
 import { Model } from './model';
 import { UpdateGuard } from './update-guard';
@@ -64,6 +64,7 @@ interface UpdateAssociationOptions extends Transactionable, Hookable {
   sourceModel?: Model;
   context?: any;
   associationContext?: any;
+  recursive?: boolean;
 }
 
 export async function updateModelByValues(instance: Model, values: UpdateValue, options?: UpdateOptions) {
@@ -120,6 +121,10 @@ export async function updateAssociations(instance: Model, values: any, options:
     return;
   }
 
+  if (options?.updateAssociationValues) {
+    options.recursive = true;
+  }
+
   let newTransaction = false;
   let transaction = options.transaction;
 
@@ -262,7 +267,7 @@ export async function updateSingleAssociation(
     throw new Error(`The value of '${key}' cannot be in array format`);
   }
 
-  const { context, updateAssociationValues = [], transaction } = options;
+  const { recursive, context, updateAssociationValues = [], transaction } = options;
   const keys = getKeysByPrefix(updateAssociationValues, key);
 
   try {
@@ -292,13 +297,13 @@ export async function updateSingleAssociation(
 
     const createAccessor = association.accessors.create;
     let dataKey: string;
-    let M: ModelCtor<Model>;
+    let M: ModelStatic<Model>;
     if (association.associationType === 'BelongsTo') {
-      M = association.target as ModelCtor<Model>;
+      M = association.target as ModelStatic<Model>;
       // @ts-ignore
       dataKey = association.targetKey;
     } else {
-      M = association.target as ModelCtor<Model>;
+      M = association.target as ModelStatic<Model>;
       dataKey = M.primaryKeyAttribute;
     }
 
@@ -313,6 +318,10 @@ export async function updateSingleAssociation(
       if (instance) {
         await model[setAccessor](instance, { context, transaction });
 
+        if (!recursive) {
+          return;
+        }
+
         if (updateAssociationValues.includes(key)) {
           await instance.update(value, { ...options, transaction });
         }
@@ -368,13 +377,14 @@ export async function updateMultipleAssociation(
     return false;
   }
 
-  const { context, updateAssociationValues = [], transaction } = options;
+  const { recursive, context, updateAssociationValues = [], transaction } = options;
   const keys = getKeysByPrefix(updateAssociationValues, key);
 
   try {
     const setAccessor = association.accessors.set;
 
     const createAccessor = association.accessors.create;
+
     if (isUndefinedOrNull(value)) {
       await model[setAccessor](null, { transaction, context });
       model.setDataValue(key, null);
@@ -442,9 +452,15 @@ export async function updateMultipleAssociation(
         const instance = await association.target.findByPk<any>(item[pk], {
           transaction,
         });
+        if (!instance) {
+          continue;
+        }
         const addAccessor = association.accessors.add;
 
         await model[addAccessor](item[pk], accessorOptions);
+        if (!recursive) {
+          continue;
+        }
         if (updateAssociationValues.includes(key)) {
           await instance.update(item, { ...options, transaction });
         }

package/src/update-guard.ts

@@ -1,5 +1,5 @@
 import lodash from 'lodash';
-import { ModelCtor } from 'sequelize';
+import { ModelStatic } from 'sequelize';
 import { Model } from './model';
 import { AssociationKeysToBeUpdate, BlackList, WhiteList } from './repository';
 
@@ -11,7 +11,7 @@ type UpdateValues = {
 
 type UpdateAction = 'create' | 'update';
 export class UpdateGuard {
-  model: ModelCtor<any>;
+  model: ModelStatic<any>;
   action: UpdateAction;
   private associationKeysToBeUpdate: AssociationKeysToBeUpdate;
   private blackList: BlackList;
@@ -21,7 +21,7 @@ export class UpdateGuard {
     this.action = action;
   }
 
-  setModel(model: ModelCtor<any>) {
+  setModel(model: ModelStatic<any>) {
     this.model = model;
   }