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

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;

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,13 @@
+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;
+}

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 } = this.options;
+    this.listener = async (instance) => {
+      const value = instance.get(name);
+      if (!value) {
+        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.js

@@ -27,7 +27,7 @@ const _UuidField = class _UuidField extends import_field.Field {
   constructor(options, context) {
     super(
       {
-        defaultValue: import_sequelize.DataTypes.UUIDV4,
+        defaultValue: new import_sequelize.DataTypes.UUIDV4(),
         ...options
       },
       context

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.1",
   "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.1",
+    "@nocobase/utils": "0.21.0-alpha.1",
     "async-mutex": "^0.3.2",
     "chalk": "^4.1.1",
     "cron-parser": "4.4.0",
@@ -35,5 +35,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "5473d9039cfdb649a8c8c625edefc9a3ac464be5"
+  "gitHead": "afd2f3d1341b85ea9daa7b2667dd4ace1fafb7ff"
 }