@nocobase/database 1.7.0-beta.12 → 1.7.0-beta.14

package/lib/belongs-to-array/belongs-to-array-repository.d.ts

@@ -31,8 +31,8 @@ export declare class BelongsToArrayAssociation {
         targetKey: string;
     });
     get target(): import("sequelize/types").ModelStatic<Model<any, any>>;
-    generateInclude(): {
-        on: import("sequelize/types/utils").Literal;
+    generateInclude(parentAs?: string): {
+        on: void;
     };
     update(instance: Model, value: any, options?: UpdateAssociationOptions): Promise<void>;
 }

package/lib/belongs-to-array/belongs-to-array-repository.js

@@ -78,19 +78,18 @@ const _BelongsToArrayAssociation = class _BelongsToArrayAssociation {
   get target() {
     return this.db.getModel(this.targetName);
   }
-  generateInclude() {
-    if (this.db.sequelize.getDialect() !== "postgres") {
-      throw new Error("Filtering by many to many (array) associations is only supported on postgres");
-    }
+  generateInclude(parentAs) {
     const targetCollection = this.db.getCollection(this.targetName);
     const targetField = targetCollection.getField(this.targetKey);
     const sourceCollection = this.db.getCollection(this.source.name);
     const foreignField = sourceCollection.getField(this.foreignKey);
     const queryInterface = this.db.sequelize.getQueryInterface();
-    const left = queryInterface.quoteIdentifiers(`${this.as}.${targetField.columnName()}`);
-    const right = queryInterface.quoteIdentifiers(`${this.source.collection.name}.${foreignField.columnName()}`);
+    const asLeft = parentAs ? `${parentAs}->${this.as}` : this.as;
+    const asRight = parentAs || this.source.collection.name;
+    const left = queryInterface.quoteIdentifiers(`${asLeft}.${targetField.columnName()}`);
+    const right = queryInterface.quoteIdentifiers(`${asRight}.${foreignField.columnName()}`);
     return {
-      on: this.db.sequelize.literal(`${left}=any(${right})`)
+      on: this.db.queryInterface.generateJoinOnForJSONArray(left, right)
     };
   }
   async update(instance, value, options = {}) {

package/lib/eager-loading/eager-loading-tree.js

@@ -85,6 +85,25 @@ const queryParentSQL = /* @__PURE__ */ __name((options) => {
       )
       SELECT ${q(targetKeyField)} AS ${q(targetKey)}, ${q(foreignKeyField)} AS ${q(foreignKey)} FROM cte`;
 }, "queryParentSQL");
+const processIncludes = /* @__PURE__ */ __name((includes, model, parentAs = "") => {
+  includes.forEach((include, index) => {
+    const association = model.associations[include.association];
+    if (association == null ? void 0 : association.generateInclude) {
+      includes[index] = {
+        ...include,
+        ...association.generateInclude(parentAs)
+      };
+    }
+    if (include.include && Array.isArray(include.include) && include.include.length > 0) {
+      const nextModel = association == null ? void 0 : association.target;
+      if (!nextModel) {
+        return;
+      }
+      processIncludes(include.include, nextModel, parentAs ? `${parentAs}->${association.as}` : association.as);
+    }
+  });
+  return includes;
+}, "processIncludes");
 const _EagerLoadingTree = class _EagerLoadingTree {
   root;
   db;
@@ -208,22 +227,13 @@ const _EagerLoadingTree = class _EagerLoadingTree {
           if (!primaryKeyField) {
             throw new Error(`Model ${node.model.name} does not have primary key`);
           }
-          includeForFilter.forEach((include, index) => {
-            const association = node.model.associations[include.association];
-            if ((association == null ? void 0 : association.associationType) == "BelongsToArray") {
-              includeForFilter[index] = {
-                ...include,
-                ...association.generateInclude()
-              };
-            }
-          });
           const ids2 = (await node.model.findAll({
             ...this.rootQueryOptions,
             includeIgnoreAttributes: false,
             attributes: [primaryKeyField],
             group: `${node.model.name}.${primaryKeyField}`,
             transaction,
-            include: includeForFilter
+            include: processIncludes(includeForFilter, node.model)
           })).map((row) => {
             return { row, pk: row[primaryKeyField] };
           });

package/lib/fields/datetime-no-tz-field.d.ts

@@ -13,7 +13,7 @@ declare class DatetimeNoTzTypeMySQL extends DataTypes.ABSTRACT {
 }
 export declare class DatetimeNoTzField extends Field {
     get dataType(): typeof DatetimeNoTzTypeMySQL;
-    init(): void;
+    beforeSave: (instance: any, options: any) => Promise<void>;
     additionalSequelizeOptions(): {};
     bind(): void;
     unbind(): void;

package/lib/fields/datetime-no-tz-field.js

@@ -61,48 +61,49 @@ const _DatetimeNoTzField = class _DatetimeNoTzField extends import_field.Field {
     if (this.database.isMySQLCompatibleDialect()) {
       return DatetimeNoTzTypeMySQL;
     }
-    return import_sequelize.DataTypes.STRING;
+    return import_sequelize.DataTypes.DATE;
   }
-  init() {
+  beforeSave = /* @__PURE__ */ __name(async (instance, options) => {
     const { name, defaultToCurrentTime, onUpdateToCurrentTime } = this.options;
-    this.beforeSave = async (instance, options) => {
-      const value = instance.get(name);
-      if (!value && instance.isNewRecord && defaultToCurrentTime) {
-        instance.set(name, /* @__PURE__ */ new Date());
-        return;
-      }
-      if (onUpdateToCurrentTime) {
-        instance.set(name, /* @__PURE__ */ new Date());
-        return;
-      }
-    };
-  }
+    const value = instance.get(name);
+    if (!value && instance.isNewRecord && defaultToCurrentTime) {
+      instance.set(name, /* @__PURE__ */ new Date());
+      return;
+    }
+    if (onUpdateToCurrentTime) {
+      instance.set(name, /* @__PURE__ */ new Date());
+      return;
+    }
+  }, "beforeSave");
   additionalSequelizeOptions() {
     const { name } = this.options;
     const timezone = this.database.options.rawTimezone || "+00:00";
     const isPg = this.database.inDialect("postgres");
+    const isMySQLCompatibleDialect = this.database.isMySQLCompatibleDialect();
     return {
       get() {
         const val = this.getDataValue(name);
         if (val instanceof Date) {
-          if (isPg) {
-            return (0, import_moment.default)(val).format("YYYY-MM-DD HH:mm:ss");
-          }
-          const momentVal = (0, import_moment.default)(val).utcOffset(timezone);
+          const momentVal = (0, import_moment.default)(val);
           return momentVal.format("YYYY-MM-DD HH:mm:ss");
         }
         return val;
       },
       set(val) {
-        if (typeof val === "string" && isIso8601(val)) {
-          const momentVal = (0, import_moment.default)(val).utcOffset(timezone);
-          val = momentVal.format("YYYY-MM-DD HH:mm:ss");
+        if (val == null) {
+          return this.setDataValue(name, null);
+        }
+        const dateOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+        const momentVal = (0, import_moment.default)(val);
+        if (typeof val === "string" && isIso8601(val) || val instanceof Date) {
+          momentVal.utcOffset(timezone);
+          momentVal.utcOffset(-dateOffset, true);
         }
-        if (val && val instanceof Date) {
-          const momentVal = (0, import_moment.default)(val).utcOffset(timezone);
-          val = momentVal.format("YYYY-MM-DD HH:mm:ss");
+        if (isMySQLCompatibleDialect) {
+          momentVal.millisecond(0);
         }
-        return this.setDataValue(name, val);
+        const date = momentVal.toDate();
+        return this.setDataValue(name, date);
       }
     };
   }

package/lib/fields/string-field.d.ts

@@ -10,8 +10,12 @@ import { DataTypes } from 'sequelize';
 import { BaseColumnFieldOptions, Field } from './field';
 export declare class StringField extends Field {
     get dataType(): DataTypes.StringDataTypeConstructor | DataTypes.StringDataType;
+    additionalSequelizeOptions(): {
+        set(value: any): void;
+    };
 }
 export interface StringFieldOptions extends BaseColumnFieldOptions {
     type: 'string';
     length?: number;
+    trim?: boolean;
 }

package/lib/fields/string-field.js

@@ -39,6 +39,14 @@ const _StringField = class _StringField extends import_field.Field {
     }
     return import_sequelize.DataTypes.STRING;
   }
+  additionalSequelizeOptions() {
+    const { name, trim } = this.options;
+    return {
+      set(value) {
+        this.setDataValue(name, trim ? value == null ? void 0 : value.trim() : value);
+      }
+    };
+  }
 };
 __name(_StringField, "StringField");
 let StringField = _StringField;

package/lib/fields/text-field.d.ts

@@ -11,8 +11,12 @@ import { BaseColumnFieldOptions, Field } from './field';
 export declare class TextField extends Field {
     get dataType(): DataTypes.TextDataTypeConstructor | DataTypes.TextDataType;
     init(): void;
+    additionalSequelizeOptions(): {
+        set(value: any): void;
+    };
 }
 export interface TextFieldOptions extends BaseColumnFieldOptions {
     type: 'text';
     length?: 'tiny' | 'medium' | 'long';
+    trim?: boolean;
 }

package/lib/fields/text-field.js

@@ -44,6 +44,14 @@ const _TextField = class _TextField extends import_field.Field {
       this.options.defaultValue = null;
     }
   }
+  additionalSequelizeOptions() {
+    const { name, trim } = this.options;
+    return {
+      set(value) {
+        this.setDataValue(name, trim ? value == null ? void 0 : value.trim() : value);
+      }
+    };
+  }
 };
 __name(_TextField, "TextField");
 let TextField = _TextField;

package/lib/query-interface/mysql-query-interface.d.ts

@@ -41,4 +41,5 @@ export default class MysqlQueryInterface extends QueryInterface {
         currentVal: number;
         transaction?: Transaction;
     }): Promise<void>;
+    generateJoinOnForJSONArray(left: string, right: string): import("sequelize/types/utils").Literal;
 }

package/lib/query-interface/mysql-query-interface.js

@@ -129,6 +129,9 @@ const _MysqlQueryInterface = class _MysqlQueryInterface extends import_query_int
       await this.db.sequelize.query(sql, { transaction });
     }
   }
+  generateJoinOnForJSONArray(left, right) {
+    return this.db.sequelize.literal(`JSON_CONTAINS(${right}, JSON_ARRAY(${left}))`);
+  }
 };
 __name(_MysqlQueryInterface, "MysqlQueryInterface");
 let MysqlQueryInterface = _MysqlQueryInterface;

package/lib/query-interface/postgres-query-interface.d.ts

@@ -38,4 +38,5 @@ export default class PostgresQueryInterface extends QueryInterface {
         };
     }>;
     showTableDefinition(tableInfo: TableInfo): Promise<any>;
+    generateJoinOnForJSONArray(left: string, right: string): import("sequelize/types/utils").Literal;
 }

package/lib/query-interface/postgres-query-interface.js

@@ -202,6 +202,9 @@ $BODY$
     );
     return res[0]["show_create_table"];
   }
+  generateJoinOnForJSONArray(left, right) {
+    return this.db.sequelize.literal(`${left}=any(${right})`);
+  }
 };
 __name(_PostgresQueryInterface, "PostgresQueryInterface");
 let PostgresQueryInterface = _PostgresQueryInterface;

package/lib/query-interface/query-interface.d.ts

@@ -49,4 +49,5 @@ export default abstract class QueryInterface {
         transaction?: Transaction;
     }): Promise<void>;
     quoteIdentifier(identifier: string): any;
+    generateJoinOnForJSONArray(left: string, right: string): void;
 }

package/lib/query-interface/query-interface.js

@@ -57,6 +57,10 @@ const _QueryInterface = class _QueryInterface {
   quoteIdentifier(identifier) {
     return this.db.sequelize.getQueryInterface().queryGenerator.quoteIdentifier(identifier);
   }
+  generateJoinOnForJSONArray(left, right) {
+    const dialect = this.db.sequelize.getDialect();
+    throw new Error(`Filtering by many to many (array) associations is not supported on ${dialect}`);
+  }
 };
 __name(_QueryInterface, "QueryInterface");
 let QueryInterface = _QueryInterface;

package/lib/query-interface/sqlite-query-interface.d.ts

@@ -41,4 +41,5 @@ export default class SqliteQueryInterface extends QueryInterface {
         currentVal: number;
         transaction?: Transaction;
     }): Promise<void>;
+    generateJoinOnForJSONArray(left: string, right: string): import("sequelize/types/utils").Literal;
 }

package/lib/query-interface/sqlite-query-interface.js

@@ -136,6 +136,9 @@ const _SqliteQueryInterface = class _SqliteQueryInterface extends import_query_i
                  WHERE name = '${tableName}';`;
     await this.db.sequelize.query(sql, { transaction });
   }
+  generateJoinOnForJSONArray(left, right) {
+    return this.db.sequelize.literal(`${left} in (SELECT value from json_each(${right}))`);
+  }
 };
 __name(_SqliteQueryInterface, "SqliteQueryInterface");
 let SqliteQueryInterface = _SqliteQueryInterface;

package/lib/relation-repository/hasmany-repository.js

@@ -80,7 +80,13 @@ const _HasManyRepository = class _HasManyRepository extends import_multiple_rela
     if (options && options["filter"]) {
       const filterResult = this.parseFilter(options["filter"], options);
       if (filterResult.include && filterResult.include.length > 0) {
-        return await this.destroyByFilter(options["filter"], transaction2);
+        return await this.destroyByFilter(
+          {
+            filter: options["filter"],
+            filterByTk: options["filterByTk"]
+          },
+          transaction2
+        );
       }
       where.push(filterResult.where);
     }

package/lib/relation-repository/multiple-relation-repository.d.ts

@@ -18,7 +18,10 @@ export declare abstract class MultipleRelationRepository extends RelationReposit
     remove(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
     update(options?: UpdateOptions): Promise<any>;
     destroy(options?: TargetKey | DestroyOptions): Promise<boolean>;
-    protected destroyByFilter(filter: Filter, transaction?: Transaction): Promise<boolean>;
+    protected destroyByFilter(options: {
+        filter?: Filter;
+        filterByTk?: TargetKey | TargetKey[];
+    }, transaction?: Transaction): Promise<boolean>;
     protected filterHasInclude(filter: Filter, options?: any): boolean;
     protected accessors(): MultiAssociationAccessors;
     updateOrCreate(options: FirstOrCreateOptions): Promise<any>;

package/lib/relation-repository/multiple-relation-repository.js

@@ -174,9 +174,9 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
   async destroy(options) {
     return false;
   }
-  async destroyByFilter(filter, transaction2) {
+  async destroyByFilter(options, transaction2) {
     const instances = await this.find({
-      filter,
+      ...options,
       transaction: transaction2
     });
     return await this.destroy({

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "1.7.0-beta.12",
+  "version": "1.7.0-beta.14",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
   "dependencies": {
-    "@nocobase/logger": "1.7.0-beta.12",
-    "@nocobase/utils": "1.7.0-beta.12",
+    "@nocobase/logger": "1.7.0-beta.14",
+    "@nocobase/utils": "1.7.0-beta.14",
     "async-mutex": "^0.3.2",
     "chalk": "^4.1.1",
     "cron-parser": "4.4.0",
@@ -38,5 +38,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "db80012c1561bd9391cd83b5aef57fd79445da8e"
+  "gitHead": "9e557ad4739803ca87d54f279c90ff69511ccdee"
 }