@nocobase/database 2.0.0-alpha.9 → 2.0.0-beta.10

package/lib/options-parser.js

@@ -96,14 +96,21 @@ const _OptionsParser = class _OptionsParser {
     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;
+    if (Array.isArray(filterByTkOption) && filterByTkOption.length === 0) {
+      return {};
     }
     const filterTargetKey = this.context.targetKey || this.collection.filterTargetKey;
+    if (Array.isArray(filterByTkOption) && Array.isArray(filterTargetKey)) {
+      if (!filterByTkOption.every(import_lodash.default.isPlainObject)) {
+        throw new Error("filterByTk array item must be plain object");
+      }
+      return {
+        [import_sequelize.Op.or]: filterByTkOption
+      };
+    }
+    if (import_lodash.default.isPlainObject(filterByTkOption)) {
+      return filterByTkOption;
+    }
     if (Array.isArray(filterTargetKey)) {
       throw new Error("multi filter target key value must be object");
     }
@@ -274,10 +281,26 @@ const _OptionsParser = class _OptionsParser {
     }
     return obj;
   }
+  normalizeAppends(appends) {
+    if (Array.isArray(appends)) {
+      return appends.filter((item) => typeof item === "string" && item.length > 0);
+    }
+    if (import_lodash.default.isPlainObject(appends)) {
+      return Object.values(appends).filter((item) => typeof item === "string" && item.length > 0);
+    }
+    if (typeof appends === "string" && appends.length > 0) {
+      return [appends];
+    }
+    return [];
+  }
   parseAppends(appends, filterParams) {
     if (!appends) return filterParams;
-    appends = import_lodash.default.sortBy(appends, (append) => append.split(".").length);
-    const setInclude = /* @__PURE__ */ __name((model, queryParams, append) => {
+    const appendList = this.normalizeAppends(appends);
+    if (!appendList.length) {
+      return filterParams;
+    }
+    const sortedAppends = import_lodash.default.sortBy(appendList, (append) => append.split(".").length);
+    const setInclude = /* @__PURE__ */ __name((model, queryParams, append, parentAs) => {
       var _a;
       const appendWithOptions = this.parseAppendWithOptions(append);
       append = appendWithOptions.name;
@@ -316,10 +339,21 @@ const _OptionsParser = class _OptionsParser {
         return;
       }
       if (existIncludeIndex == -1) {
-        queryParams["include"].push({
+        const association = associations[appendAssociation];
+        if (!association) {
+          throw new Error(`association ${appendAssociation} in ${model.name} not found`);
+        }
+        let includeOptions = {
           association: appendAssociation,
           options: appendWithOptions.options || {}
-        });
+        };
+        if (association.associationType === "BelongsToArray") {
+          includeOptions = {
+            ...includeOptions,
+            ...association.generateInclude(parentAs)
+          };
+        }
+        queryParams["include"].push(includeOptions);
         existIncludeIndex = queryParams["include"].length - 1;
       }
       if (lastLevel) {
@@ -355,14 +389,11 @@ const _OptionsParser = class _OptionsParser {
         if (appendWithOptions.raw) {
           nextAppend += appendWithOptions.raw;
         }
-        setInclude(
-          model.associations[queryParams["include"][existIncludeIndex].association].target,
-          queryParams["include"][existIncludeIndex],
-          nextAppend
-        );
+        const association = model.associations[queryParams["include"][existIncludeIndex].association];
+        setInclude(association.target, queryParams["include"][existIncludeIndex], nextAppend, association.as);
       }
     }, "setInclude");
-    for (const append of appends) {
+    for (const append of sortedAppends) {
       setInclude(this.model, filterParams, append);
     }
     debug("filter params: %o", filterParams);

package/lib/relation-repository/belongs-to-many-repository.js

@@ -88,8 +88,7 @@ const _BelongsToManyRepository = class _BelongsToManyRepository extends import_m
     };
     this.collection.validate({
       values,
-      operation: "create",
-      context: options.context
+      operation: "create"
     });
     const instance = await sourceModel[createAccessor](values, createOptions);
     await (0, import_update_associations.updateAssociations)(instance, values, { ...options, transaction: transaction2 });

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

@@ -11,6 +11,7 @@ import { RelationRepository } from './relation-repository';
 import { AssociatedOptions, CountOptions, DestroyOptions, Filter, FindOptions, TargetKey, UpdateOptions, FirstOrCreateOptions } from './types';
 export declare abstract class MultipleRelationRepository extends RelationRepository {
     targetRepositoryFilterOptionsBySourceValue(): Promise<any>;
+    private normalizeScope;
     find(options?: FindOptions): Promise<any>;
     findAndCount(options?: FindOptions): Promise<[any[], number]>;
     count(options?: CountOptions): Promise<number>;

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

@@ -65,6 +65,16 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
       [this.association.foreignKey]: filterForeignKeyValue
     };
   }
+  normalizeScope(scope, model) {
+    const result = {};
+    for (const [key, value] of Object.entries(scope)) {
+      const attr = model.getAttributes()[key];
+      if (attr == null ? void 0 : attr.field) {
+        result[attr.field] = value;
+      }
+    }
+    return result;
+  }
   async find(options) {
     const targetRepository = this.targetCollection.repository;
     const association = this.association;
@@ -74,6 +84,9 @@ const _MultipleRelationRepository = class _MultipleRelationRepository extends im
       sourceKey: association.targetKey,
       realAs: association.through.model.name
     };
+    if (association.through.scope) {
+      oneFromTargetOptions["scope"] = this.normalizeScope(association.through.scope, association.through.model);
+    }
     const pivotAssoc = new import_sequelize.HasOne(association.target, association.through.model, oneFromTargetOptions);
     const appendFilter = {
       isPivotFilter: true,

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

@@ -178,7 +178,7 @@ const _RelationRepository = class _RelationRepository {
     const values = options.values;
     const transaction2 = await this.getTransaction(options);
     const sourceModel = await this.getSourceModel(transaction2);
-    this.collection.validate({ values, context: options.context, operation: "create" });
+    this.collection.validate({ values, operation: "create" });
     const instance = await sourceModel[createAccessor](guard.sanitize(options.values), { ...options, transaction: transaction2 });
     await (0, import_update_associations.updateAssociations)(instance, values, { ...options, transaction: transaction2 });
     if (options.hooks !== false) {

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

@@ -51,7 +51,6 @@ module.exports = __toCommonJS(single_relation_repository_exports);
 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");
-var import_lodash = __toESM(require("lodash"));
 const _SingleRelationRepository = class _SingleRelationRepository extends import_relation_repository.RelationRepository {
   async remove(options) {
     const transaction2 = await this.getTransaction(options);
@@ -104,7 +103,7 @@ const _SingleRelationRepository = class _SingleRelationRepository extends import
       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/repository.d.ts

@@ -30,7 +30,7 @@ export interface FilterAble {
 }
 export type BaseTargetKey = string | number;
 export type MultiTargetKey = Record<string, BaseTargetKey>;
-export type TargetKey = BaseTargetKey | MultiTargetKey;
+export type TargetKey = BaseTargetKey | MultiTargetKey | MultiTargetKey[];
 export type TK = TargetKey | TargetKey[];
 type FieldValue = string | number | bigint | boolean | Date | Buffer | null | FieldValue[] | FilterWithOperator;
 type Operators = keyof typeof operators & keyof WhereOperators;
@@ -62,7 +62,7 @@ export type CountOptions = Omit<SequelizeCountOptions, 'distinct' | 'where' | 'i
     context?: any;
 } & FilterByTk;
 export interface FilterByTk {
-    filterByTk?: TargetKey;
+    filterByTk?: TK;
     targetCollection?: string;
 }
 export type FindOptions = SequelizeFindOptions & CommonFindOptions & FilterByTk;

package/lib/repository.js

@@ -71,8 +71,8 @@ var import_hasmany_repository = require("./relation-repository/hasmany-repositor
 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_filter_utils = require("./utils/filter-utils");
 var import_utils2 = require("./utils");
+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() {
@@ -453,7 +453,7 @@ const _Repository = class _Repository {
       underscored: this.collection.options.underscored
     });
     const values = this.model.callSetters(guard.sanitize(options.values || {}), options);
-    this.validate({ values, context: options.context, operation: "create" });
+    this.validate({ values, operation: "create" });
     const instance = await this.model.create(values, {
       ...options,
       transaction: transaction2
@@ -498,7 +498,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 = this.model.callSetters(guard.sanitize(options.values || {}), options);
-    this.validate({ values, context: options.context, operation: "update" });
+    this.validate({ values, operation: "update" });
     if (options.individualHooks === false) {
       const { model: Model2 } = this.collection;
       const primaryKeyField = Model2.primaryKeyField || Model2.primaryKeyAttribute;

package/lib/sync-runner.js

@@ -162,6 +162,9 @@ const _SyncRunner = class _SyncRunner {
     }, "isJSONColumn");
     for (const columnName in columns) {
       const column = columns[columnName];
+      if (isJSONColumn(column) && this.database.inDialect("mysql")) {
+        continue;
+      }
       const isPrimaryKey = /* @__PURE__ */ __name(() => {
         const attribute = this.findAttributeByColumnName(columnName);
         return attribute && attribute.primaryKey || column.primaryKey;

package/lib/update-associations.d.ts

@@ -13,9 +13,7 @@ export declare function modelAssociations(instance: Model): {
     [key: string]: Association<import("sequelize").Model<any, any>, import("sequelize").Model<any, any>>;
 };
 export declare function belongsToManyAssociations(instance: Model): Array<BelongsToMany>;
-export declare function modelAssociationByKey(instance: Model, key: string): Association & {
-    update?: (instance: Model, value: any, options: UpdateAssociationOptions) => Promise<any>;
-};
+export declare function modelAssociationByKey(instance: Model, key: string): Association;
 type UpdateValue = {
     [key: string]: any;
 };
@@ -51,7 +49,7 @@ export declare function updateAssociations(instance: Model, values: any, options
  * @param value
  * @param options
  */
-export declare function updateAssociation(instance: Model, key: string, value: any, options?: UpdateAssociationOptions): Promise<any>;
+export declare function updateAssociation(instance: Model, key: string, value: any, options?: UpdateAssociationOptions): Promise<boolean>;
 /**
  * update belongsTo and HasOne
  * @param model

package/lib/update-associations.js

@@ -81,8 +81,7 @@ async function updateModelByValues(instance, values, options) {
   }
   instance.constructor.collection.validate({
     values,
-    operation: "update",
-    context: options == null ? void 0 : options.context
+    operation: "update"
   });
   await instance.update(values, options);
   await updateAssociations(instance, values, options);
@@ -177,9 +176,6 @@ async function updateAssociation(instance, key, value, options = {}) {
   if (options.associationContext && isReverseAssociationPair(association, options.associationContext)) {
     return false;
   }
-  if (association.update) {
-    return association.update(instance, value, options);
-  }
   switch (association.associationType) {
     case "HasOne":
     case "BelongsTo":
@@ -223,16 +219,6 @@ async function updateSingleAssociation(model, key, value, options = {}) {
       );
     }
   }, "checkBelongsToForeignKeyValue");
-  if ((0, import_utils.isStringOrNumber)(value)) {
-    await model[setAccessor](value, { context, transaction });
-    return true;
-  }
-  if (value instanceof import_model.Model) {
-    await model[setAccessor](value, { context, transaction });
-    model.setDataValue(key, value);
-    return true;
-  }
-  const createAccessor = association.accessors.create;
   let dataKey;
   let M;
   if (association.associationType === "BelongsTo") {
@@ -242,6 +228,24 @@ async function updateSingleAssociation(model, key, value, options = {}) {
     M = association.target;
     dataKey = M.primaryKeyAttribute;
   }
+  if ((0, import_utils.isStringOrNumber)(value)) {
+    const instance2 = await M.findOne({
+      where: {
+        [dataKey]: value
+      },
+      transaction
+    });
+    if (instance2) {
+      await model[setAccessor](value, { context, transaction });
+    }
+    return true;
+  }
+  if (value instanceof import_model.Model) {
+    await model[setAccessor](value, { context, transaction });
+    model.setDataValue(key, value);
+    return true;
+  }
+  const createAccessor = association.accessors.create;
   if ((0, import_utils.isStringOrNumber)(value[dataKey])) {
     const instance2 = await M.findOne({
       where: {
@@ -259,7 +263,7 @@ async function updateSingleAssociation(model, key, value, options = {}) {
         if (association.associationType === "HasOne") {
           delete updateValues[association.foreignKey];
         }
-        await instance2.update(updateValues, { ...options, transaction });
+        await instance2.update(updateValues, { ...options, transaction, inputValues: updateValues });
       }
       await updateAssociations(instance2, value, {
         ...options,
@@ -273,10 +277,9 @@ async function updateSingleAssociation(model, key, value, options = {}) {
   }
   association.target.collection.validate({
     values: value,
-    context: options.context,
     operation: "create"
   });
-  const instance = await model[createAccessor](value, { context, transaction });
+  const instance = await model[createAccessor](value, { context, transaction, inputValues: value });
   await updateAssociations(instance, value, {
     ...options,
     transaction,
@@ -316,7 +319,7 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
     return;
   }
   value = import_lodash.default.castArray(value);
-  const setItems = [];
+  let setItems = [];
   const objectItems = [];
   for (const item of value) {
     if ((0, import_utils.isUndefinedOrNull)(item)) {
@@ -340,6 +343,25 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
       objectItems.push(item);
     }
   }
+  if (setItems.length > 0) {
+    const TargetModel = association.target;
+    const pk2 = TargetModel.primaryKeyAttribute;
+    const targetKey2 = association.targetKey || association.options.targetKey || pk2;
+    const rawKeys = [];
+    const instanceItems = [];
+    for (const item of setItems) {
+      if (item instanceof import_model.Model) {
+        instanceItems.push(item);
+      } else if ((0, import_utils.isStringOrNumber)(item)) {
+        rawKeys.push(item);
+      }
+    }
+    const validInstances = rawKeys.length ? await TargetModel.findAll({
+      where: { [targetKey2]: rawKeys },
+      transaction
+    }) : [];
+    setItems = [...instanceItems, ...validInstances];
+  }
   await model[setAccessor](setItems, { transaction, context, individualHooks: true, validate: false });
   const newItems = [];
   const pk = association.target.primaryKeyAttribute;
@@ -368,10 +390,9 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
     if ((0, import_utils.isUndefinedOrNull)(item[targetKey])) {
       association.target.collection.validate({
         values: item,
-        context: options.context,
         operation: "create"
       });
-      const instance = await model[createAccessor](item, accessorOptions);
+      const instance = await model[createAccessor](item, { ...accessorOptions, inputValues: item });
       await updateAssociations(instance, item, {
         ...options,
         transaction,
@@ -390,10 +411,9 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
       if (!instance) {
         association.target.collection.validate({
           values: item,
-          context: options.context,
           operation: "create"
         });
-        instance = await model[createAccessor](item, accessorOptions);
+        instance = await model[createAccessor](item, { ...accessorOptions, inputValues: item });
         await updateAssociations(instance, item, {
           ...options,
           transaction,
@@ -414,10 +434,9 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
         }
         association.target.collection.validate({
           values: item,
-          context: options.context,
           operation: "update"
         });
-        await instance.update(item, { ...options, transaction });
+        await instance.update(item, { ...options, transaction, inputValues: item });
       }
       await updateAssociations(instance, item, {
         ...options,

package/lib/utils/field-validation.d.ts

@@ -12,48 +12,3 @@ export declare function buildJoiSchema(validation: ValidationOptions, options: {
     label?: string;
     value: string;
 }): AnySchema;
-export declare function getJoiErrorMessage(t: Function): {
-    'string.base': any;
-    'string.empty': any;
-    'string.min': any;
-    'string.max': any;
-    'string.length': any;
-    'string.alphanum': any;
-    'string.token': any;
-    'string.regex': any;
-    'string.email': any;
-    'string.uri': any;
-    'string.uriCustomScheme': any;
-    'string.isoDate': any;
-    'string.guid': any;
-    'string.hex': any;
-    'string.hostname': any;
-    'string.lowercase': any;
-    'string.uppercase': any;
-    'string.trim': any;
-    'string.creditCard': any;
-    'string.pattern.base': any;
-    'string.pattern.name': any;
-    'string.pattern.invert.base': any;
-    'string.pattern.invert.name': any;
-    'any.required': any;
-    'number.base': any;
-    'number.min': any;
-    'number.max': any;
-    'number.less': any;
-    'number.greater': any;
-    'number.float': any;
-    'number.integer': any;
-    'number.negative': any;
-    'number.positive': any;
-    'number.precision': any;
-    'number.multiple': any;
-    'number.port': any;
-    'number.unsafe': any;
-    'date.base': any;
-    'date.format': any;
-    'date.greater': any;
-    'date.less': any;
-    'date.max': any;
-    'date.min': any;
-};

package/lib/utils/field-validation.js

@@ -37,8 +37,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var field_validation_exports = {};
 __export(field_validation_exports, {
-  buildJoiSchema: () => buildJoiSchema,
-  getJoiErrorMessage: () => getJoiErrorMessage
+  buildJoiSchema: () => buildJoiSchema
 });
 module.exports = __toCommonJS(field_validation_exports);
 var import_joi = __toESM(require("joi"));
@@ -80,64 +79,7 @@ function buildJoiSchema(validation, options) {
   return schema;
 }
 __name(buildJoiSchema, "buildJoiSchema");
-function getJoiErrorMessage(t) {
-  const tOptions = { ns: "client" };
-  const JoiErrorMessages = {
-    "string.base": t("{{#label}} must be a string", tOptions),
-    "string.empty": t("{{#label}} is not allowed to be empty", tOptions),
-    "string.min": t("{{#label}} length must be at least {{#limit}} characters long", tOptions),
-    "string.max": t("{{#label}} length must be less than or equal to {{#limit}} characters long", tOptions),
-    "string.length": t("{{#label}} length must be {{#limit}} characters long", tOptions),
-    "string.alphanum": t("{{#label}} must only contain alpha-numeric characters", tOptions),
-    "string.token": t("{{#label}} must only contain alpha-numeric and underscore characters", tOptions),
-    "string.regex": t("{{#label}} with value {{#value}} fails to match the required pattern", tOptions),
-    "string.email": t("{{#label}} email address doesn\u2019t meet the required format", tOptions),
-    "string.uri": t("{{#label}} must be a valid uri", tOptions),
-    "string.uriCustomScheme": t(
-      "{{#label}} must be a valid uri with a scheme matching the {{#scheme}} pattern",
-      tOptions
-    ),
-    "string.isoDate": t("{{#label}} must be a valid ISO 8601 date", tOptions),
-    "string.guid": t("{{#label}} must be a valid UUID", tOptions),
-    "string.hex": t("{{#label}} must only contain hexadecimal characters", tOptions),
-    "string.hostname": t("{{#label}} must be a valid hostname", tOptions),
-    "string.lowercase": t("{{#label}} must only contain lowercase characters", tOptions),
-    "string.uppercase": t("{{#label}} must only contain uppercase characters", tOptions),
-    "string.trim": t("{{#label}} must not have leading or trailing whitespace", tOptions),
-    "string.creditCard": t("{{#label}} must be a credit card", tOptions),
-    "string.pattern.base": t('{{#label}} with value "{{#value}}" fails to match the required pattern', tOptions),
-    "string.pattern.name": t('{{#label}} with value "{{#value}}" fails to match the {{#name}} pattern', tOptions),
-    "string.pattern.invert.base": t('{{#label}} with value "{{#value}}" matches the inverted pattern', tOptions),
-    "string.pattern.invert.name": t(
-      '{{#label}} with value "{{#value}}" matches the inverted {{#name}} pattern',
-      tOptions
-    ),
-    "any.required": t("{{#label}} is required", tOptions),
-    "number.base": t("{{#label}} must be a number", tOptions),
-    "number.min": t("{{#label}} must be greater than or equal to {{#limit}}", tOptions),
-    "number.max": t("{{#label}} must be less than or equal to {{#limit}}", tOptions),
-    "number.less": t("{{#label}} must be less than {{#limit}}", tOptions),
-    "number.greater": t("{{#label}} must be greater than {{#limit}}", tOptions),
-    "number.float": t("{{#label}} must be a float or double", tOptions),
-    "number.integer": t("{{#label}} must be an integer", tOptions),
-    "number.negative": t("{{#label}} must be a negative number", tOptions),
-    "number.positive": t("{{#label}} must be a positive number", tOptions),
-    "number.precision": t("{{#label}} must not have more than {{#limit}} decimal places", tOptions),
-    "number.multiple": t("{{#label}} must be a multiple of {{#multiple}}", tOptions),
-    "number.port": t("{{#label}} must be a valid port", tOptions),
-    "number.unsafe": t("{{#label}} must be a safe number", tOptions),
-    "date.base": t("{{#label}} must be a valid date", tOptions),
-    "date.format": t("{{#label}} must be in {{#format}} format", tOptions),
-    "date.greater": t("{{#label}} must be greater than {{#limit}}", tOptions),
-    "date.less": t("{{#label}} must be less than {{#limit}}", tOptions),
-    "date.max": t("{{#label}} must be less than or equal to {{#limit}}", tOptions),
-    "date.min": t("{{#label}} must be greater than or equal to {{#limit}}", tOptions)
-  };
-  return JoiErrorMessages;
-}
-__name(getJoiErrorMessage, "getJoiErrorMessage");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  buildJoiSchema,
-  getJoiErrorMessage
+  buildJoiSchema
 });

package/lib/utils.d.ts

@@ -16,4 +16,5 @@ export declare function percent2float(value: string): number;
 export declare function isUndefinedOrNull(value: any): boolean;
 export declare function isStringOrNumber(value: any): boolean;
 export declare function getKeysByPrefix(keys: string[], prefix: string): string[];
+export declare function extractTypeFromDefinition(rawType: string): string;
 export declare function processIncludes(includes: any[], model: any, parentAs?: string): any[];

package/lib/utils.js

@@ -38,6 +38,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var utils_exports = {};
 __export(utils_exports, {
   checkIdentifier: () => checkIdentifier,
+  extractTypeFromDefinition: () => extractTypeFromDefinition,
   getKeysByPrefix: () => getKeysByPrefix,
   getTableName: () => getTableName,
   isStringOrNumber: () => isStringOrNumber,
@@ -141,6 +142,14 @@ function getKeysByPrefix(keys, prefix) {
   return keys.filter((key) => key.startsWith(`${prefix}.`)).map((key) => key.substring(prefix.length + 1));
 }
 __name(getKeysByPrefix, "getKeysByPrefix");
+function extractTypeFromDefinition(rawType) {
+  const leftParenIndex = rawType.indexOf("(");
+  if (leftParenIndex === -1) {
+    return rawType.toLowerCase();
+  }
+  return rawType.substring(0, leftParenIndex).toLowerCase().trim();
+}
+__name(extractTypeFromDefinition, "extractTypeFromDefinition");
 function processIncludes(includes, model, parentAs = "") {
   includes.forEach((include, index) => {
     const association = model.associations[include.association];
@@ -164,6 +173,7 @@ __name(processIncludes, "processIncludes");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkIdentifier,
+  extractTypeFromDefinition,
   getKeysByPrefix,
   getTableName,
   isStringOrNumber,

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

@@ -39,9 +39,9 @@ const postgres = {
   name: "string",
   smallint: ["integer", "sort"],
   integer: ["integer", "unixTimestamp", "sort"],
-  bigint: ["bigInt", "unixTimestamp", "sort"],
+  bigint: ["bigInt", "snowflakeId", "unixTimestamp", "sort"],
   decimal: "decimal",
-  numeric: "float",
+  numeric: "decimal",
   real: "float",
   "double precision": "float",
   "timestamp without time zone": "datetimeNoTz",
@@ -77,7 +77,7 @@ const mysql = {
   int: ["integer", "unixTimestamp", "sort"],
   "int unsigned": ["integer", "unixTimestamp", "sort"],
   integer: ["integer", "unixTimestamp", "sort"],
-  bigint: ["bigInt", "unixTimestamp", "sort"],
+  bigint: ["bigInt", "snowflakeId", "unixTimestamp", "sort"],
   "bigint unsigned": ["bigInt", "unixTimestamp", "sort"],
   float: "float",
   double: "float",

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "2.0.0-alpha.9",
+  "version": "2.0.0-beta.10",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
   "dependencies": {
-    "@nocobase/logger": "2.0.0-alpha.9",
-    "@nocobase/utils": "2.0.0-alpha.9",
+    "@nocobase/logger": "2.0.0-beta.10",
+    "@nocobase/utils": "2.0.0-beta.10",
     "async-mutex": "^0.3.2",
     "chalk": "^4.1.1",
     "cron-parser": "4.4.0",
@@ -39,5 +39,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "4a9acf96f21a3aa35bccbd188b942595b09da0a9"
+  "gitHead": "9943dc4b0fdedcac3f304714b58635ae441e2560"
 }

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

@@ -1,20 +0,0 @@
-/**
- * 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.
- */
-import { DataTypes } from 'sequelize';
-import { BaseColumnFieldOptions, Field } from '../field';
-export interface EncryptionFieldOptions extends BaseColumnFieldOptions {
-    type: 'encryption';
-    hidden?: boolean;
-}
-export declare class EncryptionField extends Field {
-    get dataType(): DataTypes.StringDataTypeConstructor;
-    init(): void;
-    bind(): void;
-    unbind(): void;
-}