@nocobase/database 0.20.0-alpha.9 → 0.21.0-alpha.2

package/lib/collection.js

@@ -260,9 +260,6 @@ const _Collection = class _Collection extends import_events.EventEmitter {
         `Field type conflict: cannot set "${name}" on "${this.name}" to ${options.type}, parent "${name}" type is ${oldField.options.type}`
       );
     }
-    if (this.options.autoGenId !== false && options.primaryKey) {
-      this.model.removeAttribute("id");
-    }
     this.removeField(name);
     this.fields.set(name, field);
     this.emit("field.afterAdd", field);

package/lib/database.d.ts

@@ -10,7 +10,7 @@ import { CollectionFactory } from './collection-factory';
 import { CollectionGroupManager } from './collection-group-manager';
 import { ImportFileExtension } from './collection-importer';
 import DatabaseUtils from './database-utils';
-import ReferencesMap from './features/ReferencesMap';
+import ReferencesMap from './features/references-map';
 import { ArrayFieldRepository } from './field-repository/array-field-repository';
 import * as FieldTypes from './fields';
 import { Field, FieldContext, RelationField } from './fields';

package/lib/database.js

@@ -52,7 +52,7 @@ var import_collection_factory = require("./collection-factory");
 var import_collection_group_manager = require("./collection-group-manager");
 var import_collection_importer = require("./collection-importer");
 var import_database_utils = __toESM(require("./database-utils"));
-var import_ReferencesMap = __toESM(require("./features/ReferencesMap"));
+var import_references_map = __toESM(require("./features/references-map"));
 var import_referential_integrity_check = require("./features/referential-integrity-check");
 var FieldTypes = __toESM(require("./fields"));
 var import_helpers = require("./helpers");
