@nocobase/database 1.9.0-beta.8 → 2.0.0-alpha.2

package/lib/collection.d.ts

@@ -81,13 +81,22 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     model: ModelStatic<Model>;
     repository: Repository<TModelAttributes, TCreationAttributes>;
     constructor(options: CollectionOptions, context: CollectionContext);
+    get underscored(): boolean;
     get filterTargetKey(): string | string[];
     get name(): string;
     get origin(): string;
     get titleField(): string;
+    get titleFieldInstance(): Field;
     get db(): Database;
     get treeParentField(): BelongsToField | null;
     get treeChildrenField(): HasManyField | null;
+    validate(options: {
+        values: Record<string, any> | Record<string, any>[];
+        operation: 'create' | 'update';
+        context: {
+            t: Function;
+        };
+    }): void;
     isMultiFilterTargetKey(): boolean;
     tableName(): any;
     /**
@@ -148,6 +157,7 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
         modelName: string;
         sequelize: import("sequelize").Sequelize;
         tableName: any;
+        underscored: boolean;
     };
     protected bindFieldEventListener(): void;
     private checkOptions;

package/lib/collection.js

@@ -53,9 +53,11 @@ var import_events = require("events");
 var import_lodash = __toESM(require("lodash"));
 var import_safe_json_stringify = __toESM(require("safe-json-stringify"));
 var import_sequelize = require("sequelize");
+var import_fields = require("./fields");
 var import_model = require("./model");
 var import_repository = require("./repository");
 var import_utils = require("./utils");
+var import_field_validation = require("./utils/field-validation");
 function EnsureAtomicity(target, propertyKey, descriptor) {
   const originalMethod = descriptor.value;
   descriptor.value = function(...args) {
@@ -109,6 +111,9 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     this.setRepository(options.repository);
     this.setSortable(options.sortable);
   }
+  get underscored() {
+    return this.options.underscored;
+  }
   get filterTargetKey() {
     var _a;
     const targetKey = (_a = this.options) == null ? void 0 : _a.filterTargetKey;
@@ -135,6 +140,9 @@ const _Collection = class _Collection extends import_events.EventEmitter {
   get titleField() {
     return this.options.titleField || this.model.primaryKeyAttribute;
   }
+  get titleFieldInstance() {
+    return this.getField(this.titleField);
+  }
   get db() {
     return this.context.database;
   }
@@ -152,13 +160,78 @@ const _Collection = class _Collection extends import_events.EventEmitter {
       }
     }
   }
+  validate(options) {
+    const { values: updateValues, context, operation } = options;
+    if (!updateValues) {
+      return;
+    }
+    const values = Array.isArray(updateValues) ? updateValues : [updateValues];
+    const { t } = context || { t: /* @__PURE__ */ __name((key, options2) => key, "t") };
+    const unwrapTplLabel = /* @__PURE__ */ __name((label) => {
+      if (typeof label !== "string") return label;
+      const m = label.match(/^[\s\t]*\{\{\s*t\(\s*(['"])(.*?)\1(?:\s*,[\s\S]*)?\)\s*\}\}[\s\t]*$/);
+      return m ? m[2] : label;
+    }, "unwrapTplLabel");
+    const helper = /* @__PURE__ */ __name((field, value) => {
+      var _a, _b, _c;
+      const val = value[field.name];
+      if (!field.options.validation) {
+        return;
+      }
+      const fieldLabel = unwrapTplLabel(((_a = field.options.uiSchema) == null ? void 0 : _a.title) || field.name);
+      if (field instanceof import_fields.RelationField) {
+        if ((_b = field.options) == null ? void 0 : _b.validation.rules) {
+          const isRequired = (_c = field.options) == null ? void 0 : _c.validation.rules.some((rule) => rule.name === "required");
+          if (isRequired && !val) {
+            throw new Error(
+              t("{{#label}} is required", {
+                ns: "client",
+                "#label": `${t("Collection", { ns: "client" })}: ${this.name}, ${t("Field", { ns: "client" })}: ${t(
+                  fieldLabel,
+                  { ns: "client" }
+                )}`
+              })
+            );
+          }
+        }
+        return;
+      }
+      const joiSchema = (0, import_field_validation.buildJoiSchema)(field.options.validation, {
+        label: `${t("Collection", { ns: "client" })}: ${this.name}, ${t("Field", { ns: "client" })}: ${t(fieldLabel, {
+          ns: "client"
+        })}`,
+        value: val
+      });
+      const { error } = joiSchema.validate(val, {
+        messages: (0, import_field_validation.getJoiErrorMessage)(t)
+      });
+      if (error) {
+        throw error;
+      }
+    }, "helper");
+    for (const value of values) {
+      if (operation === "create") {
+        for (const [, field] of this.fields) {
+          helper(field, value);
+        }
+      }
+      if (operation === "update") {
+        for (const key of Object.keys(value)) {
+          const field = this.getField(key);
+          if (field) {
+            helper(field, value);
+          }
+        }
+      }
+    }
+  }
   isMultiFilterTargetKey() {
     return Array.isArray(this.filterTargetKey) && this.filterTargetKey.length > 1;
   }
   tableName() {
     const { name, tableName } = this.options;
     const tName = tableName || name;
-    return this.options.underscored ? (0, import_utils.snakeCase)(tName) : tName;
+    return this.underscored ? (0, import_utils.snakeCase)(tName) : tName;
   }
   /**
    * @internal
@@ -271,7 +344,7 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     return this.setField(name, options);
   }
   checkFieldType(name, options) {
-    if (!this.options.underscored) {
+    if (!this.underscored) {
       return;
     }
     const fieldName = options.field || (0, import_utils.snakeCase)(name);
@@ -416,7 +489,7 @@ const _Collection = class _Collection extends import_events.EventEmitter {
     }
     if (this.model.options.timestamps !== false) {
       let timestampsFields = ["createdAt", "updatedAt", "deletedAt"];
-      if (this.db.options.underscored) {
+      if (this.underscored) {
         timestampsFields = timestampsFields.map((fieldName) => (0, import_utils.snakeCase)(fieldName));
       }
       if (timestampsFields.includes(field.columnName())) {
@@ -709,7 +782,8 @@ const _Collection = class _Collection extends import_events.EventEmitter {
       ...import_lodash.default.omit(this.options, ["name", "fields", "model", "targetKey"]),
       modelName: name,
       sequelize: this.context.database.sequelize,
-      tableName: this.tableName()
+      tableName: this.tableName(),
+      underscored: this.underscored
     };
     return attr;
   }

package/lib/database.d.ts

@@ -17,6 +17,7 @@ import { Collection, CollectionOptions, RepositoryType } from './collection';
 import { CollectionFactory } from './collection-factory';
 import { ImportFileExtension } from './collection-importer';
 import DatabaseUtils from './database-utils';
+import { BaseDialect } from './dialects/base-dialect';
 import ReferencesMap from './features/references-map';
 import { ArrayFieldRepository } from './field-repository/array-field-repository';
 import * as FieldTypes from './fields';
@@ -31,7 +32,6 @@ import { RelationRepository } from './relation-repository/relation-repository';
 import { Repository, TargetKey } from './repository';
 import { AfterDefineCollectionListener, BeforeDefineCollectionListener, CreateListener, CreateWithAssociationsListener, DatabaseAfterDefineCollectionEventType, DatabaseAfterRemoveCollectionEventType, DatabaseBeforeDefineCollectionEventType, DatabaseBeforeRemoveCollectionEventType, DestroyListener, EventType, ModelCreateEventTypes, ModelCreateWithAssociationsEventTypes, ModelDestroyEventTypes, ModelSaveEventTypes, ModelSaveWithAssociationsEventTypes, ModelUpdateEventTypes, ModelUpdateWithAssociationsEventTypes, ModelValidateEventTypes, RemoveCollectionListener, SaveListener, SaveWithAssociationsListener, SyncListener, UpdateListener, UpdateWithAssociationsListener, ValidateListener } from './types';
 import { BaseValueParser } from './value-parsers';
-import { BaseDialect } from './dialects/base-dialect';
 export type MergeOptions = merge.Options;
 export interface PendingOptions {
     field: RelationField;
@@ -67,6 +67,11 @@ export type AddMigrationsOptions = {
     directory: string;
 };
 type OperatorFunc = (value: any, ctx?: RegisterOperatorsContext) => any;
+type RunSQLOptions = {
+    filter?: Record<string, any>;
+    bind?: Record<string, any> | Array<any>;
+    type?: 'selectVar' | 'selectRow' | 'selectRows';
+} & Transactionable;
 export declare class Database extends EventEmitter implements AsyncEmitter {
     static dialects: Map<string, typeof BaseDialect>;
     sequelize: Sequelize;
@@ -118,7 +123,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     /**
      * @internal
      */
-    sequelizeOptions(options: any): IDatabaseOptions;
+    sequelizeOptions(options: DatabaseOptions): IDatabaseOptions;
     /**
      * @internal
      */
@@ -128,6 +133,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     inDialect(...dialect: string[]): boolean;
     isMySQLCompatibleDialect(): boolean;
     isPostgresCompatibleDialect(): boolean;
+    wrapSequelizeRunForMySQL(): void;
     /**
      * Add collection to database
      * @param options
@@ -207,6 +213,9 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
         extensions?: ImportFileExtension[];
     }): Promise<Map<string, Collection>>;
     private registerCollectionType;
+    quoteIdentifier(identifier: string): string;
+    quoteTable(tableName: string): string;
+    runSQL(sql: string, options?: RunSQLOptions): Promise<any>;
 }
 export declare function extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): {
     collectionOptions: CollectionOptions;

package/lib/database.js

@@ -58,6 +58,7 @@ var import_path = require("path");
 var import_safe_json_stringify = __toESM(require("safe-json-stringify"));
 var import_sequelize = require("sequelize");
 var import_umzug = require("umzug");
+var import_collection = require("./collection");
 var import_collection_factory = require("./collection-factory");
 var import_collection_importer = require("./collection-importer");
 var import_database_utils = __toESM(require("./database-utils"));
@@ -176,6 +177,9 @@ const _Database = class _Database extends import_events.EventEmitter {
     );
     const sequelizeOptions = this.sequelizeOptions(this.options);
     this.sequelize = new import_sequelize.Sequelize(sequelizeOptions);
+    if (options.dialect === "mysql") {
+      this.wrapSequelizeRunForMySQL();
+    }
     this.queryInterface = (0, import_query_interface_builder.default)(this);
     this.collections = /* @__PURE__ */ new Map();
     this.modelHook = new import_model_hook.ModelHook(this);
@@ -397,14 +401,40 @@ const _Database = class _Database extends import_events.EventEmitter {
   isPostgresCompatibleDialect() {
     return this.inDialect("postgres");
   }
+  /*
+   * https://github.com/sidorares/node-mysql2/issues/1239#issuecomment-766867699
+   * https://github.com/sidorares/node-mysql2/pull/1407#issuecomment-1325789581
+   * > I'm starting to think simple "always send (parameter.toString()) as VAR_STRING" unless the type is explicitly specified by user" might be actually the best behaviour
+   */
+  wrapSequelizeRunForMySQL() {
+    const that = this;
+    const run = this.sequelize.dialect.Query.prototype.run;
+    this.sequelize.dialect.Query.prototype.run = function(sql, parameters) {
+      if (!/^update\s+/i.test(sql.trim()) || !(parameters == null ? void 0 : parameters.length)) {
+        return run.apply(this, [sql, parameters]);
+      }
+      try {
+        parameters.forEach((p, index) => {
+          if (typeof p === "number") {
+            parameters[index] = p.toString();
+          }
+        });
+      } catch (err) {
+        that.logger.error(err);
+      }
+      return run.apply(this, [sql, parameters]);
+    };
+  }
   /**
    * Add collection to database
    * @param options
    */
   collection(options) {
     options = import_lodash.default.cloneDeep(options);
-    if (this.options.underscored) {
-      options.underscored = true;
+    if (typeof options.underscored !== "boolean") {
+      if (this.options.underscored) {
+        options.underscored = true;
+      }
     }
     this.logger.trace(`beforeDefineCollection: ${(0, import_safe_json_stringify.default)(options)}`, {
       databaseInstanceId: this.instanceId
@@ -754,6 +784,57 @@ const _Database = class _Database extends import_events.EventEmitter {
       }
     });
   }
+  // 如果需要手动引用标识符，可以添加辅助方法
+  quoteIdentifier(identifier) {
+    return this.sequelize.getQueryInterface().queryGenerator["quoteIdentifier"](identifier);
+  }
+  quoteTable(tableName) {
+    return this.sequelize.getQueryInterface().quoteIdentifiers(tableName);
+  }
+  async runSQL(sql, options = {}) {
+    const { filter, bind, type, transaction } = options;
+    let finalSQL = sql;
+    if (!finalSQL.replace(/\s+/g, " ").trim()) {
+      throw new Error("SQL cannot be empty");
+    }
+    if (filter) {
+      let where = {};
+      const tmpCollection = new import_collection.Collection({ name: "tmp", underscored: false }, { database: this });
+      const r = tmpCollection.repository;
+      where = r.buildQueryOptions({ filter }).where;
+      const queryGenerator = this.sequelize.getQueryInterface().queryGenerator;
+      const wSQL = queryGenerator.getWhereConditions(where, null, null, { bindParam: true });
+      if (wSQL) {
+        let normalizedSQL = sql.replace(/\s+/g, " ").trim();
+        if (normalizedSQL.endsWith(";")) {
+          normalizedSQL = normalizedSQL.slice(0, -1).trim();
+        }
+        finalSQL = `SELECT * FROM (${normalizedSQL}) AS tmp WHERE ${wSQL}`;
+      }
+    }
+    this.logger.debug("runSQL", { finalSQL });
+    const result = await this.sequelize.query(finalSQL, { bind, transaction });
+    let data = result[0];
+    if (type === "selectVar") {
+      if (Array.isArray(data)) {
+        data = data[0];
+      }
+      return Object.values(data || {}).shift();
+    }
+    if (type === "selectRow") {
+      if (Array.isArray(data)) {
+        data = data[0];
+      }
+      return data || null;
+    }
+    if (type === "selectRows") {
+      if (!Array.isArray(data)) {
+        return [data].filter(Boolean);
+      }
+      return data;
+    }
+    return data;
+  }
 };
 __name(_Database, "Database");
 __publicField(_Database, "dialects", /* @__PURE__ */ new Map());

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

@@ -7,6 +7,7 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 import { BaseDialect } from './base-dialect';
+import { DatabaseOptions } from '../database';
 export declare class MysqlDialect extends BaseDialect {
     static dialectName: string;
     getVersionGuard(): {
@@ -14,5 +15,5 @@ export declare class MysqlDialect extends BaseDialect {
         get: (v: string) => string;
         version: string;
     };
-    getSequelizeOptions(options: any): any;
+    getSequelizeOptions(options: DatabaseOptions): import("../database").IDatabaseOptions;
 }

package/lib/dialects/mysql-dialect.js

@@ -32,7 +32,6 @@ __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() {
@@ -46,7 +45,11 @@ const _MysqlDialect = class _MysqlDialect extends import_base_dialect.BaseDialec
     };
   }
   getSequelizeOptions(options) {
-    import_utils.lodash.set(options, "dialectOptions.multipleStatements", true);
+    const dialectOptions = {
+      ...options.dialectOptions || {},
+      multipleStatements: true
+    };
+    options.dialectOptions = dialectOptions;
     return options;
   }
 };

package/lib/fields/field.d.ts

@@ -10,17 +10,39 @@ import { DataType, ModelAttributeColumnOptions, ModelIndexesOptions, SyncOptions
 import { Collection } from '../collection';
 import { Database } from '../database';
 import { ModelEventTypes } from '../types';
+import { BasicType, BooleanSchema, NumberSchema, ObjectSchema, StringSchema } from 'joi';
 export interface FieldContext {
     database: Database;
     collection: Collection;
 }
-export interface BaseFieldOptions {
+type RuleSchemaMap = {
+    string: StringSchema;
+    boolean: BooleanSchema;
+    number: NumberSchema;
+    object: ObjectSchema;
+};
+export type FieldValidationRuleName<T extends BasicType> = T extends keyof RuleSchemaMap ? keyof RuleSchemaMap[T] : never;
+export interface FieldValidationRule<T extends BasicType> {
+    key: string;
+    name: FieldValidationRuleName<T>;
+    args?: {
+        [key: string]: any;
+    };
+    paramsType?: 'object';
+}
+export interface ValidationOptions<T extends BasicType = BasicType> {
+    type: T;
+    rules: FieldValidationRule<T>[];
+    [key: string]: any;
+}
+export interface BaseFieldOptions<T extends BasicType = BasicType> {
     name?: string;
     hidden?: boolean;
     translation?: boolean;
+    validation?: ValidationOptions<T>;
     [key: string]: any;
 }
-export interface BaseColumnFieldOptions extends BaseFieldOptions, Omit<ModelAttributeColumnOptions, 'type'> {
+export interface BaseColumnFieldOptions<T extends BasicType = BasicType> extends BaseFieldOptions<T>, Omit<ModelAttributeColumnOptions, 'type'> {
     dataType?: DataType;
     index?: boolean | ModelIndexesOptions;
 }
@@ -50,3 +72,4 @@ export declare abstract class Field {
     additionalSequelizeOptions(): {};
     typeToString(): any;
 }
+export {};

package/lib/fields/index.d.ts

@@ -32,6 +32,7 @@ import { UnixTimestampFieldOptions } from './unix-timestamp-field';
 import { DateOnlyFieldOptions } from './date-only-field';
 import { DatetimeNoTzFieldOptions } from './datetime-no-tz-field';
 import { DatetimeTzFieldOptions } from './datetime-tz-field';
+import { SnowflakeIdFieldOptions } from './snowflake-id-field';
 export * from './array-field';
 export * from './belongs-to-field';
 export * from './belongs-to-many-field';
@@ -60,4 +61,5 @@ export * from './virtual-field';
 export * from './nanoid-field';
 export * from './encryption-field';
 export * from './unix-timestamp-field';
-export type FieldOptions = BaseFieldOptions | StringFieldOptions | IntegerFieldOptions | FloatFieldOptions | DecimalFieldOptions | DoubleFieldOptions | RealFieldOptions | JsonFieldOptions | JsonbFieldOptions | BooleanFieldOptions | RadioFieldOptions | TextFieldOptions | VirtualFieldOptions | ArrayFieldOptions | SetFieldOptions | TimeFieldOptions | DateFieldOptions | DatetimeTzFieldOptions | DatetimeNoTzFieldOptions | DateOnlyFieldOptions | UnixTimestampFieldOptions | UidFieldOptions | UUIDFieldOptions | NanoidFieldOptions | PasswordFieldOptions | ContextFieldOptions | BelongsToFieldOptions | HasOneFieldOptions | HasManyFieldOptions | BelongsToManyFieldOptions | EncryptionField;
+export * from './snowflake-id-field';
+export type FieldOptions = BaseFieldOptions | StringFieldOptions | IntegerFieldOptions | FloatFieldOptions | DecimalFieldOptions | DoubleFieldOptions | RealFieldOptions | JsonFieldOptions | JsonbFieldOptions | BooleanFieldOptions | RadioFieldOptions | TextFieldOptions | VirtualFieldOptions | ArrayFieldOptions | SetFieldOptions | TimeFieldOptions | DateFieldOptions | DatetimeTzFieldOptions | DatetimeNoTzFieldOptions | DateOnlyFieldOptions | UnixTimestampFieldOptions | UidFieldOptions | UUIDFieldOptions | NanoidFieldOptions | PasswordFieldOptions | ContextFieldOptions | BelongsToFieldOptions | HasOneFieldOptions | HasManyFieldOptions | BelongsToManyFieldOptions | EncryptionField | SnowflakeIdFieldOptions;

package/lib/fields/index.js

@@ -51,6 +51,7 @@ __reExport(fields_exports, require("./virtual-field"), module.exports);
 __reExport(fields_exports, require("./nanoid-field"), module.exports);
 __reExport(fields_exports, require("./encryption-field"), module.exports);
 __reExport(fields_exports, require("./unix-timestamp-field"), module.exports);
+__reExport(fields_exports, require("./snowflake-id-field"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./array-field"),
@@ -80,5 +81,6 @@ __reExport(fields_exports, require("./unix-timestamp-field"), module.exports);
   ...require("./virtual-field"),
   ...require("./nanoid-field"),
   ...require("./encryption-field"),
-  ...require("./unix-timestamp-field")
+  ...require("./unix-timestamp-field"),
+  ...require("./snowflake-id-field")
 });

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

@@ -13,7 +13,7 @@ export declare abstract class NumberField extends Field {
 export declare class IntegerField extends NumberField {
     get dataType(): DataTypes.IntegerDataTypeConstructor;
 }
-export interface IntegerFieldOptions extends BaseColumnFieldOptions {
+export interface IntegerFieldOptions extends BaseColumnFieldOptions<'number'> {
     type: 'integer';
 }
 export declare class BigIntField extends NumberField {

package/lib/fields/snowflake-id-field.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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';
+interface Application {
+    snowflakeIdGenerator: {
+        generate(): number | BigInt;
+    };
+}
+export declare class SnowflakeIdField extends Field {
+    private static app;
+    static setApp(app: Application): void;
+    get dataType(): DataTypes.BigIntDataTypeConstructor;
+    private setId;
+    init(): void;
+    bind(): void;
+    unbind(): void;
+}
+export interface SnowflakeIdFieldOptions extends BaseColumnFieldOptions {
+    type: 'snowflakeId';
+    epoch?: number;
+}
+export {};

package/lib/fields/snowflake-id-field.js

@@ -0,0 +1,79 @@
+/**
+ * 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 __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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)
+    __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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var snowflake_id_field_exports = {};
+__export(snowflake_id_field_exports, {
+  SnowflakeIdField: () => SnowflakeIdField
+});
+module.exports = __toCommonJS(snowflake_id_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+const _SnowflakeIdField = class _SnowflakeIdField extends import_field.Field {
+  static setApp(app) {
+    this.app = app;
+  }
+  get dataType() {
+    return import_sequelize.DataTypes.BIGINT;
+  }
+  setId(name, instance) {
+    const value = instance.get(name);
+    if (!value) {
+      const generator = this.constructor.app.snowflakeIdGenerator;
+      instance.set(name, generator.generate());
+    }
+  }
+  init() {
+    const { name } = this.options;
+    this.listener = (instance) => this.setId(name, instance);
+    this.bulkListener = async (instances) => {
+      for (const instance of instances) {
+        this.setId(name, instance);
+      }
+    };
+  }
+  bind() {
+    super.bind();
+    this.on("beforeValidate", this.listener);
+    this.on("beforeSave", this.listener);
+    this.on("beforeBulkCreate", this.bulkListener);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeValidate", this.listener);
+    this.off("beforeSave", this.listener);
+    this.off("beforeBulkCreate", this.bulkListener);
+  }
+};
+__name(_SnowflakeIdField, "SnowflakeIdField");
+__publicField(_SnowflakeIdField, "app");
+let SnowflakeIdField = _SnowflakeIdField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SnowflakeIdField
+});

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

@@ -14,7 +14,7 @@ export declare class StringField extends Field {
         set(value: any): void;
     };
 }
-export interface StringFieldOptions extends BaseColumnFieldOptions {
+export interface StringFieldOptions extends BaseColumnFieldOptions<'string'> {
     type: 'string';
     length?: number;
     trim?: boolean;

package/lib/inherited-sync-runner.js

@@ -77,6 +77,11 @@ const _InheritedSyncRunner = class _InheritedSyncRunner {
       let maxSequenceName;
       if (childAttributes.id && childAttributes.id.autoIncrement) {
         for (const parent of parents) {
+          const attributes2 = parent.model.getAttributes();
+          const parentIdField = attributes2["id"];
+          if (!(parentIdField == null ? void 0 : parentIdField.autoIncrement)) {
+            continue;
+          }
           const sequenceNameResult = await queryInterface.sequelize.query(
             `SELECT column_default
              FROM information_schema.columns
@@ -146,8 +151,14 @@ const _InheritedSyncRunner = class _InheritedSyncRunner {
       const columns = await queryInterface.describeTable(tableName, options);
       for (const attribute in childAttributes) {
         const columnName = childAttributes[attribute].field;
+        const fieldName = childAttributes[attribute].fieldName;
         if (!columns[columnName]) {
-          await queryInterface.addColumn(tableName, columnName, childAttributes[columnName], options);
+          await queryInterface.addColumn(
+            tableName,
+            columnName,
+            childAttributes[columnName] || childAttributes[fieldName],
+            options
+          );
         }
       }
     }

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

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

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

@@ -178,6 +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" });
     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/repository.d.ts

@@ -209,6 +209,7 @@ export declare class Repository<TModelAttributes extends {} = any, TCreationAttr
      */
     firstOrCreate(options: FirstOrCreateOptions): Promise<any>;
     updateOrCreate(options: FirstOrCreateOptions): Promise<any>;
+    private validate;
     /**
      * Save instance to database
      *

package/lib/repository.js

@@ -436,6 +436,9 @@ const _Repository = class _Repository {
     }
     return this.create({ values, transaction: transaction2, context, ...rest });
   }
+  validate(options) {
+    this.collection.validate(options);
+  }
   async create(options) {
     if (Array.isArray(options.values)) {
       return this.createMany({
@@ -450,6 +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" });
     const instance = await this.model.create(values, {
       ...options,
       transaction: transaction2
@@ -494,6 +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" });
     if (options.individualHooks === false) {
       const { model: Model2 } = this.collection;
       const primaryKeyField = Model2.primaryKeyField || Model2.primaryKeyAttribute;

package/lib/update-associations.js

@@ -79,6 +79,11 @@ async function updateModelByValues(instance, values, options) {
     guard.setAssociationKeysToBeUpdate(options.updateAssociationValues);
     values = guard.sanitize(values);
   }
+  instance.constructor.collection.validate({
+    values,
+    operation: "update",
+    context: options == null ? void 0 : options.context
+  });
   await instance.update(values, options);
   await updateAssociations(instance, values, options);
 }
@@ -266,6 +271,11 @@ async function updateSingleAssociation(model, key, value, options = {}) {
       return true;
     }
   }
+  association.target.collection.validate({
+    values: value,
+    context: options.context,
+    operation: "create"
+  });
   const instance = await model[createAccessor](value, { context, transaction });
   await updateAssociations(instance, value, {
     ...options,
@@ -356,6 +366,11 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
       throw new Error(`${targetKey} field value is empty`);
     }
     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);
       await updateAssociations(instance, item, {
         ...options,
@@ -373,6 +388,11 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
         transaction
       });
       if (!instance) {
+        association.target.collection.validate({
+          values: item,
+          context: options.context,
+          operation: "create"
+        });
         instance = await model[createAccessor](item, accessorOptions);
         await updateAssociations(instance, item, {
           ...options,
@@ -392,6 +412,11 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
         if (association.associationType === "HasMany") {
           delete item[association.foreignKey];
         }
+        association.target.collection.validate({
+          values: item,
+          context: options.context,
+          operation: "update"
+        });
         await instance.update(item, { ...options, transaction });
       }
       await updateAssociations(instance, item, {

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

@@ -0,0 +1,59 @@
+/**
+ * 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 { AnySchema } from 'joi';
+import { ValidationOptions } from '../fields';
+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

@@ -0,0 +1,143 @@
+/**
+ * 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 field_validation_exports = {};
+__export(field_validation_exports, {
+  buildJoiSchema: () => buildJoiSchema,
+  getJoiErrorMessage: () => getJoiErrorMessage
+});
+module.exports = __toCommonJS(field_validation_exports);
+var import_joi = __toESM(require("joi"));
+var import_lodash = __toESM(require("lodash"));
+function buildJoiSchema(validation, options) {
+  const { type, rules } = validation;
+  const { label, value } = options;
+  if (!type || typeof type !== "string" || !(type in import_joi.default)) {
+    throw new Error(`Invalid validation type: "${type}". Type must be a valid Joi schema type.`);
+  }
+  let schema = import_joi.default[type]();
+  const isRequired = rules.some((rule) => rule.name === "required");
+  if (isRequired) {
+    schema = schema.empty(null);
+  } else {
+    schema = schema.allow(null, "");
+    if ([null, ""].includes(value)) return schema;
+  }
+  if (rules) {
+    rules.forEach((rule) => {
+      if (!import_lodash.default.isEmpty(rule.args)) {
+        if (rule.name === "pattern" && !import_lodash.default.isRegExp(rule.args.regex)) {
+          const lastSlash = rule.args.regex.lastIndexOf("/");
+          const isRegExpStr = rule.args.regex.startsWith("/") && lastSlash > 0;
+          if (isRegExpStr) {
+            rule.args.regex = rule.args.regex.slice(1, lastSlash);
+          }
+          rule.args.regex = new RegExp(rule.args.regex);
+        }
+        schema = rule.paramsType === "object" ? schema[rule.name](rule.args) : schema[rule.name](...Object.values(rule.args));
+      } else {
+        schema = schema[rule.name]();
+      }
+    });
+  }
+  if (label) {
+    schema = schema.label(label);
+  }
+  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
+});

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "1.9.0-beta.8",
+  "version": "2.0.0-alpha.2",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
   "dependencies": {
-    "@nocobase/logger": "1.9.0-beta.8",
-    "@nocobase/utils": "1.9.0-beta.8",
+    "@nocobase/logger": "2.0.0-alpha.2",
+    "@nocobase/utils": "2.0.0-alpha.2",
     "async-mutex": "^0.3.2",
     "chalk": "^4.1.1",
     "cron-parser": "4.4.0",
@@ -18,6 +18,7 @@
     "flat": "^5.0.2",
     "glob": "^7.1.6",
     "graphlib": "^2.1.8",
+    "joi": "^17.13.3",
     "lodash": "^4.17.21",
     "mathjs": "^10.6.1",
     "nanoid": "^3.3.11",
@@ -38,5 +39,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "f3d4f3d1ba7adbf4d4c60e656c23da45565769c8"
+  "gitHead": "1322f486b248bef53ed8c8f42f0a39dfd02125fd"
 }