@nocobase/database 1.6.0-alpha.1 → 1.6.0-alpha.11

package/lib/collection.d.ts

@@ -29,15 +29,18 @@ export type DumpRules = BuiltInGroup | ({
 } & BaseDumpRules) | ({
     group: BuiltInGroup | string;
 } & BaseDumpRules);
+export type MigrationRule = 'overwrite' | 'skip' | 'upsert' | 'schema-only' | 'insert-ignore';
 export interface CollectionOptions extends Omit<ModelOptions, 'name' | 'hooks'> {
     name: string;
     title?: string;
     namespace?: string;
+    migrationRules?: MigrationRule[];
     dumpRules?: DumpRules;
     tableName?: string;
     inherits?: string[] | string;
     viewName?: string;
     writableView?: boolean;
+    isThrough?: boolean;
     filterTargetKey?: string | string[];
     fields?: FieldOptions[];
     model?: string | ModelStatic<Model>;

package/lib/database.js

@@ -220,6 +220,7 @@ const _Database = class _Database extends import_events.EventEmitter {
       autoGenId: false,
       timestamps: false,
       dumpRules: "required",
+      migrationRules: ["schema-only", "overwrite", "skip"],
       origin: "@nocobase/database",
       fields: [{ type: "string", name: "name", primaryKey: true }]
     });

package/lib/dialects/mysql-dialect.d.ts

@@ -14,4 +14,5 @@ export declare class MysqlDialect extends BaseDialect {
         get: (v: string) => string;
         version: string;
     };
+    getSequelizeOptions(options: any): any;
 }

package/lib/dialects/mysql-dialect.js

@@ -32,6 +32,7 @@ __export(mysql_dialect_exports, {
   MysqlDialect: () => MysqlDialect
 });
 module.exports = __toCommonJS(mysql_dialect_exports);
+var import_utils = require("@nocobase/utils");
 var import_base_dialect = require("./base-dialect");
 const _MysqlDialect = class _MysqlDialect extends import_base_dialect.BaseDialect {
   getVersionGuard() {
@@ -44,6 +45,10 @@ const _MysqlDialect = class _MysqlDialect extends import_base_dialect.BaseDialec
       version: ">=8.0.17"
     };
   }
+  getSequelizeOptions(options) {
+    import_utils.lodash.set(options, "dialectOptions.multipleStatements", true);
+    return options;
+  }
 };
 __name(_MysqlDialect, "MysqlDialect");
 __publicField(_MysqlDialect, "dialectName", "mysql");

package/lib/fields/belongs-to-many-field.js

