@nocobase/database 0.7.4-alpha.4 → 0.7.5-alpha.1

package/src/operators/array.ts

@@ -1,5 +1,5 @@
 import { Op, Sequelize } from 'sequelize';
-import { isPg, isMySQL } from './utils';
+import { isMySQL, isPg } from './utils';
 
 const getFieldName = (ctx) => {
   const fieldName = ctx.fieldName;
@@ -13,10 +13,11 @@ const escape = (value, ctx) => {
 
 const sqliteExistQuery = (value, ctx) => {
   const fieldName = getFieldName(ctx);
+  const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
 
   const sqlArray = `(${value.map((v) => `'${v}'`).join(', ')})`;
 
-  const subQuery = `exists (select * from json_each(${fieldName}) where json_each.value in ${sqlArray})`;
+  const subQuery = `exists (select * from json_each(${name}) where json_each.value in ${sqlArray})`;
 
   return subQuery;
 };
@@ -53,7 +54,8 @@ export default {
     value = escape(JSON.stringify(value.sort()), ctx);
 
     if (isMySQL(ctx)) {
-      return Sequelize.literal(`JSON_CONTAINS(${fieldName}, ${value}) AND JSON_CONTAINS(${value}, ${fieldName})`);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      return Sequelize.literal(`JSON_CONTAINS(${name}, ${value}) AND JSON_CONTAINS(${value}, ${name})`);
     }
 
     return {
@@ -66,11 +68,13 @@ export default {
     value = escape(JSON.stringify(value), ctx);
 
     if (isPg(ctx)) {
-      return Sequelize.literal(`not (${fieldName} <@ ${value}::JSONB and ${fieldName} @> ${value}::JSONB)`);
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
+      return Sequelize.literal(`not (${name} <@ ${value}::JSONB and ${name} @> ${value}::JSONB)`);
     }
 
     if (isMySQL(ctx)) {
-      return Sequelize.literal(`not (JSON_CONTAINS(${fieldName}, ${value}) AND JSON_CONTAINS(${value}, ${fieldName}))`);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      return Sequelize.literal(`not (JSON_CONTAINS(${name}, ${value}) AND JSON_CONTAINS(${value}, ${name}))`);
     }
     return {
       [Op.ne]: Sequelize.literal(`json(${value})`),
@@ -81,8 +85,9 @@ export default {
     const fieldName = getFieldName(ctx);
 
     if (isPg(ctx)) {
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
       return Sequelize.literal(
-        `${fieldName} ?| ${escape(
+        `${name} ?| ${escape(
           value.map((i) => `${i}`),
           ctx,
         )}`,
@@ -91,8 +96,8 @@ export default {
 
     if (isMySQL(ctx)) {
       value = escape(JSON.stringify(value), ctx);
-
-      return Sequelize.literal(`JSON_OVERLAPS(${fieldName}, ${value})`);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      return Sequelize.literal(`JSON_OVERLAPS(${name}, ${value})`);
     }
 
     const subQuery = sqliteExistQuery(value, ctx);
@@ -105,9 +110,10 @@ export default {
 
     if (isPg(ctx)) {
       const fieldName = getFieldName(ctx);
+      const name = ctx.fullName === fieldName ? `"${ctx.model.name}"."${fieldName}"` : `"${fieldName}"`;
       // pg single quote
       where = Sequelize.literal(
-        `not (${fieldName} ?| ${escape(
+        `not (${name} ?| ${escape(
           value.map((i) => `${i}`),
           ctx,
         )})`,
@@ -115,7 +121,8 @@ export default {
     } else if (isMySQL(ctx)) {
       const fieldName = getFieldName(ctx);
       value = escape(JSON.stringify(value), ctx);
-      where = Sequelize.literal(`NOT JSON_OVERLAPS(${fieldName}, ${value})`);
+      const name = ctx.fullName === fieldName ? `\`${ctx.model.name}\`.\`${fieldName}\`` : `\`${fieldName}\``;
+      where = Sequelize.literal(`NOT JSON_OVERLAPS(${name}, ${value})`);
     } else {
       const subQuery = sqliteExistQuery(value, ctx);
 

package/src/operators/ne.ts

@@ -2,11 +2,15 @@ import { Op } from 'sequelize';
 
 export default {
   $ne(val, ctx) {
-    return {
-      [Op.or]: {
-        [Op.ne]: val,
-        [Op.is]: null,
-      },
-    };
+    return val === null
+      ? {
+        [Op.ne]: null,
+      }
+      : {
+        [Op.or]: {
+          [Op.ne]: val,
+          [Op.is]: null,
+        },
+      };
   },
 };

package/src/relation-repository/belongs-to-many-repository.ts

@@ -31,6 +31,10 @@ interface IBelongsToManyRepository<M extends Model> {
 export class BelongsToManyRepository extends MultipleRelationRepository implements IBelongsToManyRepository<any> {
   @transaction()
   async create(options?: CreateBelongsToManyOptions): Promise<any> {
+    if (Array.isArray(options.values)) {
+      return Promise.all(options.values.map((record) => this.create({ ...options, values: record })));
+    }
+
     const transaction = await this.getTransaction(options);
 
     const createAccessor = this.accessors().create;

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

@@ -9,11 +9,12 @@ import {
   FindOptions,
   TargetKey,
   TK,
-  UpdateOptions
+  UpdateOptions,
 } from '../repository';
 import { updateModelByValues } from '../update-associations';
 import { UpdateGuard } from '../update-guard';
 import { RelationRepository, transaction } from './relation-repository';
+import { handleAppendsQuery } from '../utils';
 
 export interface FindAndCountOptions extends CommonFindOptions {}
 
@@ -52,16 +53,30 @@ export abstract class MultipleRelationRepository extends RelationRepository {
           group: `${this.targetModel.name}.${this.targetKey()}`,
           transaction,
         })
-      ).map((row) => row.get(this.targetKey()));
-
-      return await sourceModel[getAccessor]({
-        ...omit(findOptions, ['limit', 'offset']),
-        where: {
-          [this.targetKey()]: {
-            [Op.in]: ids,
-          },
-        },
-        transaction,
+      ).map((row) => {
+        return { row, pk: row.get(this.targetKey()) };
+      });
+
+      if (ids.length == 0) {
+        return [];
+      }
+
+      return await handleAppendsQuery({
+        templateModel: ids[0].row,
+        queryPromises: findOptions.include.map((include) => {
+          return sourceModel[getAccessor]({
+            ...omit(findOptions, ['limit', 'offset']),
+            include: [include],
+            where: {
+              [this.targetKey()]: {
+                [Op.in]: ids.map((id) => id.pk),
+              },
+            },
+            transaction,
+          }).then((rows) => {
+            return { rows, include };
+          });
+        }),
       });
     }
 

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

@@ -7,7 +7,7 @@ import FilterParser from '../filter-parser';
 import { Model } from '../model';
 import { OptionsParser } from '../options-parser';
 import { CreateOptions, Filter, FindOptions } from '../repository';
-import { transactionWrapperBuilder } from '../transaction-decorator';
+import { transactionWrapperBuilder } from '../decorators/transaction-decorator';
 import { updateAssociations } from '../update-associations';
 import { UpdateGuard } from '../update-guard';
 
@@ -54,6 +54,10 @@ export abstract class RelationRepository {
 
   @transaction()
   async create(options?: CreateOptions): Promise<any> {
+    if (Array.isArray(options.values)) {
+      return Promise.all(options.values.map((record) => this.create({ ...options, values: record })));
+    }
+
     const createAccessor = this.accessors().create;
 
     const guard = UpdateGuard.fromOptions(this.targetModel, options);

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

@@ -1,9 +1,10 @@
-import lodash from 'lodash';
+import lodash, { omit } 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';
 
 export interface SingleRelationFindOption extends Transactionable {
   fields?: Fields;
@@ -45,6 +46,7 @@ export abstract class SingleRelationRepository extends RelationRepository {
 
   async find(options?: SingleRelationFindOption): Promise<Model<any>> {
     const transaction = await this.getTransaction(options);
+
     const findOptions = this.buildQueryOptions({
       ...options,
     });
@@ -52,6 +54,30 @@ export abstract class SingleRelationRepository extends RelationRepository {
     const getAccessor = this.accessors().get;
     const sourceModel = await this.getSourceModel(transaction);
 
+    if (findOptions?.include?.length > 0) {
+      const templateModel = await sourceModel[getAccessor]({
+        ...findOptions,
+        includeIgnoreAttributes: false,
+        transaction,
+        attributes: [this.targetKey()],
+        group: `${this.targetModel.name}.${this.targetKey()}`,
+      });
+
+      const results = await handleAppendsQuery({
+        templateModel,
+        queryPromises: findOptions.include.map((include) => {
+          return sourceModel[getAccessor]({
+            ...findOptions,
+            include: [include],
+          }).then((row) => {
+            return { rows: [row], include };
+          });
+        }),
+      });
+
+      return results[0];
+    }
+
     return await sourceModel[getAccessor]({
       ...findOptions,
       transaction,

package/src/repository.ts

@@ -13,6 +13,8 @@ import {
 } from 'sequelize';
 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 FilterParser from './filter-parser';
 import { Model } from './model';
@@ -22,9 +24,9 @@ import { BelongsToRepository } from './relation-repository/belongs-to-repository
 import { HasManyRepository } from './relation-repository/hasmany-repository';
 import { HasOneRepository } from './relation-repository/hasone-repository';
 import { RelationRepository } from './relation-repository/relation-repository';
-import { transactionWrapperBuilder } from './transaction-decorator';
 import { updateAssociations, updateModelByValues } from './update-associations';
 import { UpdateGuard } from './update-guard';
+import { handleAppendsQuery } from './utils';
 
 const debug = require('debug')('noco-database');
 
@@ -98,7 +100,7 @@ interface FindAndCountOptions extends Omit<SequelizeAndCountOptions, 'where' | '
 }
 
 export interface CreateOptions extends SequelizeCreateOptions {
-  values?: Values;
+  values?: Values | Values[];
   whitelist?: WhiteList;
   blacklist?: BlackList;
   updateAssociationValues?: AssociationKeysToBeUpdate;
@@ -224,18 +226,34 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
           group: `${model.name}.${primaryKeyField}`,
           transaction,
         })
-      ).map((row) => row.get(primaryKeyField));
+      ).map((row) => {
+        return { row, pk: row.get(primaryKeyField) };
+      });
+
+      if (ids.length == 0) {
+        return [];
+      }
 
       const where = {
         [primaryKeyField]: {
-          [Op.in]: ids,
+          [Op.in]: ids.map((id) => id['pk']),
         },
       };
 
-      return await model.findAll({
-        ...omit(opts, ['limit', 'offset']),
-        where,
-        transaction,
+      return await handleAppendsQuery({
+        queryPromises: opts.include.map((include) => {
+          return model
+            .findAll({
+              ...omit(opts, ['limit', 'offset']),
+              include: include,
+              where,
+              transaction,
+            })
+            .then((rows) => {
+              return { rows, include };
+            });
+        }),
+        templateModel: ids[0].row,
       });
     }
 
@@ -286,7 +304,14 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
    * @param options
    */
   @transaction()
-  async create<M extends Model>(options: CreateOptions): Promise<M> {
+  async create(options: CreateOptions) {
+    if (Array.isArray(options.values)) {
+      return this.createMany({
+        ...options,
+        records: options.values,
+      });
+    }
+
     const transaction = await this.getTransaction(options);
 
     const guard = UpdateGuard.fromOptions(this.model, { ...options, action: 'create' });
@@ -335,6 +360,7 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
       const instance = await this.create({ values, transaction });
       instances.push(instance);
     }
+
     return instances;
   }
 
@@ -345,7 +371,8 @@ export class Repository<TModelAttributes extends {} = any, TCreationAttributes e
    * @param options
    */
   @transaction()
-  async update(options: UpdateOptions) {
+  @mustHaveFilter()
+  async update(options: UpdateOptions & { forceUpdate?: boolean }) {
     const transaction = await this.getTransaction(options);
     const guard = UpdateGuard.fromOptions(this.model, options);
 

package/src/update-associations.ts

@@ -6,7 +6,7 @@ import {
   HasOne,
   Hookable,
   ModelCtor,
-  Transactionable,
+  Transactionable
 } from 'sequelize';
 import { Model } from './model';
 import { UpdateGuard } from './update-guard';
@@ -130,37 +130,44 @@ export async function updateAssociations(instance: Model, values: any, options:
 
   const keys = Object.keys(values);
 
-  for (const key of Object.keys(modelAssociations(instance))) {
-    if (keys.includes(key)) {
-      await updateAssociation(instance, key, values[key], {
-        ...options,
-        transaction,
-      });
+  try {
+    for (const key of Object.keys(modelAssociations(instance))) {
+      if (keys.includes(key)) {
+        await updateAssociation(instance, key, values[key], {
+          ...options,
+          transaction,
+        });
+      }
     }
-  }
 
-  // update through table values
-  for (const belongsToMany of belongsToManyAssociations(instance)) {
-    // @ts-ignore
-    const throughModel = belongsToMany.through.model;
-    const throughModelName = throughModel.name;
-
-    if (values[throughModelName] && options.sourceModel) {
-      const where = {
-        [belongsToMany.foreignKey]: instance.get(belongsToMany.sourceKey),
-        [belongsToMany.otherKey]: options.sourceModel.get(belongsToMany.targetKey),
-      };
-
-      await throughModel.update(values[throughModel.name], {
-        where,
-        context: options.context,
-        transaction,
-      });
+    // update through table values
+    for (const belongsToMany of belongsToManyAssociations(instance)) {
+      // @ts-ignore
+      const throughModel = belongsToMany.through.model;
+      const throughModelName = throughModel.name;
+
+      if (values[throughModelName] && options.sourceModel) {
+        const where = {
+          [belongsToMany.foreignKey]: instance.get(belongsToMany.sourceKey),
+          [belongsToMany.otherKey]: options.sourceModel.get(belongsToMany.targetKey),
+        };
+
+        await throughModel.update(values[throughModel.name], {
+          where,
+          context: options.context,
+          transaction,
+        });
+      }
     }
-  }
 
-  if (newTransaction) {
-    await transaction.commit();
+    if (newTransaction) {
+      await transaction.commit();
+    }
+  } catch (error) {
+    if (newTransaction) {
+      await transaction.rollback();
+    }
+    throw error;
   }
 }
 
@@ -251,7 +258,11 @@ export async function updateSingleAssociation(
     return false;
   }
 
-  const { context, updateAssociationValues = [], transaction = await model.sequelize.transaction() } = options;
+  if (Array.isArray(value)) {
+    throw new Error(`The value of '${key}' cannot be in array format`);
+  }
+
+  const { context, updateAssociationValues = [], transaction } = options;
   const keys = getKeysByPrefix(updateAssociationValues, key);
 
   try {
@@ -261,9 +272,6 @@ export async function updateSingleAssociation(
     const removeAssociation = async () => {
       await model[setAccessor](null, { transaction });
       model.setDataValue(key, null);
-      if (!options.transaction) {
-        await transaction.commit();
-      }
       return true;
     };
 
@@ -273,19 +281,12 @@ export async function updateSingleAssociation(
 
     if (isStringOrNumber(value)) {
       await model[setAccessor](value, { context, transaction });
-      if (!options.transaction) {
-        await transaction.commit();
-      }
       return true;
     }
 
     if (value instanceof Model) {
       await model[setAccessor](value, { context, transaction });
       model.setDataValue(key, value);
-
-      if (!options.transaction) {
-        await transaction.commit();
-      }
       return true;
     }
 
@@ -323,9 +324,6 @@ export async function updateSingleAssociation(
           updateAssociationValues: keys,
         });
         model.setDataValue(key, instance);
-        if (!options.transaction) {
-          await transaction.commit();
-        }
         return true;
       }
     }
@@ -342,13 +340,7 @@ export async function updateSingleAssociation(
     if (association.targetKey) {
       model.setDataValue(association.foreignKey, instance[dataKey]);
     }
-    if (!options.transaction) {
-      await transaction.commit();
-    }
   } catch (error) {
-    if (!options.transaction) {
-      await transaction.rollback();
-    }
     throw error;
   }
 }
@@ -376,7 +368,7 @@ export async function updateMultipleAssociation(
     return false;
   }
 
-  const { context, updateAssociationValues = [], transaction = await model.sequelize.transaction() } = options;
+  const { context, updateAssociationValues = [], transaction } = options;
   const keys = getKeysByPrefix(updateAssociationValues, key);
 
   try {
@@ -467,11 +459,7 @@ export async function updateMultipleAssociation(
     }
 
     model.setDataValue(key, list1.concat(list3));
-    if (!options.transaction) {
-      await transaction.commit();
-    }
   } catch (error) {
-    await transaction.rollback();
     throw error;
   }
 }

package/src/utils.ts

@@ -0,0 +1,71 @@
+import crypto from 'crypto';
+import { Model } from './model';
+import { IdentifierError } from './errors/identifier-error';
+
+type HandleAppendsQueryOptions = {
+  templateModel: any;
+  queryPromises: Array<any>;
+};
+
+export async function handleAppendsQuery(options: HandleAppendsQueryOptions) {
+  const { templateModel, queryPromises } = options;
+
+  const primaryKey = templateModel.constructor.primaryKeyAttribute;
+
+  const results = await Promise.all(queryPromises);
+
+  let rows: Array<Model>;
+
+  for (const appendedResult of results) {
+    if (!rows) {
+      rows = appendedResult.rows;
+
+      if (rows.length == 0) {
+        return [];
+      }
+
+      const modelOptions = templateModel['_options'];
+      for (const row of rows) {
+        row['_options'] = {
+          ...row['_options'],
+          include: modelOptions['include'],
+          includeNames: modelOptions['includeNames'],
+          includeMap: modelOptions['includeMap'],
+        };
+      }
+      continue;
+    }
+
+    for (let i = 0; i < appendedResult.rows.length; i++) {
+      const appendingRow = appendedResult.rows[i];
+      const key = appendedResult.include.association;
+      const val = appendingRow.get(key);
+
+      const rowKey = appendingRow.get(primaryKey);
+
+      const targetIndex = rows.findIndex((row) => row.get(primaryKey) === rowKey);
+
+      if (targetIndex === -1) {
+        throw new Error('target row not found');
+      }
+
+      rows[targetIndex].set(key, val, {
+        raw: true,
+      });
+    }
+  }
+
+  return rows;
+}
+
+export function md5(value: string) {
+  return crypto.createHash('md5').update(value).digest('hex');
+}
+
+const MAX_IDENTIFIER_LENGTH = 63;
+
+export function checkIdentifier(value: string) {
+  if (value.length > MAX_IDENTIFIER_LENGTH) {
+    throw new IdentifierError(`Identifier ${value} is too long`);
+  }
+}