@@ -137,7 +137,7 @@ const _Database = class _Database extends import_events.EventEmitter {
   context = {};
   queryInterface;
   utils = new import_database_utils.default(this);
-  referenceMap = new import_ReferencesMap.default();
+  referenceMap = new import_references_map.default();
   inheritanceMap = new import_inherited_map.default();
   importedFrom = /* @__PURE__ */ new Map();
   modelHook;
@@ -183,7 +183,13 @@ const _Database = class _Database extends import_events.EventEmitter {
       opts.timezone = "+00:00";
     }
     if (options.dialect === "postgres") {
-      require("pg").defaults.parseInt8 = true;
+      const types = require("pg").types;
+      types.setTypeParser(types.builtins.INT8, function(val) {
+        if (val <= Number.MAX_SAFE_INTEGER) {
+          return Number(val);
+        }
+        return val;
+      });
     }
     this.options = opts;
     const sequelizeOptions = this.sequelizeOptions(this.options);

package/lib/decorators/must-have-filter-decorator.js

@@ -21,6 +21,7 @@ __export(must_have_filter_decorator_exports, {
   default: () => must_have_filter_decorator_default
 });
 module.exports = __toCommonJS(must_have_filter_decorator_exports);
+var import_utils = require("@nocobase/utils");
 const mustHaveFilter = /* @__PURE__ */ __name(() => (target, propertyKey, descriptor) => {
   const oldValue = descriptor.value;
   descriptor.value = function(...args) {
@@ -28,7 +29,7 @@ const mustHaveFilter = /* @__PURE__ */ __name(() => (target, propertyKey, descri
     if (Array.isArray(options.values)) {
       return oldValue.apply(this, args);
     }
-    if (!(options == null ? void 0 : options.filter) && !(options == null ? void 0 : options.filterByTk) && !(options == null ? void 0 : options.forceUpdate)) {
+    if (!(0, import_utils.isValidFilter)(options == null ? void 0 : options.filter) && !(options == null ? void 0 : options.filterByTk) && !(options == null ? void 0 : options.forceUpdate)) {
       throw new Error(`must provide filter or filterByTk for ${propertyKey} call, or set forceUpdate to true`);
     }
     return oldValue.apply(this, args);

package/lib/features/{ReferencesMap.d.ts → references-map.d.ts}

@@ -1,10 +1,13 @@
+export type ReferencePriority = 'default' | 'user';
 export interface Reference {
     sourceCollectionName: string;
     sourceField: string;
     targetField: string;
     targetCollectionName: string;
     onDelete: string;
+    priority: ReferencePriority;
 }
+export declare function buildReference(options: Partial<Reference>): Reference;
 declare class ReferencesMap {
     protected map: Map<string, Reference[]>;
     addReference(reference: Reference): void;

package/lib/features/{ReferencesMap.js → references-map.js}

@@ -16,30 +16,56 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var ReferencesMap_exports = {};
-__export(ReferencesMap_exports, {
-  default: () => ReferencesMap_default
+var references_map_exports = {};
+__export(references_map_exports, {
+  buildReference: () => buildReference,
+  default: () => references_map_default
 });
-module.exports = __toCommonJS(ReferencesMap_exports);
+module.exports = __toCommonJS(references_map_exports);
+const DEFAULT_ON_DELETE = "NO ACTION";
+function buildReference(options) {
+  const { sourceCollectionName, sourceField, targetField, targetCollectionName, onDelete, priority } = options;
+  return {
+    sourceCollectionName,
+    sourceField,
+    targetField,
+    targetCollectionName,
+    onDelete: (onDelete || DEFAULT_ON_DELETE).toUpperCase(),
+    priority: assignPriority(priority, onDelete)
+  };
+}
+__name(buildReference, "buildReference");
+function assignPriority(priority, onDelete) {
+  if (priority) {
+    return priority;
+  }
+  return onDelete ? "user" : "default";
+}
+__name(assignPriority, "assignPriority");
+const PRIORITY_MAP = {
+  default: 1,
+  user: 2
+};
 const _ReferencesMap = class _ReferencesMap {
   map = /* @__PURE__ */ new Map();
   addReference(reference) {
-    if (!reference.onDelete) {
-      reference.onDelete = "SET NULL";
-    }
-    reference.onDelete = reference.onDelete.toUpperCase();
     const existReference = this.existReference(reference);
     if (existReference && existReference.onDelete !== reference.onDelete) {
-      if (reference.onDelete === "SET NULL") {
-        return;
-      } else if (existReference.onDelete === "SET NULL") {
+      const existPriority = PRIORITY_MAP[existReference.priority];
+      const newPriority = PRIORITY_MAP[reference.priority];
+      if (newPriority > existPriority) {
         existReference.onDelete = reference.onDelete;
-      } else {
-        throw new Error(
-          `On Delete Conflict, exist reference ${JSON.stringify(existReference)}, new reference ${JSON.stringify(
-            reference
-          )}`
-        );
+        existReference.priority = reference.priority;
+      } else if (newPriority === existPriority && newPriority === PRIORITY_MAP["user"]) {
+        if (existReference.onDelete === "SET NULL" && reference.onDelete === "CASCADE") {
+          existReference.onDelete = reference.onDelete;
+        } else {
+          throw new Error(
+            `On Delete Conflict, exist reference ${JSON.stringify(existReference)}, new reference ${JSON.stringify(
+              reference
+            )}`
+          );
+        }
       }
     }
     if (!existReference) {
@@ -57,7 +83,7 @@ const _ReferencesMap = class _ReferencesMap {
     if (!references) {
       return null;
     }
-    const keys = Object.keys(reference).filter((k) => k !== "onDelete");
+    const keys = Object.keys(reference).filter((k) => k !== "onDelete" && k !== "priority");
     return references.find((ref) => keys.every((key) => ref[key] === reference[key]));
   }
   removeReference(reference) {
@@ -74,4 +100,8 @@ const _ReferencesMap = class _ReferencesMap {
 };
 __name(_ReferencesMap, "ReferencesMap");
 let ReferencesMap = _ReferencesMap;
-var ReferencesMap_default = ReferencesMap;
+var references_map_default = ReferencesMap;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildReference
+});

package/lib/features/referential-integrity-check.js

@@ -31,6 +31,9 @@ async function referentialIntegrityCheck(options) {
   }
   for (const reference of references) {
     const { sourceCollectionName, sourceField, targetField, onDelete } = reference;
+    if (onDelete === "NO ACTION") {
+      continue;
+    }
     const sourceCollection = db.collections.get(sourceCollectionName);
     const sourceRepository = sourceCollection.repository;
     if (sourceCollection.isView()) {

package/lib/fields/belongs-to-field.d.ts

@@ -1,17 +1,11 @@
 import { BelongsToOptions as SequelizeBelongsToOptions } from 'sequelize';
-import { Reference } from '../features/ReferencesMap';
+import { Reference, ReferencePriority } from '../features/references-map';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
 export declare class BelongsToField extends RelationField {
     static type: string;
     get dataType(): string;
     get target(): any;
-    static toReference(db: any, association: any, onDelete: any): {
-        sourceCollectionName: any;
-        sourceField: any;
-        targetField: any;
-        targetCollectionName: any;
-        onDelete: any;
-    };
+    static toReference(db: any, association: any, onDelete: any, priority?: ReferencePriority): Reference;
     reference(association: any): Reference;
     checkAssociationKeys(): void;
     bind(): boolean;

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

@@ -38,6 +38,7 @@ __export(belongs_to_field_exports, {
 module.exports = __toCommonJS(belongs_to_field_exports);
 var import_lodash = __toESM(require("lodash"));
 var import_sequelize = require("sequelize");
+var import_references_map = require("../features/references-map");
 var import_utils = require("../utils");
 var import_relation_field = require("./relation-field");
 const _BelongsToField = class _BelongsToField extends import_relation_field.RelationField {
@@ -48,18 +49,24 @@ const _BelongsToField = class _BelongsToField extends import_relation_field.Rela
     const { target, name } = this.options;
     return target || import_sequelize.Utils.pluralize(name);
   }
-  static toReference(db, association, onDelete) {
+  static toReference(db, association, onDelete, priority = "default") {
     const targetKey = association.targetKey;
-    return {
+    return (0, import_references_map.buildReference)({
       sourceCollectionName: db.modelCollection.get(association.source).name,
       sourceField: association.foreignKey,
       targetField: targetKey,
       targetCollectionName: db.modelCollection.get(association.target).name,
-      onDelete
-    };
+      onDelete,
+      priority
+    });
   }
   reference(association) {
-    return _BelongsToField.toReference(this.database, association, this.options.onDelete);
+    return _BelongsToField.toReference(
+      this.database,
+      association,
+      this.options.onDelete,
+      this.options.onDelete ? "user" : "default"
+    );
   }
   checkAssociationKeys() {
     let { foreignKey, targetKey } = this.options;

package/lib/fields/belongs-to-many-field.d.ts

@@ -1,5 +1,5 @@
 import { AssociationScope, BelongsToManyOptions as SequelizeBelongsToManyOptions } from 'sequelize';
-import { Reference } from '../features/ReferencesMap';
+import { Reference } from '../features/references-map';
 import { MultipleRelationFieldOptions, RelationField } from './relation-field';
 export declare class BelongsToManyField extends RelationField {
     get dataType(): string;

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

@@ -41,6 +41,7 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
   references(association) {
     const db = this.context.database;
     const onDelete = this.options.onDelete || "CASCADE";
+    const priority = this.options.onDelete ? "user" : "default";
     const targetAssociation = association.toTarget;
     if (association.targetKey) {
       targetAssociation.targetKey = association.targetKey;
@@ -50,8 +51,8 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
       sourceAssociation.targetKey = association.sourceKey;
     }
     return [
-      import_belongs_to_field.BelongsToField.toReference(db, targetAssociation, onDelete),
-      import_belongs_to_field.BelongsToField.toReference(db, sourceAssociation, onDelete)
+      import_belongs_to_field.BelongsToField.toReference(db, targetAssociation, onDelete, priority),
+      import_belongs_to_field.BelongsToField.toReference(db, sourceAssociation, onDelete, priority)
     ];
   }
   checkAssociationKeys(database) {
@@ -126,9 +127,6 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
       Through = database.collection(throughCollectionOptions);
       Object.defineProperty(Through.model, "isThrough", { value: true });
     }
-    if (!this.options.onDelete) {
-      this.options.onDelete = "CASCADE";
-    }
     const belongsToManyOptions = {
       constraints: false,
       ...(0, import_lodash.omit)(this.options, ["name", "type", "target"]),

package/lib/fields/has-many-field.d.ts

@@ -1,5 +1,5 @@
 import { AssociationScope, DataType, ForeignKeyOptions, HasManyOptions, HasManyOptions as SequelizeHasManyOptions } from 'sequelize';
-import { Reference } from '../features/ReferencesMap';
+import { Reference } from '../features/references-map';
 import { MultipleRelationFieldOptions, RelationField } from './relation-field';
 export interface HasManyFieldOptions extends HasManyOptions {
     /**

package/lib/fields/has-many-field.js

@@ -23,6 +23,7 @@ __export(has_many_field_exports, {
 module.exports = __toCommonJS(has_many_field_exports);
 var import_lodash = require("lodash");
 var import_sequelize = require("sequelize");
+var import_references_map = require("../features/references-map");
 var import_utils = require("../utils");
 var import_relation_field = require("./relation-field");
 const _HasManyField = class _HasManyField extends import_relation_field.RelationField {
@@ -38,13 +39,13 @@ const _HasManyField = class _HasManyField extends import_relation_field.Relation
   }
   reference(association) {
     const sourceKey = association.sourceKey;
-    return {
+    return (0, import_references_map.buildReference)({
       sourceCollectionName: this.database.modelCollection.get(association.target).name,
       sourceField: association.foreignKey,
       targetField: sourceKey,
       targetCollectionName: this.database.modelCollection.get(association.source).name,
       onDelete: this.options.onDelete
-    };
+    });
   }
   checkAssociationKeys() {
     let { foreignKey, sourceKey } = this.options;

package/lib/fields/has-one-field.d.ts

@@ -1,5 +1,5 @@
 import { AssociationScope, DataType, ForeignKeyOptions, HasOneOptions, HasOneOptions as SequelizeHasOneOptions } from 'sequelize';
-import { Reference } from '../features/ReferencesMap';
+import { Reference } from '../features/references-map';
 import { BaseRelationFieldOptions, RelationField } from './relation-field';
 export interface HasOneFieldOptions extends HasOneOptions {
     /**

package/lib/fields/has-one-field.js

@@ -23,6 +23,7 @@ __export(has_one_field_exports, {
 module.exports = __toCommonJS(has_one_field_exports);
 var import_lodash = require("lodash");
 var import_sequelize = require("sequelize");
+var import_references_map = require("../features/references-map");
 var import_utils = require("../utils");
 var import_relation_field = require("./relation-field");
 const _HasOneField = class _HasOneField extends import_relation_field.RelationField {
@@ -45,13 +46,13 @@ const _HasOneField = class _HasOneField extends import_relation_field.RelationFi
   }
   reference(association) {
     const sourceKey = association.sourceKey;
-    return {
+    return (0, import_references_map.buildReference)({
       sourceCollectionName: this.database.modelCollection.get(association.target).name,
       sourceField: association.foreignKey,
       targetField: sourceKey,
       targetCollectionName: this.database.modelCollection.get(association.source).name,
       onDelete: this.options.onDelete
-    };
+    });
   }
   checkAssociationKeys() {
     let { foreignKey, sourceKey } = this.options;

package/lib/fields/index.d.ts

@@ -19,6 +19,7 @@ import { TimeFieldOptions } from './time-field';
 import { UidFieldOptions } from './uid-field';
 import { UUIDFieldOptions } from './uuid-field';
 import { VirtualFieldOptions } from './virtual-field';
+import { NanoidFieldOptions } from './nanoid-field';
 export * from './array-field';
 export * from './belongs-to-field';
 export * from './belongs-to-many-field';
@@ -41,4 +42,5 @@ export * from './time-field';
 export * from './uid-field';
 export * from './uuid-field';
 export * from './virtual-field';
-export type FieldOptions = BaseFieldOptions | StringFieldOptions | IntegerFieldOptions | FloatFieldOptions | DecimalFieldOptions | DoubleFieldOptions | RealFieldOptions | JsonFieldOptions | JsonbFieldOptions | BooleanFieldOptions | RadioFieldOptions | SortFieldOptions | TextFieldOptions | VirtualFieldOptions | ArrayFieldOptions | SetFieldOptions | TimeFieldOptions | DateFieldOptions | UidFieldOptions | UUIDFieldOptions | PasswordFieldOptions | ContextFieldOptions | BelongsToFieldOptions | HasOneFieldOptions | HasManyFieldOptions | BelongsToManyFieldOptions;
+export * from './nanoid-field';
+export type FieldOptions = BaseFieldOptions | StringFieldOptions | IntegerFieldOptions | FloatFieldOptions | DecimalFieldOptions | DoubleFieldOptions | RealFieldOptions | JsonFieldOptions | JsonbFieldOptions | BooleanFieldOptions | RadioFieldOptions | SortFieldOptions | TextFieldOptions | VirtualFieldOptions | ArrayFieldOptions | SetFieldOptions | TimeFieldOptions | DateFieldOptions | UidFieldOptions | UUIDFieldOptions | NanoidFieldOptions | PasswordFieldOptions | ContextFieldOptions | BelongsToFieldOptions | HasOneFieldOptions | HasManyFieldOptions | BelongsToManyFieldOptions;

package/lib/fields/index.js

@@ -36,6 +36,7 @@ __reExport(fields_exports, require("./time-field"), module.exports);
 __reExport(fields_exports, require("./uid-field"), module.exports);
 __reExport(fields_exports, require("./uuid-field"), module.exports);
 __reExport(fields_exports, require("./virtual-field"), module.exports);
+__reExport(fields_exports, require("./nanoid-field"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./array-field"),
@@ -59,5 +60,6 @@ __reExport(fields_exports, require("./virtual-field"), module.exports);
   ...require("./time-field"),
   ...require("./uid-field"),
   ...require("./uuid-field"),
-  ...require("./virtual-field")
+  ...require("./virtual-field"),
+  ...require("./nanoid-field")
 });

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

@@ -0,0 +1,14 @@
+import { DataTypes } from 'sequelize';
+import { BaseColumnFieldOptions, Field } from './field';
+export declare class NanoidField extends Field {
+    get dataType(): DataTypes.StringDataTypeConstructor;
+    init(): void;
+    bind(): void;
+    unbind(): void;
+}
+export interface NanoidFieldOptions extends BaseColumnFieldOptions {
+    type: 'nanoid';
+    size?: number;
+    customAlphabet?: string;
+    autoFill?: boolean;
+}

package/lib/fields/nanoid-field.js

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nanoid_field_exports = {};
+__export(nanoid_field_exports, {
+  NanoidField: () => NanoidField
+});
+module.exports = __toCommonJS(nanoid_field_exports);
+var import_sequelize = require("sequelize");
+var import_field = require("./field");
+var import_nanoid = require("nanoid");
+const DEFAULT_SIZE = 12;
+const _NanoidField = class _NanoidField extends import_field.Field {
+  get dataType() {
+    return import_sequelize.DataTypes.STRING;
+  }
+  init() {
+    const { name, size, customAlphabet: customAlphabetOptions, autoFill } = this.options;
+    this.listener = async (instance) => {
+      const value = instance.get(name);
+      if (!value && autoFill !== false) {
+        const nanoIdFunc = customAlphabetOptions ? (0, import_nanoid.customAlphabet)(customAlphabetOptions) : import_nanoid.nanoid;
+        instance.set(name, nanoIdFunc(size || DEFAULT_SIZE));
+      }
+    };
+  }
+  bind() {
+    super.bind();
+    this.on("beforeCreate", this.listener);
+    this.on("beforeUpdate", this.listener);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeCreate", this.listener);
+    this.off("beforeUpdate", this.listener);
+  }
+};
+__name(_NanoidField, "NanoidField");
+let NanoidField = _NanoidField;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NanoidField
+});

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

@@ -1,9 +1,12 @@
 import { DataTypes } from 'sequelize';
-import { BaseColumnFieldOptions, Field, FieldContext } from './field';
+import { BaseColumnFieldOptions, Field } from './field';
 export declare class UuidField extends Field {
-    constructor(options?: any, context?: FieldContext);
     get dataType(): DataTypes.AbstractDataTypeConstructor;
+    init(): void;
+    bind(): void;
+    unbind(): void;
 }
 export interface UUIDFieldOptions extends BaseColumnFieldOptions {
     type: 'uuid';
+    autoFill?: boolean;
 }

package/lib/fields/uuid-field.js

@@ -23,19 +23,30 @@ __export(uuid_field_exports, {
 module.exports = __toCommonJS(uuid_field_exports);
 var import_sequelize = require("sequelize");
 var import_field = require("./field");
+var import_uuid = require("uuid");
 const _UuidField = class _UuidField extends import_field.Field {
-  constructor(options, context) {
-    super(
-      {
-        defaultValue: import_sequelize.DataTypes.UUIDV4,
-        ...options
-      },
-      context
-    );
-  }
   get dataType() {
     return import_sequelize.DataTypes.UUID;
   }
+  init() {
+    const { name, autoFill } = this.options;
+    this.listener = async (instance) => {
+      const value = instance.get(name);
+      if (!value && autoFill !== false) {
+        instance.set(name, (0, import_uuid.v4)());
+      }
+    };
+  }
+  bind() {
+    super.bind();
+    this.on("beforeCreate", this.listener);
+    this.on("beforeUpdate", this.listener);
+  }
+  unbind() {
+    super.unbind();
+    this.off("beforeCreate", this.listener);
+    this.off("beforeUpdate", this.listener);
+  }
 };
 __name(_UuidField, "UuidField");
 let UuidField = _UuidField;

package/lib/repository.js

@@ -44,6 +44,7 @@ module.exports = __toCommonJS(repository_exports);
 var import_flat = require("flat");
 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");
@@ -469,7 +470,7 @@ const _Repository = class _Repository {
         transaction: transaction2
       });
     }
-    if (options.filter) {
+    if (options.filter && (0, import_utils.isValidFilter)(options.filter)) {
       if (this.collection.model.primaryKeyAttributes.length !== 1 && !import_lodash.default.get(this.collection.options, "filterTargetKey")) {
         const queryOptions = {
           ...this.buildQueryOptions(options)

package/lib/sync-runner.d.ts

@@ -5,6 +5,7 @@ export declare class SyncRunner {
     private readonly collection;
     private readonly database;
     private tableDescMap;
+    private uniqueAttributes;
     constructor(model: typeof Model);
     get tableName(): string | {
         tableName: string;
@@ -17,6 +18,8 @@ export declare class SyncRunner {
         [attribute: string]: import("sequelize").ModelAttributeColumnOptions<SequelizeModel<any, any>>;
     };
     runSync(options: any): Promise<any>;
+    handleUniqueFieldBeforeSync(beforeColumns: any, options: any): Promise<void>;
+    handlePrimaryKeyBeforeSync(columns: any, options: any): Promise<void>;
     handlePrimaryKey(columns: any, options: any): Promise<void>;
     handleDefaultValues(columns: any, options: any): Promise<void>;
     handleUniqueIndex(options: any): Promise<void>;

package/lib/sync-runner.js

@@ -34,6 +34,7 @@ const _SyncRunner = class _SyncRunner {
   collection;
   database;
   tableDescMap = {};
+  uniqueAttributes = [];
   get tableName() {
     return this.model.getTableName();
   }
@@ -68,6 +69,15 @@ const _SyncRunner = class _SyncRunner {
       }
       throw e;
     }
+    try {
+      const beforeColumns = await this.queryInterface.describeTable(this.tableName, options);
+      await this.handlePrimaryKeyBeforeSync(beforeColumns, options);
+      await this.handleUniqueFieldBeforeSync(beforeColumns, options);
+    } catch (e) {
+      if (!e.message.includes("No description found")) {
+        throw e;
+      }
+    }
     const syncResult = await this.performSync(options);
     const columns = await this.queryInterface.describeTable(this.tableName, options);
     await this.handlePrimaryKey(columns, options);
@@ -75,10 +85,34 @@ const _SyncRunner = class _SyncRunner {
     await this.handleUniqueIndex(options);
     return syncResult;
   }
-  async handlePrimaryKey(columns, options) {
-    if (!this.database.inDialect("postgres")) {
+  async handleUniqueFieldBeforeSync(beforeColumns, options) {
+    if (!this.database.inDialect("sqlite")) {
       return;
     }
+    const newAttributes = Object.keys(this.rawAttributes).filter((key) => {
+      return !Object.keys(beforeColumns).includes(this.rawAttributes[key].field) && this.rawAttributes[key].unique;
+    });
+    this.uniqueAttributes = newAttributes;
+    for (const newAttribute of newAttributes) {
+      this.rawAttributes[newAttribute].unique = false;
+    }
+  }
+  async handlePrimaryKeyBeforeSync(columns, options) {
+    const columnsBePrimaryKey = Object.keys(columns).filter((key) => {
+      return columns[key].primaryKey == true;
+    }).sort();
+    const columnsWillBePrimaryKey = Object.keys(this.rawAttributes).filter((key) => {
+      return this.rawAttributes[key].primaryKey == true;
+    }).map((key) => {
+      return this.rawAttributes[key].field;
+    }).sort();
+    if (columnsBePrimaryKey.length == 1 && !columnsWillBePrimaryKey.includes(columnsBePrimaryKey[0])) {
+      if (this.database.inDialect("mariadb", "mysql")) {
+        await this.sequelize.query(`ALTER TABLE ${this.collection.quotedTableName()} DROP PRIMARY KEY;`, options);
+      }
+    }
+  }
+  async handlePrimaryKey(columns, options) {
     try {
       const columnsBePrimaryKey = Object.keys(columns).filter((key) => {
         return columns[key].primaryKey == true;
@@ -91,18 +125,26 @@ const _SyncRunner = class _SyncRunner {
       if (columnsWillBePrimaryKey.length == 0) {
         return;
       }
-      if (JSON.stringify(columnsBePrimaryKey) != JSON.stringify(columnsWillBePrimaryKey)) {
-        await this.queryInterface.addConstraint(this.tableName, {
-          type: "primary key",
-          fields: columnsWillBePrimaryKey,
-          name: `${this.collection.tableName()}_${columnsWillBePrimaryKey.join("_")}_pk`,
-          transaction: options == null ? void 0 : options.transaction
-        });
+      if (columnsWillBePrimaryKey.length == 1 && JSON.stringify(columnsBePrimaryKey) != JSON.stringify(columnsWillBePrimaryKey)) {
+        if (this.database.inDialect("mariadb", "mysql")) {
+          await this.sequelize.query(
+            `ALTER TABLE ${this.collection.quotedTableName()} ADD PRIMARY KEY (${columnsWillBePrimaryKey[0]});`,
+            options
+          );
+        } else {
+          await this.queryInterface.addConstraint(this.tableName, {
+            type: "primary key",
+            fields: columnsWillBePrimaryKey,
+            name: `${this.collection.tableName()}_${columnsWillBePrimaryKey.join("_")}_pk`,
+            transaction: options == null ? void 0 : options.transaction
+          });
+        }
       }
     } catch (e) {
       if (e.message.includes("No description found")) {
         return;
       }
+      throw e;
     }
   }
   async handleDefaultValues(columns, options) {
@@ -154,6 +196,9 @@ const _SyncRunner = class _SyncRunner {
     }
   }
   async handleUniqueIndex(options) {
+    for (const uniqueAttribute of this.uniqueAttributes) {
+      this.rawAttributes[uniqueAttribute].unique = true;
+    }
     const existsIndexes = await this.queryInterface.showIndex(this.collection.getTableNameWithSchema(), options);
     const existsUniqueIndexes = existsIndexes.filter((index) => index.unique);
     const uniqueAttributes = Object.keys(this.rawAttributes).filter((key) => {
@@ -190,7 +235,8 @@ const _SyncRunner = class _SyncRunner {
       if (!indexExists) {
         await this.queryInterface.addIndex(this.tableName, [this.rawAttributes[uniqueAttribute].field], {
           unique: true,
-          transaction: options == null ? void 0 : options.transaction
+          transaction: options == null ? void 0 : options.transaction,
+          name: `${this.collection.tableName()}_${this.rawAttributes[uniqueAttribute].field}_uk`
         });
       }
     }

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

@@ -1,10 +1,10 @@
 declare const _default: {
     postgres: {
-        'character varying': string;
-        varchar: string;
+        'character varying': string[];
+        varchar: string[];
+        char: string[];
         character: string;
         text: string;
-        char: string;
         oid: string;
         name: string;
         smallint: string[];
@@ -34,10 +34,10 @@ declare const _default: {
         'smallint unsigned': string[];
         'tinyint unsigned': string[];
         'mediumint unsigned': string[];
-        char: string;
+        char: string[];
+        varchar: string[];
         date: string;
         time: string;
-        varchar: string;
         text: string;
         longtext: string;
         int: string[];
@@ -52,10 +52,11 @@ declare const _default: {
         datetime: string;
         timestamp: string;
         json: string[];
+        enum: string;
     };
     sqlite: {
         text: string;
-        varchar: string;
+        varchar: string[];
         integer: string;
         real: string;
         datetime: string;
@@ -72,10 +73,10 @@ declare const _default: {
         'smallint unsigned': string[];
         'tinyint unsigned': string[];
         'mediumint unsigned': string[];
-        char: string;
+        char: string[];
+        varchar: string[];
         date: string;
         time: string;
-        varchar: string;
         text: string;
         longtext: string;
         int: string[];
@@ -90,6 +91,7 @@ declare const _default: {
         datetime: string;
         timestamp: string;
         json: string[];
+        enum: string;
     };
 };
 export default _default;

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

@@ -21,11 +21,11 @@ __export(field_type_map_exports, {
 });
 module.exports = __toCommonJS(field_type_map_exports);
 const postgres = {
-  "character varying": "string",
-  varchar: "string",
+  "character varying": ["string", "uuid", "nanoid"],
+  varchar: ["string", "uuid", "nanoid"],
+  char: ["string", "uuid", "nanoid"],
   character: "string",
   text: "text",
-  char: "string",
   oid: "string",
   name: "string",
   smallint: ["integer", "sort"],
@@ -46,7 +46,7 @@ const postgres = {
   path: "json",
   polygon: "json",
   circle: "json",
-  uuid: "string"
+  uuid: "uuid"
 };
 const mysql = {
   smallint: ["integer", "boolean", "sort"],
@@ -55,10 +55,10 @@ const mysql = {
   "smallint unsigned": ["integer", "boolean", "sort"],
   "tinyint unsigned": ["integer", "boolean", "sort"],
   "mediumint unsigned": ["integer", "boolean", "sort"],
-  char: "string",
+  char: ["string", "uuid", "nanoid"],
+  varchar: ["string", "uuid", "nanoid"],
   date: "date",
   time: "time",
-  varchar: "string",
   text: "text",
   longtext: "text",
   int: ["integer", "sort"],
@@ -72,11 +72,12 @@ const mysql = {
   decimal: "decimal",
   datetime: "date",
   timestamp: "date",
-  json: ["json", "array"]
+  json: ["json", "array"],
+  enum: "string"
 };
 const sqlite = {
   text: "text",
-  varchar: "string",
+  varchar: ["string", "uuid", "nanoid"],
   integer: "integer",
   real: "real",
   datetime: "date",

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "0.20.0-alpha.9",
+  "version": "0.21.0-alpha.2",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "0.20.0-alpha.9",
-    "@nocobase/utils": "0.20.0-alpha.9",
+    "@nocobase/logger": "0.21.0-alpha.2",
+    "@nocobase/utils": "0.21.0-alpha.2",
     "async-mutex": "^0.3.2",
     "chalk": "^4.1.1",
     "cron-parser": "4.4.0",
@@ -25,7 +25,8 @@
     "qs": "^6.11.2",
     "semver": "^7.3.7",
     "sequelize": "^6.26.0",
-    "umzug": "^3.1.1"
+    "umzug": "^3.1.1",
+    "uuid": "^9.0.1"
   },
   "devDependencies": {
     "@types/glob": "^7.2.0"
@@ -35,5 +36,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "5473d9039cfdb649a8c8c625edefc9a3ac464be5"
+  "gitHead": "90628f2e2da846208fb2d7966ddb4e467d187ffb"
 }