@@ -125,7 +125,10 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
       Through = database.getCollection(through);
     } else {
       const throughCollectionOptions = {
-        name: through
+        name: through,
+        isThrough: true,
+        sourceCollectionName: this.collection.name,
+        targetCollectionName: this.target
       };
       if (this.collection.options.dumpRules) {
         throughCollectionOptions["dumpRules"] = this.collection.options.dumpRules;

package/lib/fields/unix-timestamp-field.js

@@ -52,7 +52,7 @@ const _UnixTimestampField = class _UnixTimestampField extends import_date_field.
     if (accuracy === "millisecond") {
       rationalNumber = 1;
     }
-    return Math.floor(new Date(val).getTime() / rationalNumber);
+    return Math.floor(typeof val === "number" ? val : new Date(val).getTime() / rationalNumber);
   }
   additionalSequelizeOptions() {
     var _a, _b, _c, _d, _e;
@@ -71,16 +71,19 @@ const _UnixTimestampField = class _UnixTimestampField extends import_date_field.
     return {
       get() {
         const value = this.getDataValue(name);
-        if (value === null || value === void 0) {
+        if (value == null) {
           return value;
         }
         return new Date(value * rationalNumber);
       },
       set(value) {
-        if (value === null || value === void 0) {
+        if (value == null) {
           this.setDataValue(name, value);
         } else {
-          this.setDataValue(name, Math.floor(new Date(value).getTime() / rationalNumber));
+          this.setDataValue(
+            name,
+            Math.floor(typeof value === "number" ? value : new Date(value).getTime() / rationalNumber)
+          );
         }
       }
     };

package/lib/filter-match.js

@@ -69,7 +69,9 @@ function filterMatch(model, where) {
     $ne: /* @__PURE__ */ __name((value, condition) => value !== condition, "$ne"),
     $in: /* @__PURE__ */ __name((value, condition) => condition.includes(value), "$in"),
     $or: /* @__PURE__ */ __name((model2, conditions) => Object.values(conditions).some((condition) => filterMatch(model2, condition)), "$or"),
-    $and: /* @__PURE__ */ __name((model2, conditions) => Object.values(conditions).every((condition) => filterMatch(model2, condition)), "$and")
+    $and: /* @__PURE__ */ __name((model2, conditions) => Object.values(conditions).every((condition) => filterMatch(model2, condition)), "$and"),
+    // boolean
+    $isFalsy: /* @__PURE__ */ __name((value) => !value, "$isFalsy")
   };
   for (const [key, value] of Object.entries(where)) {
     if (operatorFunctions[key] !== void 0) {

package/lib/interfaces/datetime-interface.d.ts

@@ -8,6 +8,29 @@
  */
 import { BaseInterface } from './base-interface';
 export declare class DatetimeInterface extends BaseInterface {
+    protected parseDateString(value: string): {
+        year: string;
+        month: string;
+        day: string;
+        hour: string;
+        minute: string;
+        second: string;
+    } | {
+        year: string;
+        month: string;
+        day: string;
+        hour?: undefined;
+        minute?: undefined;
+        second?: undefined;
+    };
+    protected formatDateTimeToISO(dateInfo: {
+        year: string;
+        month: string;
+        day: string;
+        hour?: string;
+        minute?: string;
+        second?: string;
+    }): string;
     toValue(value: any, ctx?: any): Promise<any>;
     toString(value: any, ctx?: any): any;
 }

package/lib/interfaces/datetime-interface.js

@@ -62,15 +62,39 @@ function resolveTimeZoneFromCtx(ctx) {
 }
 __name(resolveTimeZoneFromCtx, "resolveTimeZoneFromCtx");
 const _DatetimeInterface = class _DatetimeInterface extends import_base_interface.BaseInterface {
+  parseDateString(value) {
+    const dateOnlyMatch = /^(\d{4})[-/]?(\d{2})[-/]?(\d{2})$/.exec(value);
+    const dateTimeMatch = /^(\d{4})(\d{2})(\d{2})\s+(\d{2}):(\d{2}):(\d{2})$/.exec(value);
+    if (dateTimeMatch) {
+      const [_, year, month, day, hour, minute, second] = dateTimeMatch;
+      return { year, month, day, hour, minute, second };
+    }
+    if (dateOnlyMatch) {
+      const [_, year, month, day] = dateOnlyMatch;
+      return { year, month, day };
+    }
+    return null;
+  }
+  formatDateTimeToISO(dateInfo) {
+    const { year, month, day, hour = "00", minute = "00", second = "00" } = dateInfo;
+    const m = (0, import_dayjs.default)(`${year}-${month}-${day} ${hour}:${minute}:${second}.000`);
+    return m.toISOString();
+  }
   async toValue(value, ctx = {}) {
     if (!value) {
       return null;
     }
+    if (typeof value === "number") {
+      const valueStr = value.toString();
+      const dateOnlyMatch = /^(\d{4})[-/]?(\d{2})[-/]?(\d{2})$/.exec(valueStr);
+      if (dateOnlyMatch) {
+        value = valueStr;
+      }
+    }
     if (typeof value === "string") {
-      const match = /^(\d{4})[-/]?(\d{2})[-/]?(\d{2})$/.exec(value);
-      if (match) {
-        const m = (0, import_dayjs.default)(`${match[1]}-${match[2]}-${match[3]} 00:00:00.000`);
-        return m.toISOString();
+      const dateInfo = this.parseDateString(value);
+      if (dateInfo) {
+        return this.formatDateTimeToISO(dateInfo);
       }
     }
     if (import_dayjs.default.isDayjs(value)) {

package/lib/interfaces/datetime-no-tz-interface.d.ts

@@ -1,5 +1,13 @@
 import { DatetimeInterface } from './datetime-interface';
 export declare class DatetimeNoTzInterface extends DatetimeInterface {
+    protected formatDateTimeToString(dateInfo: {
+        year: string;
+        month: string;
+        day: string;
+        hour?: string;
+        minute?: string;
+        second?: string;
+    }): string;
     toValue(value: any, ctx?: any): Promise<any>;
     toString(value: any, ctx?: any): any;
 }

package/lib/interfaces/datetime-no-tz-interface.js

@@ -55,14 +55,21 @@ function isNumeric(str) {
 }
 __name(isNumeric, "isNumeric");
 const _DatetimeNoTzInterface = class _DatetimeNoTzInterface extends import_datetime_interface.DatetimeInterface {
+  formatDateTimeToString(dateInfo) {
+    const { year, month, day, hour, minute, second } = dateInfo;
+    if (hour !== void 0 && minute !== void 0 && second !== void 0) {
+      return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+    }
+    return `${year}-${month}-${day}`;
+  }
   async toValue(value, ctx = {}) {
     if (!value) {
       return null;
     }
     if (typeof value === "string") {
-      const match = /^(\d{4})[-/]?(\d{2})[-/]?(\d{2})$/.exec(value);
-      if (match) {
-        return `${match[1]}-${match[2]}-${match[3]}`;
+      const dateInfo = this.parseDateString(value);
+      if (dateInfo) {
+        return this.formatDateTimeToString(dateInfo);
       }
     }
     if (import_dayjs.default.isDayjs(value)) {

package/lib/interfaces/to-many-interface.js

@@ -38,7 +38,7 @@ const _ToManyInterface = class _ToManyInterface extends import_base_interface.Ba
     }
     str = `${str}`.trim();
     const items = str.split(",");
-    const { filterKey, targetCollection, transaction } = ctx;
+    const { filterKey, targetCollection, transaction, field } = ctx;
     const targetInstances = await targetCollection.repository.find({
       filter: {
         [filterKey]: items
@@ -51,7 +51,17 @@ const _ToManyInterface = class _ToManyInterface extends import_base_interface.Ba
       }
     });
     const primaryKeyAttribute = targetCollection.model.primaryKeyAttribute;
-    return targetInstances.map((targetInstance) => targetInstance[primaryKeyAttribute]);
+    const targetKey = field.options.targetKey;
+    const values = targetInstances.map((targetInstance) => {
+      const result = {
+        [targetKey]: targetInstance[targetKey]
+      };
+      if (targetKey !== primaryKeyAttribute) {
+        result[primaryKeyAttribute] = targetInstance[primaryKeyAttribute];
+      }
+      return result;
+    });
+    return values;
   }
 };
 __name(_ToManyInterface, "ToManyInterface");

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

@@ -7,7 +7,8 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { AggregateOptions, DestroyOptions, FindOptions, TargetKey, TK } from '../repository';
-import { AssociatedOptions, MultipleRelationRepository } from './multiple-relation-repository';
+import { MultipleRelationRepository } from './multiple-relation-repository';
+import { AssociatedOptions } from './types';
 export declare class HasManyRepository extends MultipleRelationRepository {
     find(options?: FindOptions): Promise<any>;
     aggregate(options: AggregateOptions): Promise<any>;

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

@@ -6,24 +6,20 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { MultiAssociationAccessors, Transaction, Transactionable } from 'sequelize';
-import { CommonFindOptions, CountOptions, DestroyOptions, Filter, FindOneOptions, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
+import { MultiAssociationAccessors, Transaction } from 'sequelize';
 import { RelationRepository } from './relation-repository';
-type FindAndCountOptions = CommonFindOptions;
-export interface AssociatedOptions extends Transactionable {
-    tk?: TK;
-}
+import { AssociatedOptions, CountOptions, DestroyOptions, Filter, FindOptions, TargetKey, UpdateOptions, FirstOrCreateOptions } from './types';
 export declare abstract class MultipleRelationRepository extends RelationRepository {
     targetRepositoryFilterOptionsBySourceValue(): Promise<any>;
     find(options?: FindOptions): Promise<any>;
-    findAndCount(options?: FindAndCountOptions): Promise<[any[], number]>;
+    findAndCount(options?: FindOptions): Promise<[any[], number]>;
     count(options?: CountOptions): Promise<number>;
-    findOne(options?: FindOneOptions): Promise<any>;
+    findOne(options?: FindOptions): Promise<any>;
     remove(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
     update(options?: UpdateOptions): Promise<any>;
-    destroy(options?: TK | DestroyOptions): Promise<boolean>;
+    destroy(options?: TargetKey | DestroyOptions): Promise<boolean>;
     protected destroyByFilter(filter: Filter, transaction?: Transaction): Promise<boolean>;
     protected filterHasInclude(filter: Filter, options?: any): boolean;
     protected accessors(): MultiAssociationAccessors;
+    updateOrCreate(options: FirstOrCreateOptions): Promise<any>;
 }
-export {};

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

@@ -191,6 +191,10 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
   accessors() {
     return super.accessors();
   }
+  async updateOrCreate(options) {
+    const result = await super.updateOrCreate(options);
+    return Array.isArray(result) ? result[0] : result;
+  }
 };
 __name(_MultipleRelationRepository, "MultipleRelationRepository");
 __decorateClass([
@@ -205,6 +209,9 @@ __decorateClass([
   (0, import_relation_repository.transaction)(),
   import_target_collection_decorator.default
 ], _MultipleRelationRepository.prototype, "update", 1);
+__decorateClass([
+  (0, import_relation_repository.transaction)()
+], _MultipleRelationRepository.prototype, "updateOrCreate", 1);
 let MultipleRelationRepository = _MultipleRelationRepository;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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, TargetKey } from '../repository';
+import { CreateOptions, Filter, FindOptions, FirstOrCreateOptions, TargetKey, UpdateOptions } from './types';
 export declare const transaction: (transactionInjector?: any) => (target: any, name: any, descriptor: any) => any;
 export declare abstract class RelationRepository {
     sourceCollection: Collection;
@@ -30,6 +30,8 @@ export declare abstract class RelationRepository {
     isMultiTargetKey(value?: any): boolean;
     get collection(): Collection<any, any>;
     abstract find(options?: FindOptions): Promise<any>;
+    abstract findOne(options?: FindOptions): Promise<any>;
+    abstract update(options: UpdateOptions): Promise<any>;
     chunk(options: FindOptions & {
         chunkSize: number;
         callback: (rows: Model[], options: FindOptions) => Promise<void>;
@@ -37,6 +39,8 @@ export declare abstract class RelationRepository {
     convertTk(options: any): any;
     convertTks(options: any): any[];
     targetKey(): any;
+    firstOrCreate(options: FirstOrCreateOptions): Promise<any>;
+    updateOrCreate(options: FirstOrCreateOptions): Promise<any>;
     create(options?: CreateOptions): Promise<any>;
     getSourceModel(transaction?: Transaction): Promise<Model<any, any>>;
     protected accessors(): import("sequelize").SingleAssociationAccessors | import("sequelize").MultiAssociationAccessors;

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

@@ -55,6 +55,7 @@ var import_filter_parser = __toESM(require("../filter-parser"));
 var import_options_parser = require("../options-parser");
 var import_update_associations = require("../update-associations");
 var import_update_guard = require("../update-guard");
+var import_filter_utils = require("../utils/filter-utils");
 const transaction = (0, import_transaction_decorator.transactionWrapperBuilder)(function() {
   return this.sourceCollection.model.sequelize.transaction();
 });
@@ -141,6 +142,32 @@ const _RelationRepository = class _RelationRepository {
   targetKey() {
     return this.associationField.targetKey;
   }
+  async firstOrCreate(options) {
+    const { filterKeys, values, transaction: transaction2, hooks, context } = options;
+    const filter = (0, import_filter_utils.valuesToFilter)(values, filterKeys);
+    const instance = await this.findOne({ filter, transaction: transaction2, context });
+    if (instance) {
+      return instance;
+    }
+    return this.create({ values, transaction: transaction2, hooks, context });
+  }
+  async updateOrCreate(options) {
+    const { filterKeys, values, transaction: transaction2, hooks, context } = options;
+    const filter = (0, import_filter_utils.valuesToFilter)(values, filterKeys);
+    const instance = await this.findOne({ filter, transaction: transaction2, context });
+    if (instance) {
+      return await this.update({
+        filterByTk: instance.get(
+          this.targetCollection.filterTargetKey || this.targetCollection.model.primaryKeyAttribute
+        ),
+        values,
+        transaction: transaction2,
+        hooks,
+        context
+      });
+    }
+    return this.create({ values, transaction: transaction2, hooks, context });
+  }
   async create(options) {
     if (Array.isArray(options.values)) {
       return Promise.all(options.values.map((record) => this.create({ ...options, values: record })));
@@ -210,6 +237,12 @@ const _RelationRepository = class _RelationRepository {
   }
 };
 __name(_RelationRepository, "RelationRepository");
+__decorateClass([
+  transaction()
+], _RelationRepository.prototype, "firstOrCreate", 1);
+__decorateClass([
+  transaction()
+], _RelationRepository.prototype, "updateOrCreate", 1);
 __decorateClass([
   transaction()
 ], _RelationRepository.prototype, "create", 1);

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

@@ -8,15 +8,8 @@
  */
 import { SingleAssociationAccessors, Transactionable } from 'sequelize';
 import { Model } from '../model';
-import { Appends, Except, Fields, Filter, TargetKey, UpdateOptions } from '../repository';
+import { FindOptions, TargetKey, UpdateOptions } from './types';
 import { RelationRepository } from './relation-repository';
-export interface SingleRelationFindOption extends Transactionable {
-    fields?: Fields;
-    except?: Except;
-    appends?: Appends;
-    filter?: Filter;
-    targetCollection?: string;
-}
 interface SetOption extends Transactionable {
     tk?: TargetKey;
 }
@@ -24,8 +17,8 @@ export declare abstract class SingleRelationRepository extends RelationRepositor
     abstract filterOptions(sourceModel: any): any;
     remove(options?: Transactionable): Promise<void>;
     set(options: TargetKey | SetOption): Promise<void>;
-    find(options?: SingleRelationFindOption): Promise<any>;
-    findOne(options?: SingleRelationFindOption): Promise<Model<any>>;
+    find(options?: FindOptions): Promise<any>;
+    findOne(options?: FindOptions): Promise<Model<any>>;
     destroy(options?: Transactionable): Promise<boolean>;
     update(options: UpdateOptions): Promise<any>;
     /**

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

@@ -48,7 +48,6 @@ __export(single_relation_repository_exports, {
   SingleRelationRepository: () => SingleRelationRepository
 });
 module.exports = __toCommonJS(single_relation_repository_exports);
-var import_lodash = __toESM(require("lodash"));
 var import_target_collection_decorator = __toESM(require("../decorators/target-collection-decorator"));
 var import_update_associations = require("../update-associations");
 var import_relation_repository = require("./relation-repository");
@@ -97,13 +96,14 @@ const _SingleRelationRepository = class _SingleRelationRepository extends import
     const transaction2 = await this.getTransaction(options);
     const target = await this.find({
       transaction: transaction2,
+      // @ts-ignore
       targetCollection: options.targetCollection
     });
     if (!target) {
       throw new Error("The record does not exist");
     }
     await (0, import_update_associations.updateModelByValues)(target, options == null ? void 0 : options.values, {
-      ...import_lodash.default.omit(options, "values"),
+      ...options,
       transaction: transaction2
     });
     if (options.hooks !== false) {

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

@@ -6,10 +6,81 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-import { TargetKey, Values } from '../repository';
-import { Transactionable } from 'sequelize';
-export type PrimaryKeyWithThroughValues = [TargetKey, Values];
-export interface AssociatedOptions extends Transactionable {
-    tk?: TargetKey | TargetKey[] | PrimaryKeyWithThroughValues | PrimaryKeyWithThroughValues[];
+import { AssociationKeysToBeUpdate, BlackList, Values, WhiteList } from '@nocobase/database';
+import { Transaction } from 'sequelize';
+import { CreateOptions as SequelizeCreateOptions, UpdateOptions as SequelizeUpdateOptions } from 'sequelize/types/model';
+export type TargetKey = string | number | {
+    [key: string]: any;
+};
+export interface Filter {
+    [key: string]: any;
+}
+export interface Appends {
+    [key: string]: true | Appends;
+}
+export interface Except {
+    [key: string]: true | Except;
+}
+export interface CommonOptions {
+    transaction?: Transaction;
+    context?: any;
+}
+export interface FindOptions extends CommonOptions {
+    filter?: Filter;
+    filterByTk?: TargetKey;
+    fields?: string[];
+    appends?: string[];
+    except?: string[];
+    sort?: string[];
+    limit?: number;
+    offset?: number;
+    raw?: boolean;
+    targetCollection?: string;
+}
+export interface CountOptions extends CommonOptions {
+    filter?: Filter;
+}
+export interface CreateOptions extends SequelizeCreateOptions {
+    values?: Values | Values[];
+    whitelist?: WhiteList;
+    blacklist?: BlackList;
+    updateAssociationValues?: AssociationKeysToBeUpdate;
+    context?: any;
+}
+export interface UpdateOptions extends Omit<SequelizeUpdateOptions, 'where'> {
+    values: Values;
+    filter?: Filter;
+    filterByTk?: TargetKey;
+    whitelist?: WhiteList;
+    blacklist?: BlackList;
+    updateAssociationValues?: AssociationKeysToBeUpdate;
+    targetCollection?: string;
+    context?: any;
+}
+export interface DestroyOptions extends CommonOptions {
+    filter?: Filter;
+    filterByTk?: TargetKey;
+    truncate?: boolean;
+    context?: any;
+}
+export interface FirstOrCreateOptions extends CommonOptions {
+    filterKeys: string[];
+    values: any;
+    hooks?: boolean;
+    context?: any;
+}
+export interface ThroughValues {
+    [key: string]: any;
+}
+export interface AssociatedOptions extends CommonOptions {
+    tk?: TargetKey | TargetKey[];
+    transaction?: Transaction;
+}
+export interface PrimaryKeyWithThroughValues {
+    pk: any;
+    throughValues?: ThroughValues;
+}
+export interface ToggleOptions extends CommonOptions {
+    tk?: TargetKey;
+    transaction?: Transaction;
 }
-export type setAssociationOptions = TargetKey | TargetKey[] | PrimaryKeyWithThroughValues | PrimaryKeyWithThroughValues[] | AssociatedOptions;

package/lib/repository.d.ts

@@ -7,18 +7,19 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 /// <reference types="node" />
-import { Association, BulkCreateOptions, CountOptions as SequelizeCountOptions, CreateOptions as SequelizeCreateOptions, DestroyOptions as SequelizeDestroyOptions, FindAndCountOptions as SequelizeAndCountOptions, FindOptions as SequelizeFindOptions, ModelStatic, Transactionable, UpdateOptions as SequelizeUpdateOptions, WhereOperators } from 'sequelize';
+import { Association, BulkCreateOptions, ModelStatic, FindAndCountOptions as SequelizeAndCountOptions, CountOptions as SequelizeCountOptions, CreateOptions as SequelizeCreateOptions, DestroyOptions as SequelizeDestroyOptions, FindOptions as SequelizeFindOptions, UpdateOptions as SequelizeUpdateOptions, Transactionable, WhereOperators } from 'sequelize';
 import { Collection } from './collection';
 import { Database } from './database';
 import { ArrayFieldRepository } from './field-repository/array-field-repository';
 import { Model } from './model';
 import operators from './operators';
+import { BelongsToArrayRepository } from './relation-repository/belongs-to-array-repository';
 import { BelongsToManyRepository } from './relation-repository/belongs-to-many-repository';
 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 { BelongsToArrayRepository } from './relation-repository/belongs-to-array-repository';
+import { valuesToFilter } from './utils/filter-utils';
 interface CreateManyOptions extends BulkCreateOptions {
     records: Values[];
 }
@@ -134,19 +135,18 @@ export interface AggregateOptions {
     filter?: Filter;
     distinct?: boolean;
 }
-interface FirstOrCreateOptions extends Transactionable {
+export interface FirstOrCreateOptions extends Transactionable {
     filterKeys: string[];
     values?: Values;
     hooks?: boolean;
+    context?: any;
 }
 export declare class Repository<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes> {
     database: Database;
     collection: Collection;
     model: ModelStatic<Model>;
     constructor(collection: Collection);
-    static valuesToFilter(values: Values, filterKeys: Array<string>): {
-        $and: any[];
-    };
+    static valuesToFilter: typeof valuesToFilter;
     /**
      * return count by filter
      */

package/lib/repository.js

@@ -13,6 +13,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
@@ -43,16 +44,16 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var repository_exports = {};
 __export(repository_exports, {
   Repository: () => Repository,
   Transactionable: () => import_sequelize2.Transactionable
 });
 module.exports = __toCommonJS(repository_exports);
-var import_flat = require("flat");
+var import_utils = require("@nocobase/utils");
 var import_lodash = __toESM(require("lodash"));
 var import_sequelize = require("sequelize");
-var import_utils = require("@nocobase/utils");
 var import_must_have_filter_decorator = __toESM(require("./decorators/must-have-filter-decorator"));
 var import_target_collection_decorator = __toESM(require("./decorators/target-collection-decorator"));
 var import_transaction_decorator = require("./decorators/transaction-decorator");
@@ -61,13 +62,14 @@ var import_array_field_repository = require("./field-repository/array-field-repo
 var import_fields = require("./fields");
 var import_filter_parser = __toESM(require("./filter-parser"));
 var import_options_parser = require("./options-parser");
+var import_belongs_to_array_repository = require("./relation-repository/belongs-to-array-repository");
 var import_belongs_to_many_repository = require("./relation-repository/belongs-to-many-repository");
 var import_belongs_to_repository = require("./relation-repository/belongs-to-repository");
 var import_hasmany_repository = require("./relation-repository/hasmany-repository");
 var import_hasone_repository = require("./relation-repository/hasone-repository");
 var import_update_associations = require("./update-associations");
 var import_update_guard = require("./update-guard");
-var import_belongs_to_array_repository = require("./relation-repository/belongs-to-array-repository");
+var import_filter_utils = require("./utils/filter-utils");
 var import_sequelize2 = require("sequelize");
 const debug = require("debug")("noco-database");
 const transaction = (0, import_transaction_decorator.transactionWrapperBuilder)(function() {
@@ -124,43 +126,6 @@ const _Repository = class _Repository {
     this.collection = collection;
     this.model = collection.model;
   }
-  static valuesToFilter(values = {}, filterKeys) {
-    const removeArrayIndexInKey = /* @__PURE__ */ __name((key) => {
-      const chunks = key.split(".");
-      return chunks.filter((chunk) => {
-        return !chunk.match(/\d+/);
-      }).join(".");
-    }, "removeArrayIndexInKey");
-    const filterAnd = [];
-    const flattedValues = (0, import_flat.flatten)(values);
-    const flattedValuesObject = {};
-    for (const key in flattedValues) {
-      const keyWithoutArrayIndex = removeArrayIndexInKey(key);
-      if (flattedValuesObject[keyWithoutArrayIndex]) {
-        if (!Array.isArray(flattedValuesObject[keyWithoutArrayIndex])) {
-          flattedValuesObject[keyWithoutArrayIndex] = [flattedValuesObject[keyWithoutArrayIndex]];
-        }
-        flattedValuesObject[keyWithoutArrayIndex].push(flattedValues[key]);
-      } else {
-        flattedValuesObject[keyWithoutArrayIndex] = [flattedValues[key]];
-      }
-    }
-    for (const filterKey of filterKeys) {
-      const filterValue = flattedValuesObject[filterKey] ? flattedValuesObject[filterKey] : import_lodash.default.get(values, filterKey);
-      if (filterValue) {
-        filterAnd.push({
-          [filterKey]: filterValue
-        });
-      } else {
-        filterAnd.push({
-          [filterKey]: null
-        });
-      }
-    }
-    return {
-      $and: filterAnd
-    };
-  }
   /**
    * return count by filter
    */
@@ -339,27 +304,28 @@ const _Repository = class _Repository {
    * Get the first record matching the attributes or create it.
    */
   async firstOrCreate(options) {
-    const { filterKeys, values, transaction: transaction2, hooks } = options;
+    const { filterKeys, values, transaction: transaction2, hooks, context } = options;
     const filter = _Repository.valuesToFilter(values, filterKeys);
-    const instance = await this.findOne({ filter, transaction: transaction2 });
+    const instance = await this.findOne({ filter, transaction: transaction2, context });
     if (instance) {
       return instance;
     }
-    return this.create({ values, transaction: transaction2, hooks });
+    return this.create({ values, transaction: transaction2, hooks, context });
   }
   async updateOrCreate(options) {
-    const { filterKeys, values, transaction: transaction2, hooks } = options;
+    const { filterKeys, values, transaction: transaction2, hooks, context } = options;
     const filter = _Repository.valuesToFilter(values, filterKeys);
-    const instance = await this.findOne({ filter, transaction: transaction2 });
+    const instance = await this.findOne({ filter, transaction: transaction2, context });
     if (instance) {
       return await this.update({
         filterByTk: instance.get(this.collection.filterTargetKey || this.collection.model.primaryKeyAttribute),
         values,
         transaction: transaction2,
-        hooks
+        hooks,
+        context
       });
     }
-    return this.create({ values, transaction: transaction2, hooks });
+    return this.create({ values, transaction: transaction2, hooks, context });
   }
   async create(options) {
     if (Array.isArray(options.values)) {
@@ -500,7 +466,7 @@ const _Repository = class _Repository {
         throw new Error(`filterByTk is not supported for collection that has no primary key`);
       }
     }
-    if (filterByTk && !options.filter) {
+    if (filterByTk && !(0, import_utils.isValidFilter)(options.filter)) {
       const where = [];
       for (const tk of filterByTk) {
         const optionParser = new import_options_parser.OptionsParser(
@@ -595,6 +561,7 @@ const _Repository = class _Repository {
   }
 };
 __name(_Repository, "Repository");
+__publicField(_Repository, "valuesToFilter", import_filter_utils.valuesToFilter);
 __decorateClass([
   transaction()
 ], _Repository.prototype, "create", 1);

package/lib/utils/filter-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+type Values = Record<string, any>;
+export declare function valuesToFilter(values: Values, filterKeys: Array<string>): {
+    $and: any[];
+};
+export {};

package/lib/utils/filter-utils.js

@@ -0,0 +1,86 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var filter_utils_exports = {};
+__export(filter_utils_exports, {
+  valuesToFilter: () => valuesToFilter
+});
+module.exports = __toCommonJS(filter_utils_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_flat = require("flat");
+function valuesToFilter(values = {}, filterKeys) {
+  const removeArrayIndexInKey = /* @__PURE__ */ __name((key) => {
+    const chunks = key.split(".");
+    return chunks.filter((chunk) => {
+      return !chunk.match(/\d+/);
+    }).join(".");
+  }, "removeArrayIndexInKey");
+  const filterAnd = [];
+  const flattedValues = (0, import_flat.flatten)(values);
+  const flattedValuesObject = {};
+  for (const key in flattedValues) {
+    const keyWithoutArrayIndex = removeArrayIndexInKey(key);
+    if (flattedValuesObject[keyWithoutArrayIndex]) {
+      if (!Array.isArray(flattedValuesObject[keyWithoutArrayIndex])) {
+        flattedValuesObject[keyWithoutArrayIndex] = [flattedValuesObject[keyWithoutArrayIndex]];
+      }
+      flattedValuesObject[keyWithoutArrayIndex].push(flattedValues[key]);
+    } else {
+      flattedValuesObject[keyWithoutArrayIndex] = [flattedValues[key]];
+    }
+  }
+  for (const filterKey of filterKeys) {
+    const filterValue = flattedValuesObject[filterKey] ? flattedValuesObject[filterKey] : import_lodash.default.get(values, filterKey);
+    if (filterValue) {
+      filterAnd.push({
+        [filterKey]: filterValue
+      });
+    } else {
+      filterAnd.push({
+        [filterKey]: null
+      });
+    }
+  }
+  return {
+    $and: filterAnd
+  };
+}
+__name(valuesToFilter, "valuesToFilter");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  valuesToFilter
+});

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "1.6.0-alpha.1",
+  "version": "1.6.0-alpha.11",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
   "dependencies": {
-    "@nocobase/logger": "1.6.0-alpha.1",
-    "@nocobase/utils": "1.6.0-alpha.1",
+    "@nocobase/logger": "1.6.0-alpha.11",
+    "@nocobase/utils": "1.6.0-alpha.11",
     "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": "a4c91015e34ec0c9a427451b5fbdfb5fedc4f3d7"
+  "gitHead": "2a07f8a9af90b3ce09229cae72a485c14df2361b"
 }