@nocobase/database 0.18.0-alpha.9 → 0.19.0-alpha.2

package/lib/collection-factory.d.ts

@@ -4,6 +4,7 @@ import { Model } from './model';
 type CollectionTypeOptions = {
     condition: (options: CollectionOptions) => boolean;
     onSync?: (model: typeof Model, options: any) => Promise<void>;
+    onDump?: (dumper: any, collection: Collection) => Promise<void>;
 };
 export declare class CollectionFactory {
     private database;

package/lib/collection-group-manager.d.ts

@@ -1,13 +1,26 @@
+import { BaseDumpRules, DumpRules } from './collection';
 import Database from './database';
+type RequiredGroup = 'required';
+type SkippedGroup = 'skipped';
+export type BuiltInGroup = RequiredGroup | SkippedGroup;
+export type DumpRulesGroupType = BuiltInGroup | string;
 export interface CollectionGroup {
-    namespace: string;
     collections: string[];
     function: string;
-    dumpable: 'required' | 'optional' | 'skip';
+    dataType: DumpRulesGroupType;
     delayRestore?: any;
 }
+export interface CollectionGroupWithCollectionTitle extends Omit<CollectionGroup, 'collections'> {
+    collections: Array<{
+        name: string;
+        title: string;
+    }>;
+}
 export declare class CollectionGroupManager {
     db: Database;
     constructor(db: Database);
-    getGroups(): CollectionGroup[];
+    static unifyDumpRules(dumpRules: DumpRules): (BaseDumpRules & {
+        group: DumpRulesGroupType;
+    }) | undefined;
 }
+export {};

package/lib/collection-group-manager.js

@@ -21,70 +21,32 @@ __export(collection_group_manager_exports, {
   CollectionGroupManager: () => CollectionGroupManager
 });
 module.exports = __toCommonJS(collection_group_manager_exports);
-var import_lodash = require("lodash");
 const _CollectionGroupManager = class _CollectionGroupManager {
   constructor(db) {
     this.db = db;
   }
-  getGroups() {
-    const collections = [...this.db.collections.values()];
-    const groups = /* @__PURE__ */ new Map();
-    const skipped = [];
-    for (const collection of collections) {
-      const groupKey = collection.options.namespace;
-      if (!groupKey) {
-        continue;
-      }
-      const [namespace, groupFunc] = groupKey.split(".");
-      if (!groupFunc) {
-        skipped.push({
-          name: collection.name,
-          reason: "no-group-function"
-        });
-        continue;
-      }
-      if (!groups.has(groupKey)) {
-        const dumpable = (() => {
-          if (!collection.options.duplicator) {
-            return void 0;
-          }
-          if ((0, import_lodash.isString)(collection.options.duplicator)) {
-            return {
-              dumpable: collection.options.duplicator
-            };
-          }
-          return collection.options.duplicator;
-        })();
-        if (!dumpable) {
-          skipped.push({
-            name: collection.name,
-            reason: "no-dumpable"
-          });
-          continue;
-        }
-        const group2 = {
-          namespace,
-          function: groupFunc,
-          collections: dumpable.with ? (0, import_lodash.castArray)(dumpable.with) : [],
-          dumpable: dumpable.dumpable
-        };
-        if (dumpable.delayRestore) {
-          group2.delayRestore = dumpable.delayRestore;
-        }
-        groups.set(groupKey, group2);
-      }
-      const group = groups.get(groupKey);
-      group.collections.push(collection.name);
+  static unifyDumpRules(dumpRules) {
+    if (!dumpRules) {
+      return void 0;
     }
-    const results = [...groups.values()];
-    const groupCollections = results.map((i) => i.collections).flat();
-    for (const skipItem of skipped) {
-      if (groupCollections.includes(skipItem.name)) {
-        continue;
-      }
-      this.db.logger.warn(`collection ${skipItem.name} is not in any collection group, reason: ${skipItem.reason}.`);
+    if (typeof dumpRules === "string") {
+      return {
+        group: dumpRules
+      };
     }
-    return results;
+    if ("required" in dumpRules && dumpRules.required) {
+      return {
+        ...dumpRules,
+        group: "required"
+      };
+    }
+    if ("skipped" in dumpRules && dumpRules.skipped) {
+      return {
+        ...dumpRules,
+        group: "skipped"
+      };
+    }
+    return dumpRules;
   }
 };
 __name(_CollectionGroupManager, "CollectionGroupManager");

package/lib/collection.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 import { ModelOptions, ModelStatic, QueryInterfaceDropTableOptions, QueryInterfaceOptions, SyncOptions, Transactionable } from 'sequelize';
+import { BuiltInGroup } from './collection-group-manager';
 import { Database } from './database';
 import { BelongsToField, Field, FieldOptions, HasManyField } from './fields';
 import { Model } from './model';
@@ -10,24 +11,21 @@ export type CollectionSortable = string | boolean | {
     name?: string;
     scopeKey?: string;
 };
-type dumpable = 'required' | 'optional' | 'skip';
+export type BaseDumpRules = {
+    delayRestore?: any;
+};
+export type DumpRules = BuiltInGroup | ({
+    required: true;
+} & BaseDumpRules) | ({
+    skipped: true;
+} & BaseDumpRules) | ({
+    group: BuiltInGroup | string;
+} & BaseDumpRules);
 export interface CollectionOptions extends Omit<ModelOptions, 'name' | 'hooks'> {
     name: string;
     title?: string;
     namespace?: string;
-    /**
-     * Used for @nocobase/plugin-duplicator
-     * @see packages/core/database/src/collection-group-manager.tss
-     *
-     * @prop {'required' | 'optional' | 'skip'} dumpable - Determine whether the collection is dumped
-     * @prop {string[] | string} [with] - Collections dumped with this collection
-     * @prop {any} [delayRestore] - A function to execute after all collections are restored
-     */
-    duplicator?: dumpable | {
-        dumpable: dumpable;
-        with?: string[] | string;
-        delayRestore?: any;
-    };
+    dumpRules?: DumpRules;
     tableName?: string;
     inherits?: string[] | string;
     viewName?: string;
@@ -47,6 +45,15 @@ export interface CollectionOptions extends Omit<ModelOptions, 'name' | 'hooks'>
     magicAttribute?: string;
     tree?: string;
     template?: string;
+    /**
+     * where is the collection from
+     *
+     * values
+     * - 'plugin' - collection is from plugin
+     * - 'core' - collection is from core
+     * - 'user' - collection is from user
+     */
+    origin?: string;
     [key: string]: any;
 }
 export interface CollectionContext {
@@ -62,6 +69,7 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     constructor(options: CollectionOptions, context: CollectionContext);
     get filterTargetKey(): string;
     get name(): string;
+    get origin(): string;
     get titleField(): string;
     get db(): Database;
     get treeParentField(): BelongsToField | null;
@@ -125,4 +133,3 @@ export declare class Collection<TModelAttributes extends {} = any, TCreationAttr
     private checkOptions;
     private checkTableName;
 }
-export {};

package/lib/collection.js

@@ -105,6 +105,9 @@ const _Collection = class _Collection extends import_events.EventEmitter {
   get name() {
     return this.options.name;
   }
+  get origin() {
+    return this.options.origin || "core";
+  }
   get titleField() {
     return this.options.titleField || this.model.primaryKeyAttribute;
   }

package/lib/database.d.ts

@@ -6,6 +6,7 @@ import { EventEmitter } from 'events';
 import { ModelStatic, Options, QueryInterfaceDropAllTablesOptions, QueryOptions, Sequelize, SyncOptions, Transactionable } from 'sequelize';
 import { Umzug } from 'umzug';
 import { Collection, CollectionOptions, RepositoryType } from './collection';
+import { CollectionFactory } from './collection-factory';
 import { CollectionGroupManager } from './collection-group-manager';
 import { ImportFileExtension } from './collection-importer';
 import DatabaseUtils from './database-utils';
@@ -22,7 +23,6 @@ import { RelationRepository } from './relation-repository/relation-repository';
 import { Repository } 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 { CollectionFactory } from './collection-factory';
 export type MergeOptions = merge.Options;
 export interface PendingOptions {
     field: RelationField;
@@ -99,7 +99,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     utils: DatabaseUtils;
     referenceMap: ReferencesMap;
     inheritanceMap: InheritanceMap;
-    importedFrom: Map<string, string[]>;
+    importedFrom: Map<string, Set<string>>;
     modelHook: ModelHook;
     version: DatabaseVersion;
     delayCollectionExtend: Map<string, {
@@ -113,7 +113,9 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     constructor(options: DatabaseOptions);
     _instanceId: string;
     get instanceId(): string;
-    registerCollectionType(): void;
+    createMigrator({ migrations }: {
+        migrations: any;
+    }): Umzug<any>;
     setContext(context: any): void;
     sequelizeOptions(options: any): any;
     initListener(): void;
@@ -180,6 +182,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
         from?: string;
         extensions?: ImportFileExtension[];
     }): Promise<Map<string, Collection>>;
+    private registerCollectionType;
 }
 export declare function extendCollection(collectionOptions: CollectionOptions, mergeOptions?: MergeOptions): {
     collectionOptions: CollectionOptions;

package/lib/database.js

@@ -38,6 +38,7 @@ __export(database_exports, {
 module.exports = __toCommonJS(database_exports);
 var import_logger = require("@nocobase/logger");
 var import_utils = require("@nocobase/utils");
+var import_chalk = __toESM(require("chalk"));
 var import_events = require("events");
 var import_exponential_backoff = require("exponential-backoff");
 var import_glob = __toESM(require("glob"));
@@ -47,12 +48,14 @@ var import_path = require("path");
 var import_semver = __toESM(require("semver"));
 var import_sequelize = require("sequelize");
 var import_umzug = require("umzug");
+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_referential_integrity_check = require("./features/referential-integrity-check");
 var FieldTypes = __toESM(require("./fields"));
+var import_helpers = require("./helpers");
 var import_inherited_collection = require("./inherited-collection");
 var import_inherited_map = __toESM(require("./inherited-map"));
 var import_listeners = require("./listeners");
@@ -64,9 +67,6 @@ var import_sql_collection = require("./sql-collection/sql-collection");
 var import_utils2 = require("./utils");
 var import_value_parsers = require("./value-parsers");
 var import_view_collection = require("./view-collection");
-var import_collection_factory = require("./collection-factory");
-var import_chalk = __toESM(require("chalk"));
-var import_helpers = require("./helpers");
 const DialectVersionAccessors = {
   sqlite: {
     sql: "select sqlite_version() as version",
@@ -227,8 +227,8 @@ const _Database = class _Database extends import_events.EventEmitter {
       name: "migrations",
       autoGenId: false,
       timestamps: false,
-      namespace: "core.migration",
-      duplicator: "required",
+      dumpRules: "required",
+      origin: "@nocobase/database",
       fields: [{ type: "string", name: "name", primaryKey: true }]
     });
     this.migrator = new import_umzug.Umzug({
@@ -250,21 +250,24 @@ const _Database = class _Database extends import_events.EventEmitter {
   get instanceId() {
     return this._instanceId;
   }
-  registerCollectionType() {
-    this.collectionFactory.registerCollectionType(import_inherited_collection.InheritedCollection, {
-      condition: (options) => {
-        return options.inherits && import_lodash.default.castArray(options.inherits).length > 0;
-      }
-    });
-    this.collectionFactory.registerCollectionType(import_view_collection.ViewCollection, {
-      condition: (options) => {
-        return options.viewName || options.view;
-      }
-    });
-    this.collectionFactory.registerCollectionType(import_sql_collection.SqlCollection, {
-      condition: (options) => {
-        return options.sql;
-      }
+  createMigrator({ migrations }) {
+    const migratorOptions = this.options.migrator || {};
+    const context = {
+      db: this,
+      sequelize: this.sequelize,
+      queryInterface: this.sequelize.getQueryInterface(),
+      ...migratorOptions.context
+    };
+    return new import_umzug.Umzug({
+      logger: migratorOptions.logger || console,
+      migrations: Array.isArray(migrations) ? import_lodash.default.sortBy(migrations, (m) => m.name) : migrations,
+      context,
+      storage: new import_umzug.SequelizeStorage({
+        tableName: `${this.options.tablePrefix || ""}migrations`,
+        modelName: "migrations",
+        ...migratorOptions.storage,
+        sequelize: this.sequelize
+      })
     });
   }
   setContext(context) {
@@ -353,6 +356,14 @@ const _Database = class _Database extends import_events.EventEmitter {
         options.schema = this.options.schema;
       }
     });
+    this.on("afterDefineCollection", async (collection) => {
+      const options = collection.options;
+      if (options.origin) {
+        const existsSet = this.importedFrom.get(options.origin) || /* @__PURE__ */ new Set();
+        existsSet.add(collection.name);
+        this.importedFrom.set(options.origin, existsSet);
+      }
+    });
     (0, import_listeners.registerBuiltInListeners)(this);
   }
   addMigration(item) {
@@ -668,15 +679,46 @@ const _Database = class _Database extends import_events.EventEmitter {
       if (module2.extend) {
         this.extendCollection(module2.collectionOptions, module2.mergeOptions);
       } else {
-        const collection = this.collection(module2);
-        if (options.from) {
-          this.importedFrom.set(options.from, [...this.importedFrom.get(options.from) || [], collection.name]);
-        }
+        const collection = this.collection({
+          ...module2,
+          origin: options.from
+        });
         result.set(collection.name, collection);
       }
     }
     return result;
   }
+  registerCollectionType() {
+    this.collectionFactory.registerCollectionType(import_inherited_collection.InheritedCollection, {
+      condition: (options) => {
+        return options.inherits && import_lodash.default.castArray(options.inherits).length > 0;
+      }
+    });
+    this.collectionFactory.registerCollectionType(import_view_collection.ViewCollection, {
+      condition: (options) => {
+        return options.viewName || options.view;
+      },
+      async onSync() {
+        return;
+      },
+      async onDump(dumper, collection) {
+        const viewDef = await collection.db.queryInterface.viewDef(collection.getTableNameWithSchemaAsString());
+        dumper.writeSQLContent(`view-${collection.name}`, {
+          sql: [
+            `DROP VIEW IF EXISTS ${collection.getTableNameWithSchemaAsString()}`,
+            `CREATE VIEW ${collection.getTableNameWithSchemaAsString()} AS ${viewDef}`
+          ],
+          group: "required"
+        });
+        return;
+      }
+    });
+    this.collectionFactory.registerCollectionType(import_sql_collection.SqlCollection, {
+      condition: (options) => {
+        return options.sql;
+      }
+    });
+  }
 };
 __name(_Database, "Database");
 let Database = _Database;

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

@@ -69,6 +69,9 @@ const _BelongsToManyField = class _BelongsToManyField extends import_relation_fi
       const throughCollectionOptions = {
         name: through
       };
+      if (this.collection.options.dumpRules) {
+        throughCollectionOptions["dumpRules"] = this.collection.options.dumpRules;
+      }
       if (this.collection.collectionSchema()) {
         throughCollectionOptions["schema"] = this.collection.collectionSchema();
       }

package/lib/fields/field.js

@@ -137,7 +137,7 @@ const _Field = class _Field {
   toSequelize() {
     const opts = import_lodash.default.omit(this.options, ["name"]);
     if (this.dataType) {
-      Object.assign(opts, { type: this.dataType });
+      Object.assign(opts, { type: this.database.sequelize.normalizeDataType(this.dataType) });
     }
     return opts;
   }

package/lib/query-interface/mysql-query-interface.d.ts

@@ -1,4 +1,4 @@
-import { Transactionable } from 'sequelize';
+import { Transaction, Transactionable } from 'sequelize';
 import { Collection } from '../collection';
 import QueryInterface, { TableInfo } from './query-interface';
 export default class MysqlQueryInterface extends QueryInterface {
@@ -18,4 +18,18 @@ export default class MysqlQueryInterface extends QueryInterface {
     parseSQL(sql: string): any;
     viewDef(viewName: string): Promise<string>;
     showTableDefinition(tableInfo: TableInfo): Promise<any>;
+    getAutoIncrementInfo(options: {
+        tableInfo: TableInfo;
+        fieldName: string;
+    }): Promise<{
+        seqName?: string;
+        currentVal: number;
+    }>;
+    setAutoIncrementVal(options: {
+        tableInfo: TableInfo;
+        columnName: string;
+        seqName?: string;
+        currentVal: number;
+        transaction?: Transaction;
+    }): Promise<void>;
 }

package/lib/query-interface/mysql-query-interface.js

@@ -94,6 +94,29 @@ const _MysqlQueryInterface = class _MysqlQueryInterface extends import_query_int
     const results = await this.db.sequelize.query(sql, { type: "SELECT" });
     return results[0]["Create Table"];
   }
+  async getAutoIncrementInfo(options) {
+    const { tableInfo, fieldName } = options;
+    const sql = `SELECT AUTO_INCREMENT as currentVal
+                 FROM information_schema.tables
+                 WHERE table_schema = DATABASE()
+                   AND table_name = '${tableInfo.tableName}';`;
+    const results = await this.db.sequelize.query(sql, { type: "SELECT" });
+    let currentVal = results[0]["currentVal"];
+    if (currentVal === null) {
+      const maxSql = `SELECT MAX(${fieldName}) as currentVal
+                      FROM ${tableInfo.tableName};`;
+      const maxResults = await this.db.sequelize.query(maxSql, { type: "SELECT" });
+      currentVal = maxResults[0]["currentVal"];
+    }
+    return {
+      currentVal
+    };
+  }
+  async setAutoIncrementVal(options) {
+    const { tableInfo, columnName, seqName, currentVal, transaction } = options;
+    const sql = `ALTER TABLE ${tableInfo.tableName} AUTO_INCREMENT = ${currentVal};`;
+    await this.db.sequelize.query(sql, { transaction });
+  }
 };
 __name(_MysqlQueryInterface, "MysqlQueryInterface");
 let MysqlQueryInterface = _MysqlQueryInterface;

package/lib/query-interface/postgres-query-interface.d.ts

@@ -1,7 +1,22 @@
 import { Collection } from '../collection';
 import QueryInterface, { TableInfo } from './query-interface';
+import { Transaction } from 'sequelize';
 export default class PostgresQueryInterface extends QueryInterface {
     constructor(db: any);
+    setAutoIncrementVal(options: {
+        tableInfo: TableInfo;
+        columnName: string;
+        seqName?: string;
+        currentVal?: number;
+        transaction?: Transaction;
+    }): Promise<void>;
+    getAutoIncrementInfo(options: {
+        tableInfo: TableInfo;
+        fieldName: string;
+    }): Promise<{
+        seqName?: string;
+        currentVal: number;
+    }>;
     collectionTableExists(collection: Collection, options?: any): Promise<any>;
     listViews(): Promise<[unknown[], unknown]>;
     viewDef(viewName: string): Promise<string>;

package/lib/query-interface/postgres-query-interface.js

@@ -38,6 +38,51 @@ const _PostgresQueryInterface = class _PostgresQueryInterface extends import_que
   constructor(db) {
     super(db);
   }
+  async setAutoIncrementVal(options) {
+    const { tableInfo, columnName, seqName, currentVal, transaction } = options;
+    if (!seqName) {
+      throw new Error("seqName is required to set auto increment val in postgres");
+    }
+    await this.db.sequelize.query(
+      `alter table ${this.db.utils.quoteTable({
+        tableName: tableInfo.tableName,
+        schema: tableInfo.schema
+      })}
+            alter column "${columnName}" set default nextval('${seqName}')`,
+      {
+        transaction
+      }
+    );
+    if (currentVal) {
+      await this.db.sequelize.query(`select setval('${seqName}', ${currentVal})`, {
+        transaction
+      });
+    }
+  }
+  async getAutoIncrementInfo(options) {
+    const fieldName = options.fieldName || "id";
+    const tableInfo = options.tableInfo;
+    const sequenceNameResult = await this.db.sequelize.query(
+      `SELECT column_default
+           FROM information_schema.columns
+           WHERE table_name = '${tableInfo.tableName}'
+             and table_schema = '${tableInfo.schema || "public"}'
+             and "column_name" = '${fieldName}';`
+    );
+    const columnDefault = sequenceNameResult[0][0]["column_default"];
+    const regex = new RegExp(/nextval\('(.*)'::regclass\)/);
+    const match = regex.exec(columnDefault);
+    const sequenceName = match[1];
+    const sequenceCurrentValResult = await this.db.sequelize.query(
+      `select last_value
+           from ${sequenceName}`
+    );
+    const sequenceCurrentVal = parseInt(sequenceCurrentValResult[0][0]["last_value"]);
+    return {
+      seqName: sequenceName,
+      currentVal: sequenceCurrentVal
+    };
+  }
   async collectionTableExists(collection, options) {
     const transaction = options == null ? void 0 : options.transaction;
     const tableName = collection.model.tableName;

package/lib/query-interface/query-interface.d.ts

@@ -1,4 +1,4 @@
-import { QueryInterface as SequelizeQueryInterface, Transactionable } from 'sequelize';
+import { QueryInterface as SequelizeQueryInterface, Transaction, Transactionable } from 'sequelize';
 import { Collection } from '../collection';
 import Database from '../database';
 export type TableInfo = {
@@ -25,4 +25,18 @@ export default abstract class QueryInterface {
     abstract parseSQL(sql: string): any;
     abstract showTableDefinition(tableInfo: TableInfo): Promise<any>;
     dropAll(options: any): Promise<void>;
+    abstract getAutoIncrementInfo(options: {
+        tableInfo: TableInfo;
+        fieldName: string;
+    }): Promise<{
+        seqName?: string;
+        currentVal: number;
+    }>;
+    abstract setAutoIncrementVal(options: {
+        tableInfo: TableInfo;
+        columnName: string;
+        seqName?: string;
+        currentVal: number;
+        transaction?: Transaction;
+    }): Promise<void>;
 }

package/lib/query-interface/sqlite-query-interface.d.ts

@@ -1,5 +1,6 @@
 import { Collection } from '../collection';
 import QueryInterface, { TableInfo } from './query-interface';
+import { Transaction } from 'sequelize';
 export default class SqliteQueryInterface extends QueryInterface {
     constructor(db: any);
     collectionTableExists(collection: Collection, options?: any): Promise<boolean>;
@@ -17,4 +18,18 @@ export default class SqliteQueryInterface extends QueryInterface {
     parseSQL(sql: string): any;
     viewDef(viewName: string): Promise<string>;
     showTableDefinition(tableInfo: TableInfo): Promise<any>;
+    getAutoIncrementInfo(options: {
+        tableInfo: TableInfo;
+        fieldName: string;
+    }): Promise<{
+        seqName?: string;
+        currentVal: number;
+    }>;
+    setAutoIncrementVal(options: {
+        tableInfo: TableInfo;
+        columnName: string;
+        seqName?: string;
+        currentVal: number;
+        transaction?: Transaction;
+    }): Promise<void>;
 }

package/lib/query-interface/sqlite-query-interface.js

@@ -101,6 +101,31 @@ const _SqliteQueryInterface = class _SqliteQueryInterface extends import_query_i
   showTableDefinition(tableInfo) {
     return Promise.resolve(void 0);
   }
+  async getAutoIncrementInfo(options) {
+    const { tableInfo } = options;
+    const tableName = tableInfo.tableName;
+    const sql = `SELECT seq
+                 FROM sqlite_sequence
+                 WHERE name = '${tableName}';`;
+    const results = await this.db.sequelize.query(sql, { type: "SELECT" });
+    const row = results[0];
+    if (!row) {
+      return {
+        currentVal: 0
+      };
+    }
+    return {
+      currentVal: row["seq"]
+    };
+  }
+  async setAutoIncrementVal(options) {
+    const { tableInfo, columnName, seqName, currentVal, transaction } = options;
+    const tableName = tableInfo.tableName;
+    const sql = `UPDATE sqlite_sequence
+                 SET seq = ${currentVal}
+                 WHERE name = '${tableName}';`;
+    await this.db.sequelize.query(sql, { transaction });
+  }
 };
 __name(_SqliteQueryInterface, "SqliteQueryInterface");
 let SqliteQueryInterface = _SqliteQueryInterface;

package/lib/value-parsers/date-value-parser.js

@@ -45,6 +45,14 @@ function isNumeric(str) {
 __name(isNumeric, "isNumeric");
 const _DateValueParser = class _DateValueParser extends import_base_value_parser.BaseValueParser {
   async setValue(value) {
+    if (typeof value === "string") {
+      const match = /^(\d{4})[-/]?(\d{2})[-/]?(\d{2})$/.exec(value);
+      if (match) {
+        const m = (0, import_dayjs.default)(`${match[1]}-${match[2]}-${match[3]} 00:00:00.000`);
+        this.value = m.toISOString();
+        return;
+      }
+    }
     if (import_dayjs.default.isDayjs(value)) {
       this.value = value;
     } else if (isDate(value)) {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@nocobase/database",
-  "version": "0.18.0-alpha.9",
+  "version": "0.19.0-alpha.2",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "0.18.0-alpha.9",
-    "@nocobase/utils": "0.18.0-alpha.9",
+    "@nocobase/logger": "0.19.0-alpha.2",
+    "@nocobase/utils": "0.19.0-alpha.2",
     "async-mutex": "^0.3.2",
     "chalk": "^4.1.1",
     "cron-parser": "4.4.0",
@@ -21,19 +21,19 @@
     "lodash": "^4.17.21",
     "mathjs": "^10.6.1",
     "nanoid": "^3.3.6",
+    "node-fetch": "^2.6.7",
     "qs": "^6.11.2",
     "semver": "^7.3.7",
     "sequelize": "^6.26.0",
     "umzug": "^3.1.1"
   },
   "devDependencies": {
-    "@types/glob": "^7.2.0",
-    "node-fetch": "^2.6.7"
+    "@types/glob": "^7.2.0"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "34ca0df4eede2e83fc86297b0fe19eba970e2b1b"
+  "gitHead": "cff5b77ecf12ccdb450d50d505b3aa44a68478c8"
 }