@nocobase/server 2.0.0-alpha.7 → 2.0.0-alpha.71

package/lib/app-supervisor/main-only-adapter.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 Application from '../application';
+import type { AppDiscoveryAdapter, AppProcessAdapter, AppStatus, GetAppOptions } from './types';
+import type { AppSupervisor } from './index';
+/** Minimal single-process adapter only for booting the main application. */
+export declare class MainOnlyAdapter implements AppDiscoveryAdapter, AppProcessAdapter {
+    protected readonly supervisor: AppSupervisor;
+    readonly name: string;
+    app: Application;
+    status: AppStatus;
+    appErrors: Record<string, Error>;
+    constructor(supervisor: AppSupervisor);
+    getApp(appName: string, options?: GetAppOptions): Promise<Application<import("../application").DefaultState, import("../application").DefaultContext>>;
+    bootstrapApp(appName: string): Promise<void>;
+    addApp(app: Application): Application<import("../application").DefaultState, import("../application").DefaultContext>;
+    getApps(): Application<import("../application").DefaultState, import("../application").DefaultContext>[];
+    hasApp(appName: string): boolean;
+    startApp(appName: string): Promise<void>;
+    stopApp(appName: string): Promise<void>;
+    removeApp(appName: string): Promise<void>;
+    upgradeApp(appName: string): Promise<void>;
+    removeAllApps(): Promise<void>;
+    setAppStatus(appName: string, status: AppStatus, options?: {}): void;
+    getAppStatus(appName: string, defaultStatus?: AppStatus): AppStatus;
+    hasAppError(appName: string): boolean;
+    setAppError(appName: string, error: Error): void;
+    clearAppError(appName: string): void;
+    setAppLastSeenAt(): void;
+    getAppLastSeenAt(appName: string): any;
+}

package/lib/app-supervisor/main-only-adapter.js

