@nocobase/database 1.3.44-beta → 1.4.0-alpha.0

package/lib/options-parser.d.ts

@@ -26,6 +26,7 @@ export declare class OptionsParser {
     static appendInheritInspectAttribute(include: any, collection: any): any;
     isAssociation(key: string): boolean;
     isAssociationPath(path: string): boolean;
+    filterByTkToWhereOption(): {};
     toSequelizeParams(): any;
     /**
      * parser sort options

package/lib/options-parser.js

@@ -90,17 +90,34 @@ const _OptionsParser = class _OptionsParser {
   isAssociationPath(path) {
     return this.isAssociation(path.split(".")[0]);
   }
+  filterByTkToWhereOption() {
+    var _a;
+    const filterByTkOption = (_a = this.options) == null ? void 0 : _a.filterByTk;
+    if (!filterByTkOption) {
+      return {};
+    }
+    if (import_lodash.default.isPlainObject(this.options.filterByTk)) {
+      const where = {};
+      for (const [key, value] of Object.entries(filterByTkOption)) {
+        where[key] = value;
+      }
+      return where;
+    }
+    const filterTargetKey = this.context.targetKey || this.collection.filterTargetKey;
+    if (Array.isArray(filterTargetKey)) {
+      throw new Error("multi filter target key value must be object");
+    }
+    return {
+      [filterTargetKey]: filterByTkOption
+    };
+  }
   toSequelizeParams() {
     var _a, _b;
     const queryParams = this.filterParser.toSequelizeParams();
     if ((_a = this.options) == null ? void 0 : _a.filterByTk) {
+      const filterByTkWhere = this.filterByTkToWhereOption();
       queryParams.where = {
-        [import_sequelize.Op.and]: [
-          queryParams.where,
-          {
-            [this.context.targetKey || this.collection.filterTargetKey]: this.options.filterByTk
-          }
-        ]
+        [import_sequelize.Op.and]: [queryParams.where, filterByTkWhere]
       };
     }
     if ((_b = this.options) == null ? void 0 : _b.include) {
@@ -123,12 +140,18 @@ const _OptionsParser = class _OptionsParser {
       sort = sort.split(",");
     }
     let defaultSortField = this.model.primaryKeyAttribute;
-    if (!defaultSortField && this.collection.filterTargetKey) {
+    if (Array.isArray(this.collection.filterTargetKey)) {
+      defaultSortField = this.collection.filterTargetKey;
+    }
+    if (!defaultSortField && this.collection.filterTargetKey && !Array.isArray(this.collection.filterTargetKey)) {
       defaultSortField = this.collection.filterTargetKey;
     }
     if (defaultSortField && !((_b = this.options) == null ? void 0 : _b.group)) {
-      if (!sort.includes(defaultSortField)) {
-        sort.push(defaultSortField);
+      defaultSortField = import_lodash.default.castArray(defaultSortField);
+      for (const key of defaultSortField) {
+        if (!sort.includes(key)) {
+          sort.push(key);
+        }
       }
     }
     const orderParams = [];
@@ -151,7 +174,10 @@ const _OptionsParser = class _OptionsParser {
       }
       sortField.push(direction);
       if (this.database.isMySQLCompatibleDialect()) {
-        orderParams.push([import_sequelize.Sequelize.fn("ISNULL", import_sequelize.Sequelize.col(`${this.model.name}.${sortField[0]}`))]);
+        const fieldName = sortField[0];
+        if (this.model.fieldRawAttributesMap[fieldName]) {
+          orderParams.push([import_sequelize.Sequelize.fn("ISNULL", import_sequelize.Sequelize.col(`${this.model.name}.${sortField[0]}`))]);
+        }
       }
       orderParams.push(sortField);
     }

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

@@ -50,6 +50,9 @@ function buildQueryInterface(db) {
     postgres: import_postgres_query_interface.default,
     sqlite: import_sqlite_query_interface.default
   };
+  if (db.isPostgresCompatibleDialect()) {
+    return new import_postgres_query_interface.default(db);
+  }
   const dialect = db.options.dialect;
   if (!map[dialect]) {
     return null;

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

@@ -45,29 +45,26 @@ var import_relation_repository = require("./relation-repository");
 const _HasManyRepository = class _HasManyRepository extends import_multiple_relation_repository.MultipleRelationRepository {
   async find(options) {
     const targetRepository = this.targetCollection.repository;
-    const addFilter = {
-      [this.association.foreignKey]: this.sourceKeyValue
-    };
-    if (options == null ? void 0 : options.filterByTk) {
-      addFilter[this.associationField.targetKey] = options.filterByTk;
+    const targetFilterOptions = await this.targetRepositoryFilterOptionsBySourceValue();
+    const findOptionsOmit = ["where", "values", "attributes"];
+    if ((options == null ? void 0 : options.filterByTk) && !this.isMultiTargetKey(options.filterByTk)) {
+      targetFilterOptions[this.associationField.targetKey] = options.filterByTk;
+      findOptionsOmit.push("filterByTk");
     }
     const findOptions = {
-      ...(0, import_lodash.omit)(options, ["filterByTk", "where", "values", "attributes"]),
+      ...(0, import_lodash.omit)(options, findOptionsOmit),
       filter: {
-        $and: [options.filter || {}, addFilter]
+        $and: [(options == null ? void 0 : options.filter) || {}, targetFilterOptions]
       }
     };
     return await targetRepository.find(findOptions);
   }
   async aggregate(options) {
     const targetRepository = this.targetCollection.repository;
-    const addFilter = {
-      [this.association.foreignKey]: this.sourceKeyValue
-    };
     const aggOptions = {
       ...options,
       filter: {
-        $and: [options.filter || {}, addFilter]
+        $and: [options.filter || {}, await this.targetRepositoryFilterOptionsBySourceValue()]
       }
     };
     return await targetRepository.aggregate(aggOptions);

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

@@ -14,6 +14,7 @@ export interface AssociatedOptions extends Transactionable {
     tk?: TK;
 }
 export declare abstract class MultipleRelationRepository extends RelationRepository {
+    targetRepositoryFilterOptionsBySourceValue(): Promise<any>;
     find(options?: FindOptions): Promise<any>;
     findAndCount(options?: FindAndCountOptions): Promise<[any[], number]>;
     count(options?: CountOptions): Promise<number>;

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

@@ -55,6 +55,16 @@ var import_update_associations = require("../update-associations");
 var import_update_guard = require("../update-guard");
 var import_relation_repository = require("./relation-repository");
 const _MultipleRelationRepository = class _MultipleRelationRepository extends import_relation_repository.RelationRepository {
+  async targetRepositoryFilterOptionsBySourceValue() {
+    let filterForeignKeyValue = this.sourceKeyValue;
+    if (this.isMultiTargetKey()) {
+      const sourceModel = await this.getSourceModel();
+      filterForeignKeyValue = sourceModel.get(this.association.sourceKey);
+    }
+    return {
+      [this.association.foreignKey]: filterForeignKeyValue
+    };
+  }
   async find(options) {
     const targetRepository = this.targetCollection.repository;
     const association = this.association;
@@ -68,9 +78,7 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
     const appendFilter = {
       isPivotFilter: true,
       association: pivotAssoc,
-      where: {
-        [association.foreignKey]: this.sourceKeyValue
-      }
+      where: await this.targetRepositoryFilterOptionsBySourceValue()
     };
     return targetRepository.find({
       include: [appendFilter],

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

@@ -11,7 +11,7 @@ import { Collection } from '../collection';
 import Database from '../database';
 import { RelationField } from '../fields/relation-field';
 import { Model } from '../model';
-import { CreateOptions, Filter, FindOptions } from '../repository';
+import { CreateOptions, Filter, FindOptions, TargetKey } from '../repository';
 export declare const transaction: (transactionInjector?: any) => (target: any, name: any, descriptor: any) => any;
 export declare abstract class RelationRepository {
     sourceCollection: Collection;
@@ -20,11 +20,14 @@ export declare abstract class RelationRepository {
     targetCollection: Collection;
     associationName: string;
     associationField: RelationField;
-    sourceKeyValue: string | number;
+    sourceKeyValue: TargetKey;
     sourceInstance: Model;
     db: Database;
     database: Database;
-    constructor(sourceCollection: Collection, association: string, sourceKeyValue: string | number);
+    constructor(sourceCollection: Collection, association: string, sourceKeyValue: TargetKey);
+    decodeMultiTargetKey(str: string): any;
+    setSourceKeyValue(sourceKeyValue: TargetKey): void;
+    isMultiTargetKey(value?: any): boolean;
     get collection(): Collection<any, any>;
     abstract find(options?: FindOptions): Promise<any>;
     chunk(options: FindOptions & {

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

@@ -73,13 +73,27 @@ const _RelationRepository = class _RelationRepository {
     this.db = sourceCollection.context.database;
     this.database = this.db;
     this.sourceCollection = sourceCollection;
-    this.sourceKeyValue = sourceKeyValue;
+    this.setSourceKeyValue(sourceKeyValue);
     this.associationName = association;
     this.association = this.sourceCollection.model.associations[association];
     this.associationField = this.sourceCollection.getField(association);
     this.targetModel = this.association.target;
     this.targetCollection = this.sourceCollection.context.database.modelCollection.get(this.targetModel);
   }
+  decodeMultiTargetKey(str) {
+    try {
+      const decoded = decodeURIComponent(str);
+      return JSON.parse(decoded);
+    } catch (e) {
+      return false;
+    }
+  }
+  setSourceKeyValue(sourceKeyValue) {
+    this.sourceKeyValue = typeof sourceKeyValue === "string" ? this.decodeMultiTargetKey(sourceKeyValue) || sourceKeyValue : sourceKeyValue;
+  }
+  isMultiTargetKey(value) {
+    return import_lodash.default.isPlainObject(value || this.sourceKeyValue);
+  }
   get collection() {
     return this.db.getCollection(this.targetModel.name);
   }
@@ -109,7 +123,7 @@ const _RelationRepository = class _RelationRepository {
   }
   convertTk(options) {
     let tk = options;
-    if (typeof options === "object" && options["tk"]) {
+    if (typeof options === "object" && "tk" in options) {
       tk = options["tk"];
     }
     return tk;
@@ -119,7 +133,10 @@ const _RelationRepository = class _RelationRepository {
     if (typeof tk === "string") {
       tk = tk.split(",");
     }
-    return import_lodash.default.castArray(tk);
+    if (tk) {
+      return import_lodash.default.castArray(tk);
+    }
+    return [];
   }
   targetKey() {
     return this.associationField.targetKey;
@@ -147,7 +164,13 @@ const _RelationRepository = class _RelationRepository {
   }
   async getSourceModel(transaction2) {
     if (!this.sourceInstance) {
-      this.sourceInstance = await this.sourceCollection.model.findOne({
+      this.sourceInstance = this.isMultiTargetKey() ? await this.sourceCollection.repository.findOne({
+        filter: {
+          // @ts-ignore
+          ...this.sourceKeyValue
+        },
+        transaction: transaction2
+      }) : await this.sourceCollection.model.findOne({
         where: {
           [this.associationField.sourceKey]: this.sourceKeyValue
         },

package/lib/repository.d.ts

@@ -26,7 +26,9 @@ export { Transactionable } from 'sequelize';
 export interface FilterAble {
     filter: Filter;
 }
-export type TargetKey = string | number;
+export type BaseTargetKey = string | number;
+export type MultiTargetKey = Record<string, BaseTargetKey>;
+export type TargetKey = BaseTargetKey | MultiTargetKey;
 export type TK = TargetKey | TargetKey[];
 type FieldValue = string | number | bigint | boolean | Date | Buffer | null | FieldValue[] | FilterWithOperator;
 type Operators = keyof typeof operators & keyof WhereOperators;
@@ -116,7 +118,7 @@ declare class RelationRepositoryBuilder<R extends RelationRepository> {
         BelongsToArray: typeof BelongsToArrayRepository;
     };
     constructor(collection: Collection, associationName: string);
-    of(id: string | number): R;
+    of(id: TargetKey): R;
     protected builder(): {
         HasOne: typeof HasOneRepository;
         BelongsTo: typeof BelongsToRepository;
@@ -171,6 +173,7 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      *
      */
     findById(id: string | number): Promise<Model<any, any>>;
+    findByTargetKey(targetKey: TargetKey): Promise<any>;
     /**
      * Find one record from database
      *

package/lib/repository.js

@@ -175,27 +175,24 @@ const _Repository = class _Repository {
       };
     }
     if (countOptions == null ? void 0 : countOptions.filterByTk) {
+      const optionParser = new import_options_parser.OptionsParser(options, {
+        collection: this.collection
+      });
       options["where"] = {
-        [import_sequelize.Op.and]: [
-          options["where"] || {},
-          {
-            [this.collection.filterTargetKey]: options.filterByTk
-          }
-        ]
+        [import_sequelize.Op.and]: [options["where"] || {}, optionParser.filterByTkToWhereOption()]
       };
     }
     const queryOptions = {
       ...options,
-      distinct: Boolean(this.collection.model.primaryKeyAttribute)
+      distinct: Boolean(this.collection.model.primaryKeyAttribute) && !this.collection.isMultiFilterTargetKey()
     };
     if (((_a = queryOptions.include) == null ? void 0 : _a.length) === 0) {
       delete queryOptions.include;
     }
-    const count = await this.collection.model.count({
+    return await this.collection.model.count({
       ...queryOptions,
       transaction: transaction2
     });
-    return count;
   }
   async aggregate(options) {
     var _a;
@@ -325,6 +322,9 @@ const _Repository = class _Repository {
   findById(id) {
     return this.collection.model.findByPk(id);
   }
+  findByTargetKey(targetKey) {
+    return this.findOne({ filterByTk: targetKey });
+  }
   /**
    * Find one record from database
    *
@@ -374,7 +374,7 @@ const _Repository = class _Repository {
       action: "create",
       underscored: this.collection.options.underscored
     });
-    const values = guard.sanitize(options.values || {});
+    const values = this.model.callSetters(guard.sanitize(options.values || {}), options);
     const instance = await this.model.create(values, {
       ...options,
       transaction: transaction2
@@ -418,7 +418,7 @@ const _Repository = class _Repository {
     }
     const transaction2 = await this.getTransaction(options);
     const guard = import_update_guard.UpdateGuard.fromOptions(this.model, { ...options, underscored: this.collection.options.underscored });
-    const values = guard.sanitize(options.values);
+    const values = this.model.callSetters(guard.sanitize(options.values || {}), options);
     if (options.individualHooks === false) {
       const { model: Model2 } = this.collection;
       const primaryKeyField = Model2.primaryKeyField || Model2.primaryKeyAttribute;
@@ -501,15 +501,26 @@ const _Repository = class _Repository {
       }
     }
     if (filterByTk && !options.filter) {
-      return await this.model.destroy({
+      const where = [];
+      for (const tk of filterByTk) {
+        const optionParser = new import_options_parser.OptionsParser(
+          {
+            filterByTk: tk
+          },
+          {
+            collection: this.collection
+          }
+        );
+        where.push(optionParser.filterByTkToWhereOption());
+      }
+      const destroyOptions = {
         ...options,
         where: {
-          [modelFilterKey]: {
-            [import_sequelize.Op.in]: filterByTk
-          }
+          [import_sequelize.Op.or]: where
         },
         transaction: transaction2
-      });
+      };
+      return await this.model.destroy(destroyOptions);
     }
     if (options.filter && (0, import_utils.isValidFilter)(options.filter)) {
       if (this.collection.model.primaryKeyAttributes.length !== 1 && !import_lodash.default.get(this.collection.options, "filterTargetKey")) {

package/lib/update-associations.d.ts

@@ -8,6 +8,7 @@
  */
 import { Association, BelongsToMany, Hookable, Transactionable } from 'sequelize';
 import { Model } from './model';
+import { TargetKey } from './repository';
 export declare function modelAssociations(instance: Model): {
     [key: string]: Association<import("sequelize").Model<any, any>, import("sequelize").Model<any, any>>;
 };
@@ -18,7 +19,7 @@ type UpdateValue = {
 };
 interface UpdateOptions extends Transactionable {
     filter?: any;
-    filterByTk?: number | string;
+    filterByTk?: TargetKey;
     whitelist?: string[];
     blacklist?: string[];
     updateAssociationValues?: string[];

package/lib/update-associations.js

@@ -323,7 +323,7 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
     } else if (item.sequelize) {
       setItems.push(item);
     } else if (typeof item === "object") {
-      const targetKey2 = association.targetKey || "id";
+      const targetKey2 = association.targetKey || association.options.targetKey || "id";
       if (item[targetKey2]) {
         const attributes = {
           [targetKey2]: item[targetKey2]
@@ -337,9 +337,9 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
   await model[setAccessor](setItems, { transaction, context, individualHooks: true });
   const newItems = [];
   const pk = association.target.primaryKeyAttribute;
-  const tmpKey = (_a = association["options"]) == null ? void 0 : _a["targetKey"];
   let targetKey = pk;
   const db = model.constructor["database"];
+  const tmpKey = (_a = association["options"]) == null ? void 0 : _a["targetKey"];
   if (tmpKey !== pk) {
     const targetKeyFieldOptions = (_b = db.getFieldByPath(`${association.target.name}.${tmpKey}`)) == null ? void 0 : _b.options;
     if (targetKeyFieldOptions == null ? void 0 : targetKeyFieldOptions.unique) {
@@ -405,7 +405,8 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
     }
   }
   for (const newItem of newItems) {
-    const existIndexInSetItems = setItems.findIndex((setItem) => setItem[targetKey] === newItem[targetKey]);
+    const findTargetKey = association.targetKey || association.options.targetKey || targetKey;
+    const existIndexInSetItems = setItems.findIndex((setItem) => setItem[findTargetKey] === newItem[findTargetKey]);
     if (existIndexInSetItems !== -1) {
       setItems[existIndexInSetItems] = newItem;
     } else {

package/lib/view/field-type-map.d.ts

@@ -62,7 +62,7 @@ declare const fieldTypeMap: {
         boolean: string;
         decimal: string;
         year: string[];
-        datetime: string;
+        datetime: string[];
         timestamp: string;
         json: string[];
         enum: string;
@@ -104,7 +104,7 @@ declare const fieldTypeMap: {
         boolean: string;
         decimal: string;
         year: string[];
-        datetime: string;
+        datetime: string[];
         timestamp: string;
         json: string[];
         enum: string;

package/lib/view/field-type-map.js

@@ -30,24 +30,24 @@ __export(field_type_map_exports, {
 });
 module.exports = __toCommonJS(field_type_map_exports);
 const postgres = {
-  "character varying": ["string", "uuid", "nanoid", "encryption"],
-  varchar: ["string", "uuid", "nanoid", "encryption"],
-  char: ["string", "uuid", "nanoid", "encryption"],
+  "character varying": ["string", "uuid", "nanoid", "encryption", "datetimeNoTz"],
+  varchar: ["string", "uuid", "nanoid", "encryption", "datetimeNoTz"],
+  char: ["string", "uuid", "nanoid", "encryption", "datetimeNoTz"],
   character: "string",
   text: "text",
   oid: "string",
   name: "string",
   smallint: ["integer", "sort"],
-  integer: ["integer", "sort"],
-  bigint: ["bigInt", "sort"],
+  integer: ["integer", "unixTimestamp", "sort"],
+  bigint: ["bigInt", "unixTimestamp", "sort"],
   decimal: "decimal",
   numeric: "float",
   real: "float",
   "double precision": "float",
-  "timestamp without time zone": "date",
-  "timestamp with time zone": "date",
+  "timestamp without time zone": "datetimeNoTz",
+  "timestamp with time zone": "datetimeTz",
   "time without time zone": "time",
-  date: "date",
+  date: "dateOnly",
   boolean: "boolean",
   json: ["json", "array"],
   jsonb: ["json", "array", "jsonb"],
@@ -68,24 +68,24 @@ const mysql = {
   "mediumint unsigned": ["integer", "boolean", "sort"],
   char: ["string", "uuid", "nanoid", "encryption"],
   varchar: ["string", "uuid", "nanoid", "encryption"],
-  date: "date",
+  date: "dateOnly",
   time: "time",
   tinytext: "text",
   text: "text",
   mediumtext: "text",
   longtext: "text",
-  int: ["integer", "sort"],
-  "int unsigned": ["integer", "sort"],
-  integer: ["integer", "sort"],
-  bigint: ["bigInt", "sort"],
-  "bigint unsigned": ["bigInt", "sort"],
+  int: ["integer", "unixTimestamp", "sort"],
+  "int unsigned": ["integer", "unixTimestamp", "sort"],
+  integer: ["integer", "unixTimestamp", "sort"],
+  bigint: ["bigInt", "unixTimestamp", "sort"],
+  "bigint unsigned": ["bigInt", "unixTimestamp", "sort"],
   float: "float",
   double: "float",
   boolean: "boolean",
   decimal: "decimal",
   year: ["string", "integer"],
-  datetime: "date",
-  timestamp: "date",
+  datetime: ["datetimeNoTz", "datetimeTz"],
+  timestamp: "datetimeTz",
   json: ["json", "array"],
   enum: "string"
 };
@@ -94,7 +94,7 @@ const sqlite = {
   varchar: ["string", "uuid", "nanoid", "encryption"],
   integer: "integer",
   real: "real",
-  datetime: "date",
+  datetime: "datetimeTz",
   date: "date",
   time: "time",
   boolean: "boolean",

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "1.3.44-beta",
+  "version": "1.4.0-alpha.0",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
   "dependencies": {
-    "@nocobase/logger": "1.3.44-beta",
-    "@nocobase/utils": "1.3.44-beta",
+    "@nocobase/logger": "1.4.0-alpha.0",
+    "@nocobase/utils": "1.4.0-alpha.0",
     "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": "1d5666123ac1e2997e434e38defef963ba0d9f90"
+  "gitHead": "8ffa7b54bbaf720c0c9857da4b19a99110dffc4b"
 }