@@ -0,0 +1,156 @@
+/**
+ * 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 __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 main_only_adapter_exports = {};
+__export(main_only_adapter_exports, {
+  MainOnlyAdapter: () => MainOnlyAdapter
+});
+module.exports = __toCommonJS(main_only_adapter_exports);
+const _MainOnlyAdapter = class _MainOnlyAdapter {
+  constructor(supervisor) {
+    this.supervisor = supervisor;
+    this.name = "main-only";
+  }
+  name;
+  app;
+  status;
+  appErrors = {};
+  async getApp(appName, options = {}) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "getApp", appName });
+      return;
+    }
+    if (!options.withOutBootStrap) {
+      await this.bootstrapApp(appName);
+    }
+    return this.app;
+  }
+  async bootstrapApp(appName) {
+    if (appName !== "main" || !this.app) {
+      this.setAppStatus(appName, "not_found");
+      return;
+    }
+    const status = this.getAppStatus("main");
+    if (this.hasApp(appName) && status && status !== "preparing") {
+      return;
+    }
+    this.setAppStatus("main", "initializing");
+    this.setAppStatus("main", "initialized");
+  }
+  addApp(app) {
+    if (app.name !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "addApp" });
+      return;
+    }
+    if (this.app) {
+      throw new Error(`app ${app.name} already exists`);
+    }
+    this.app = app;
+    if (!this.status || this.status === "not_found") {
+      this.setAppStatus(app.name, "preparing");
+    }
+    return app;
+  }
+  getApps() {
+    return [this.app];
+  }
+  hasApp(appName) {
+    if (appName !== "main") {
+      return false;
+    }
+    return !!this.app;
+  }
+  async startApp(appName) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "startApp" });
+      return;
+    }
+    const app = await this.getApp(appName, { withOutBootStrap: true });
+    await (app == null ? void 0 : app.runCommand("start", "--quickstart"));
+  }
+  async stopApp(appName) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "stopApp" });
+      return;
+    }
+    await this.app.runCommand("stop");
+  }
+  async removeApp(appName) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "removeApp" });
+      return;
+    }
+    if (!this.app) {
+      return;
+    }
+    await this.app.runCommand("destroy");
+  }
+  async upgradeApp(appName) {
+    if (appName !== "main") {
+      this.supervisor.logger.warn(`only main app is supported`, { method: "upgrade" });
+      return;
+    }
+    if (!this.app) {
+      return;
+    }
+    await this.app.runCommand("upgrade");
+  }
+  async removeAllApps() {
+    return this.removeApp("main");
+  }
+  setAppStatus(appName, status, options = {}) {
+    if (this.status === status) {
+      return;
+    }
+    this.status = status;
+    this.supervisor.emit("appStatusChanged", { appName, status, options });
+  }
+  getAppStatus(appName, defaultStatus) {
+    return this.status ?? defaultStatus ?? null;
+  }
+  hasAppError(appName) {
+    return !!this.appErrors[appName];
+  }
+  setAppError(appName, error) {
+    this.appErrors[appName] = error;
+    this.supervisor.emit("appError", { appName, error });
+  }
+  clearAppError(appName) {
+    this.appErrors[appName] = null;
+  }
+  setAppLastSeenAt() {
+  }
+  getAppLastSeenAt(appName) {
+    return null;
+  }
+};
+__name(_MainOnlyAdapter, "MainOnlyAdapter");
+let MainOnlyAdapter = _MainOnlyAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MainOnlyAdapter
+});

package/lib/app-supervisor/types.d.ts

@@ -0,0 +1,161 @@
+/**
+ * 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.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+import { IDatabaseOptions, Transaction, Transactionable } from '@nocobase/database';
+import type Application from '../application';
+import type { AppSupervisor } from './index';
+import type { IncomingMessage, ServerResponse } from 'http';
+/**
+ * Options accepted by discovery adapter when loading an application.
+ */
+export type GetAppOptions = {
+    withOutBootStrap?: boolean;
+    [key: string]: any;
+};
+/**
+ * Parameters supplied to a bootstrapper when a sub-application is being started.
+ */
+export type BootOptions = {
+    appName: string;
+    options: Record<string, any>;
+    appSupervisor: AppSupervisor;
+};
+/**
+ * Callback used by process adapters to lazily initialize applications.
+ */
+export type AppBootstrapper = (bootOptions: BootOptions) => Promise<void>;
+/**
+ * All supported lifecycle states of a managed application.
+ */
+export type AppStatus = 'preparing' | 'initializing' | 'initialized' | 'running' | 'commanding' | 'stopped' | 'error' | 'not_found';
+/**
+ * Metadata representing a deployable environment (container, pod, VM, etc.).
+ */
+export type EnvironmentInfo = {
+    name: string;
+    url?: string;
+    proxyUrl?: string;
+    available?: boolean;
+    appVersion?: string;
+    lastHeartbeatAt?: number;
+};
+export type BootstrapLock = {
+    acquire: () => Promise<boolean>;
+    release: () => Promise<void>;
+};
+export type AppModelOptions = {
+    dbConnType?: 'new_database' | 'new_connection' | 'new_schema' | string;
+    database?: IDatabaseOptions;
+    [key: string]: any;
+};
+export type AppModel = {
+    name: string;
+    cname?: string;
+    environment?: string;
+    environments?: string[];
+    options: AppModelOptions;
+};
+export type ProcessCommand = {
+    requestId: string;
+    appName: string;
+    action: 'create' | 'start' | 'stop' | 'remove' | string;
+    environments: string[];
+    payload?: Record<string, any>;
+};
+export type AppDbCreatorOptions = Transactionable & {
+    app: Application;
+    appOptions: AppModelOptions;
+};
+export type AppDbCreator = (options: AppDbCreatorOptions) => Promise<void>;
+export type AppOptionsFactory = (appName: string, mainApp: Application, options?: AppModelOptions) => any;
+/**
+ * Abstraction for discovering applications across deployment environments.
+ */
+export type AppStatusesResult = Record<string, AppStatus | Record<string, AppStatus> | null>;
+export interface AppDiscoveryAdapter {
+    readonly name: string;
+    readonly environmentName?: string;
+    readonly environmentUrl?: string;
+    readonly environmentProxyUrl?: string;
+    readonly appStatus?: Record<string, AppStatus>;
+    readonly lastSeenAt?: Map<string, number>;
+    /**
+     * Update the "last seen at" timestamp for an application.
+     */
+    setAppLastSeenAt(appName: string): void | Promise<void>;
+    getAppLastSeenAt(appName: string): number | null | Promise<number | null>;
+    /**
+     * Read the cached lifecycle status for a given application.
+     */
+    getAppStatus(appName: string, defaultStatus?: AppStatus): Promise<AppStatus | null> | AppStatus | null;
+    /**
+     * Persist an application's lifecycle status back to the discovery backend.
+     */
+    setAppStatus(appName: string, status: AppStatus, options?: Record<string, any>): void | Promise<void>;
+    clearAppStatus?(appName: string): void | Promise<void>;
+    loadAppModels?(mainApp: Application): Promise<void>;
+    getAppsStatuses?(appNames?: string[]): Promise<AppStatusesResult> | AppStatusesResult;
+    addAutoStartApps?(environmentName: string, appName: string[]): Promise<void>;
+    getAutoStartApps?(environmentName: string): Promise<string[]>;
+    removeAutoStartApps?(environmentName: string, appNames: string[]): Promise<void>;
+    addAppModel?(appModel: AppModel): Promise<void>;
+    getAppModel?(appName: string): Promise<AppModel>;
+    removeAppModel?(appName: string): Promise<void>;
+    getAppNameByCName?(cname: string): Promise<string | null>;
+    registerEnvironment?(environment: EnvironmentInfo): Promise<boolean>;
+    unregisterEnvironment?(): Promise<void>;
+    listEnvironments?(): Promise<EnvironmentInfo[]>;
+    getEnvironment?(environmentName: string): Promise<EnvironmentInfo | null>;
+    heartbeatEnvironment?(): Promise<void>;
+    getBootstrapLock?(appName: string): Promise<BootstrapLock | null> | BootstrapLock | null;
+    proxyWeb?(appName: string, req: IncomingMessage, res: ServerResponse): Promise<boolean>;
+    proxyWs?(req: IncomingMessage, socket: any, head: Buffer): Promise<boolean>;
+    dispose?(): Promise<void>;
+}
+export interface AppProcessAdapter {
+    readonly name: string;
+    readonly apps?: Record<string, Application>;
+    readonly appErrors?: Record<string, Error>;
+    readonly lastMaintainingMessage?: Record<string, string>;
+    readonly statusBeforeCommanding?: Record<string, AppStatus>;
+    addApp(app: Application): void;
+    getApp(appName: string, options?: GetAppOptions): Promise<Application>;
+    hasApp(appName: string): boolean;
+    bootstrapApp(appName: string): Promise<void>;
+    getApps?(): Application[];
+    createApp?(options: {
+        appModel: AppModel;
+        mainApp?: Application;
+        transaction?: Transaction;
+    }, context?: {
+        requestId: string;
+    }): Promise<void>;
+    startApp?(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    stopApp?(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    removeApp?(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    upgradeApp?(appName: string, context?: {
+        requestId: string;
+    }): Promise<void>;
+    removeAllApps?(): Promise<void>;
+    setAppError?(appName: string, error: Error): void;
+    hasAppError?(appName: string): boolean;
+    clearAppError?(appName: string): void;
+}
+export interface AppCommandAdapter {
+    dispatchCommand(command: ProcessCommand): Promise<void>;
+    registerCommandHandler(mainApp: Application): void;
+    dispose?(): Promise<void>;
+}

package/lib/app-supervisor/types.js

@@ -0,0 +1,24 @@
+/**
+ * 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 __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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/application.d.ts

@@ -34,10 +34,9 @@ import { SyncMessageManager } from './sync-message-manager';
 import AesEncryptor from './aes-encryptor';
 import { AuditManager } from './audit-manager';
 import { Environment } from './environment';
-import { ServiceContainer } from './service-container';
 import { EventQueue, EventQueueOptions } from './event-queue';
-import { BackgroundJobManager, BackgroundJobManagerOptions } from './background-job-manager';
 import { RedisConfig, RedisConnectionManager } from './redis-connection-manager';
+import { ServiceContainer } from './service-container';
 import { WorkerIdAllocator } from './worker-id-allocator';
 export type PluginType = string | typeof Plugin;
 export type PluginConfiguration = PluginType | [PluginType, any];
@@ -89,7 +88,6 @@ export interface ApplicationOptions {
     auditManager?: AuditManager;
     lockManager?: LockManagerOptions;
     eventQueue?: EventQueueOptions;
-    backgroundJobManager?: BackgroundJobManagerOptions;
     /**
      * @internal
      */
@@ -129,7 +127,12 @@ interface StartOptions {
 type MaintainingStatus = 'command_begin' | 'command_end' | 'command_running' | 'command_error';
 export type MaintainingCommandStatus = {
     command: {
+        components?: {
+            maintaining: string;
+            maintainingDialog: string;
+        };
         name: string;
+        [key: string]: any;
     };
     status: MaintainingStatus;
     error?: Error;
@@ -190,9 +193,9 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     container: ServiceContainer;
     lockManager: LockManager;
     eventQueue: EventQueue;
-    backgroundJobManager: BackgroundJobManager;
     constructor(options: ApplicationOptions);
     private static staticCommands;
+    static registerStaticCommand(callback: (app: Application) => void): void;
     static addCommand(callback: (app: Application) => void): void;
     private _sqlLogger;
     get instanceId(): number;
@@ -219,7 +222,7 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     get environment(): Environment;
     protected _cronJobManager: CronJobManager;
     get cronJobManager(): CronJobManager;
-    get mainDataSource(): SequelizeDataSource;
+    get mainDataSource(): SequelizeDataSource<import("@nocobase/data-source-manager").DatabaseIntrospector>;
     get db(): Database;
     get resourceManager(): import("@nocobase/resourcer").ResourceManager;
     /**
@@ -276,14 +279,14 @@ export declare class Application<StateT = DefaultState, ContextT = DefaultContex
     /**
      * @internal
      */
-    setMaintaining(_maintainingCommandStatus: MaintainingCommandStatus): void;
+    setMaintaining(_maintainingCommandStatus: MaintainingCommandStatus): Promise<void>;
     /**
      * @internal
      */
     setMaintainingMessage(message: string): void;
     /**
      * This method is deprecated and should not be used.
-     * Use {@link #this.version.get()} instead.
+     * Use {@link #this.getPackageVersion} instead.
      * @deprecated
      */
     getVersion(): string;

package/lib/application.js

@@ -50,8 +50,8 @@ var import_database = __toESM(require("@nocobase/database"));
 var import_logger = require("@nocobase/logger");
 var import_telemetry = require("@nocobase/telemetry");
 var import_lock_manager = require("@nocobase/lock-manager");
-var import_utils = require("@nocobase/utils");
 var import_snowflake_id = require("@nocobase/snowflake-id");
+var import_utils = require("@nocobase/utils");
 var import_crypto = require("crypto");
 var import_glob = __toESM(require("glob"));
 var import_koa = __toESM(require("koa"));
@@ -81,12 +81,11 @@ var import_available_action = require("./acl/available-action");
 var import_aes_encryptor = __toESM(require("./aes-encryptor"));
 var import_audit_manager = require("./audit-manager");
 var import_environment = require("./environment");
-var import_service_container = require("./service-container");
 var import_event_queue = require("./event-queue");
-var import_background_job_manager = require("./background-job-manager");
 var import_redis_connection_manager = require("./redis-connection-manager");
-var import_worker_id_allocator = require("./worker-id-allocator");
+var import_service_container = require("./service-container");
 var import_snowflake_id_field = require("./snowflake-id-field");
+var import_worker_id_allocator = require("./worker-id-allocator");
 const _Application = class _Application extends import_koa.default {
   constructor(options) {
     super();
@@ -142,7 +141,9 @@ const _Application = class _Application extends import_koa.default {
   container = new import_service_container.ServiceContainer();
   lockManager;
   eventQueue;
-  backgroundJobManager;
+  static registerStaticCommand(callback) {
+    this.staticCommands.push(callback);
+  }
   static addCommand(callback) {
     this.staticCommands.push(callback);
   }
@@ -315,9 +316,9 @@ const _Application = class _Application extends import_koa.default {
   /**
    * @internal
    */
-  setMaintaining(_maintainingCommandStatus) {
+  async setMaintaining(_maintainingCommandStatus) {
     this._maintainingCommandStatus = _maintainingCommandStatus;
-    this.emit("maintaining", _maintainingCommandStatus);
+    await this.emitAsync("maintaining", _maintainingCommandStatus);
     if (_maintainingCommandStatus.status == "command_end") {
       this._maintaining = false;
       return;
@@ -336,7 +337,7 @@ const _Application = class _Application extends import_koa.default {
   }
   /**
    * This method is deprecated and should not be used.
-   * Use {@link #this.version.get()} instead.
+   * Use {@link #this.getPackageVersion} instead.
    * @deprecated
    */
   getVersion() {
@@ -609,7 +610,7 @@ const _Application = class _Application extends import_koa.default {
         await this.pm.loadCommands();
       }
       const command = await this.cli.parseAsync(argv, options);
-      this.setMaintaining({
+      await this.setMaintaining({
         status: "command_end",
         command: this.activatedCommand
       });
@@ -620,7 +621,7 @@ const _Application = class _Application extends import_koa.default {
           name: "unknown"
         };
       }
-      this.setMaintaining({
+      await this.setMaintaining({
         status: "command_error",
         command: this.activatedCommand,
         error
@@ -777,6 +778,12 @@ const _Application = class _Application extends import_koa.default {
   }
   async upgrade(options = {}) {
     this.log.info("upgrading...");
+    const pkgVersion = this.getPackageVersion();
+    const appVersion = await this.version.get();
+    if (process.env.SKIP_SAME_VERSION_UPGRADE === "true" && pkgVersion === appVersion) {
+      this.log.info(`app is already the latest version (${appVersion})`);
+      return;
+    }
     await this.reInit();
     const migrator1 = await this.loadCoreMigrations();
     await migrator1.beforeLoad.up();
@@ -800,7 +807,9 @@ const _Application = class _Application extends import_koa.default {
     await migrator3.afterLoad.up();
     await this.pm.repository.updateVersions();
     await this.version.update();
-    await this.emitAsync("afterUpgrade", this, options);
+    if (!options.quickstart) {
+      await this.emitAsync("afterUpgrade", this, options);
+    }
     await this.restart();
   }
   toJSON() {
@@ -834,11 +843,11 @@ const _Application = class _Application extends import_koa.default {
       this.activatedCommand = {
         name: (0, import_helper.getCommandFullName)(actionCommand)
       };
-      this.setMaintaining({
+      await this.setMaintaining({
         status: "command_begin",
         command: this.activatedCommand
       });
-      this.setMaintaining({
+      await this.setMaintaining({
         status: "command_running",
         command: this.activatedCommand
       });
@@ -911,7 +920,6 @@ const _Application = class _Application extends import_koa.default {
     this.pubSubManager = (0, import_pub_sub_manager.createPubSubManager)(this, options.pubSubManager);
     this.syncMessageManager = new import_sync_message_manager.SyncMessageManager(this, options.syncMessageManager);
     this.eventQueue = new import_event_queue.EventQueue(this, options.eventQueue);
-    this.backgroundJobManager = new import_background_job_manager.BackgroundJobManager(this, options.backgroundJobManager);
     this.lockManager = new import_lock_manager.LockManager({
       defaultAdapter: process.env.LOCK_ADAPTER_DEFAULT,
       ...options.lockManager
@@ -927,8 +935,8 @@ const _Application = class _Application extends import_koa.default {
       plugins: plugins || []
     });
     this._telemetry = new import_telemetry.Telemetry({
-      serviceName: `nocobase-${this.name}`,
-      version: this.getVersion(),
+      appName: this.name,
+      version: this.getPackageVersion(),
       ...options.telemetry
     });
     this._authManager = new import_auth.AuthManager({
@@ -941,6 +949,11 @@ const _Application = class _Application extends import_koa.default {
       name: "auth",
       actions: import_auth.actions
     });
+    this._dataSourceManager.beforeAddDataSource((dataSource) => {
+      if (dataSource.collectionManager instanceof import_data_source_manager.SequelizeCollectionManager) {
+        (0, import_snowflake_id_field.setupSnowflakeIdField)(this, dataSource.collectionManager.db);
+      }
+    });
     this._dataSourceManager.afterAddDataSource((dataSource) => {
       if (dataSource.collectionManager instanceof import_data_source_manager.SequelizeCollectionManager) {
         for (const [actionName, actionParams] of Object.entries(import_available_action.availableActions)) {
@@ -948,7 +961,7 @@ const _Application = class _Application extends import_koa.default {
         }
       }
     });
-    this._dataSourceManager.use(this._authManager.middleware(), { tag: "auth" });
+    this._dataSourceManager.use(this._authManager.middleware(), { tag: "auth", before: "default" });
     this._dataSourceManager.use(import_validate_filter_params.default, { tag: "validate-filter-params", before: ["auth"] });
     this._dataSourceManager.use(import_middlewares.parseVariables, {
       group: "parseVariables",
@@ -982,7 +995,6 @@ const _Application = class _Application extends import_koa.default {
       app: this
     });
     this.dataSourceManager.dataSources.set("main", mainDataSourceInstance);
-    (0, import_snowflake_id_field.setupSnowflakeIdField)(this);
   }
   createDatabase(options) {
     const logging = /* @__PURE__ */ __name((...args) => {

package/lib/commands/index.js

@@ -53,6 +53,7 @@ var import_start = __toESM(require("./start"));
 var import_stop = __toESM(require("./stop"));
 var import_upgrade = __toESM(require("./upgrade"));
 var import_console = __toESM(require("./console"));
+var import_repair = __toESM(require("./repair"));
 /* istanbul ignore file -- @preserve */
 function registerCli(app) {
   (0, import_console.default)(app);
@@ -68,6 +69,7 @@ function registerCli(app) {
   (0, import_destroy.default)(app);
   (0, import_start.default)(app);
   (0, import_refresh.default)(app);
+  (0, import_repair.default)(app);
   app.command("build").argument("[packages...]");
   app.command("clean");
   app.command("dev").usage("[options]").option("-p, --port [port]").option("--client").option("--server");

package/lib/commands/pm.js

@@ -38,6 +38,17 @@ var pm_default = /* @__PURE__ */ __name((app) => {
   pm.command("create").argument("plugin").option("--force-recreate").action(async (plugin, options) => {
     await app.pm.create(plugin, options);
   });
+  pm.command("pull").arguments("<packageNames...>").option("--registry [registry]").option("--auth-token [authToken]").option("--version [version]").action(async (packageNames, options, cli) => {
+    try {
+      let name = packageNames;
+      if (Array.isArray(packageNames) && packageNames.length === 1) {
+        name = packageNames[0];
+      }
+      await app.pm.pull(name, { ...options });
+    } catch (error) {
+      throw new import_plugin_command_error.PluginCommandError(`Failed to pull plugin`, { cause: error });
+    }
+  });
   pm.command("add").ipc().preload().arguments("<packageNames...>").option("--registry [registry]").option("--auth-token [authToken]").option("--version [version]").action(async (packageNames, options, cli) => {
     try {
       let name = packageNames;

package/lib/commands/repair.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 Application from '../application';
+declare const _default: (app: Application) => void;
+export default _default;