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

package/lib/acl/available-action.js

@@ -56,7 +56,7 @@ const availableActions = {
   update: {
     displayName: '{{t("Edit")}}',
     type: "old-data",
-    aliases: ["update", "move", "add", "set", "remove", "toggle"],
+    aliases: ["update", "move"],
     allowConfigureFields: true
   },
   destroy: {

package/lib/aes-encryptor.d.ts

@@ -13,6 +13,7 @@ export declare class AesEncryptor {
     constructor(key: Buffer);
     encrypt(text: string): Promise<string>;
     decrypt(encryptedText: string): Promise<string>;
+    decryptSync(encryptedText: string): string;
     static getOrGenerateKey(keyFilePath: string): Promise<Buffer>;
     static getKeyPath(appName: string): Promise<string>;
     static create(app: Application): Promise<AesEncryptor>;

package/lib/aes-encryptor.js

@@ -67,16 +67,19 @@ const _AesEncryptor = class _AesEncryptor {
   async decrypt(encryptedText) {
     return new Promise((resolve2, reject) => {
       try {
-        const iv = Buffer.from(encryptedText.slice(0, 32), "hex");
-        const encrypted = Buffer.from(encryptedText.slice(32), "hex");
-        const decipher = import_crypto.default.createDecipheriv("aes-256-cbc", this.key, iv);
-        const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
-        resolve2(decrypted.toString("utf8"));
+        resolve2(this.decryptSync(encryptedText));
       } catch (error) {
         reject(error);
       }
     });
   }
+  decryptSync(encryptedText) {
+    const iv = Buffer.from(encryptedText.slice(0, 32), "hex");
+    const encrypted = Buffer.from(encryptedText.slice(32), "hex");
+    const decipher = import_crypto.default.createDecipheriv("aes-256-cbc", this.key, iv);
+    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    return decrypted.toString("utf8");
+  }
   static async getOrGenerateKey(keyFilePath) {
     try {
       const key = await import_fs_extra.default.readFile(keyFilePath);
@@ -109,6 +112,10 @@ const _AesEncryptor = class _AesEncryptor {
     return appKeyPath;
   }
   static async create(app) {
+    if (process.env.APP_AES_SECRET_KEY) {
+      const key2 = Buffer.from(process.env.APP_AES_SECRET_KEY, "hex");
+      return new _AesEncryptor(key2);
+    }
     const KEY_PATH = process.env.APP_AES_SECRET_KEY_PATH;
     const keyPath = KEY_PATH ? (0, import_path.resolve)(process.cwd(), KEY_PATH) : await this.getKeyPath(app.name);
     const key = await _AesEncryptor.getOrGenerateKey(keyPath);

package/lib/app-command.d.ts

@@ -14,6 +14,7 @@ export declare class AppCommand extends Command {
     auth(): this;
     preload(): this;
     hasCommand(name: string): boolean;
+    findCommand(name: string): any;
     isHandleByIPCServer(): boolean;
     createCommand(name?: string): AppCommand;
     parseHandleByIPCServer(argv: any, parseOptions?: any): Boolean;

package/lib/app-command.js

@@ -51,6 +51,9 @@ const _AppCommand = class _AppCommand extends import_commander.Command {
     const names = this.commands.map((c) => c.name());
     return names.includes(name);
   }
+  findCommand(name) {
+    return this._findCommand(name);
+  }
   isHandleByIPCServer() {
     return this._handleByIPCServer;
   }

package/lib/app-supervisor/app-options-factory.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 { IDatabaseOptions } from '@nocobase/database';
+import Application from '../application';
+import { AppModelOptions } from './types';
+export declare const appOptionsFactory: (appName: string, mainApp: Application, options: AppModelOptions) => {
+    dbConnType: string;
+    database: {
+        tablePrefix: string;
+        migrator?: any;
+        usingBigIntForId?: boolean;
+        underscored?: boolean;
+        logger?: import("@nocobase/logger/lib/logger").Logger | import("@nocobase/logger/lib/logger").LoggerOptions;
+        customHooks?: any;
+        instanceId?: string;
+        addAllCollections?: boolean;
+        dialect?: import("sequelize").Dialect;
+        dialectModule?: object;
+        dialectModulePath?: string;
+        dialectOptions?: object;
+        storage?: string;
+        database?: string;
+        username?: string;
+        password?: string;
+        host?: string;
+        port?: number;
+        ssl?: boolean;
+        protocol?: string;
+        define?: import("sequelize").ModelOptions<import("sequelize").Model<any, any>>;
+        query?: import("sequelize").QueryOptions;
+        set?: import("sequelize").DefaultSetOptions;
+        sync?: import("@nocobase/database").SyncOptions;
+        timezone?: string;
+        omitNull?: boolean;
+        native?: boolean;
+        replication?: false | import("sequelize").ReplicationOptions;
+        pool?: import("sequelize").PoolOptions;
+        quoteIdentifiers?: boolean;
+        isolationLevel?: string;
+        transactionType?: import("@nocobase/database").Transaction.TYPES;
+        typeValidation?: boolean;
+        operatorsAliases?: import("sequelize").OperatorsAliases;
+        standardConformingStrings?: boolean;
+        clientMinMessages?: string | boolean;
+        hooks?: Partial<import("sequelize/types/hooks").SequelizeHooks<import("sequelize").Model<any, any>, any, any>>;
+        minifyAliases?: boolean;
+        logQueryParameters?: boolean;
+        retry?: import("retry-as-promised").Options;
+        schema?: string;
+        attributeBehavior?: "escape" | "throw" | "unsafe-legacy";
+        logging?: boolean | ((sql: string, timing?: number) => void);
+        benchmark?: boolean;
+    };
+    plugins: string[];
+    resourcer: {
+        prefix: string;
+    };
+    cacheManager: {
+        prefix: string;
+        defaultStore?: string;
+        stores?: {
+            [storeType: string]: {
+                [key: string]: any;
+                store?: "memory" | import("cache-manager").FactoryStore<import("cache-manager").Store, any>;
+                close?: (store: import("cache-manager").Store) => Promise<void>;
+            };
+        };
+    };
+    logger: import("../application").AppLoggerOptions;
+} & {
+    name: string;
+    dbConnType?: string;
+    database?: IDatabaseOptions;
+};

package/lib/app-supervisor/app-options-factory.js

@@ -0,0 +1,91 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var app_options_factory_exports = {};
+__export(app_options_factory_exports, {
+  appOptionsFactory: () => appOptionsFactory
+});
+module.exports = __toCommonJS(app_options_factory_exports);
+var import_database = require("@nocobase/database");
+var import_lodash = __toESM(require("lodash"));
+var import_path = __toESM(require("path"));
+var import_lodash2 = __toESM(require("lodash"));
+function getDatabaseConfig(app) {
+  let oldConfig = app.options.database instanceof import_database.Database ? app.options.database.options : app.options.database;
+  if (!oldConfig && app.db) {
+    oldConfig = app.db.options;
+  }
+  return import_lodash.default.cloneDeep(import_lodash.default.omit(oldConfig, ["migrator"]));
+}
+__name(getDatabaseConfig, "getDatabaseConfig");
+const appOptionsFactory = /* @__PURE__ */ __name((appName, mainApp, options) => {
+  const rawDatabaseOptions = getDatabaseConfig(mainApp);
+  let dbConnType = "new_database";
+  if (rawDatabaseOptions.dialect === "sqlite") {
+    const mainAppStorage = rawDatabaseOptions.storage;
+    if (mainAppStorage !== ":memory:") {
+      const mainStorageDir = import_path.default.dirname(mainAppStorage);
+      rawDatabaseOptions.storage = import_path.default.join(mainStorageDir, `${appName}.sqlite`);
+    }
+  } else if (process.env.USE_DB_SCHEMA_IN_SUBAPP === "true" && ["postgres", "kingbase"].includes(rawDatabaseOptions.dialect)) {
+    rawDatabaseOptions.schema = appName;
+    dbConnType = "new_schema";
+  } else if ((options == null ? void 0 : options.dbConnType) !== "new_schema") {
+    rawDatabaseOptions.database = appName;
+  }
+  const defaultOptions = {
+    dbConnType,
+    database: {
+      ...rawDatabaseOptions,
+      tablePrefix: ""
+    },
+    plugins: ["nocobase"],
+    resourcer: {
+      prefix: process.env.API_BASE_PATH
+    },
+    cacheManager: {
+      ...mainApp.options.cacheManager,
+      prefix: appName
+    },
+    logger: mainApp.options.logger
+  };
+  return import_lodash2.default.merge({}, defaultOptions, { ...options, name: appName });
+}, "appOptionsFactory");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appOptionsFactory
+});

package/lib/app-supervisor/condition-registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+export type Predicate<C> = (ctx: C) => boolean | Promise<boolean>;
+type Handler<C, R> = (ctx: C) => R | Promise<R>;
+export declare class ConditionalRegistry<C, R> {
+    private rules;
+    private defaultHandler?;
+    register(when: Predicate<C>, run: Handler<C, R>, priority?: number): void;
+    setDefault(run: Handler<C, R>): void;
+    run(ctx: C): Promise<R>;
+}
+export {};

package/lib/app-supervisor/condition-registry.js

@@ -0,0 +1,60 @@
+/**
+ * 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 condition_registry_exports = {};
+__export(condition_registry_exports, {
+  ConditionalRegistry: () => ConditionalRegistry
+});
+module.exports = __toCommonJS(condition_registry_exports);
+const _ConditionalRegistry = class _ConditionalRegistry {
+  rules = [];
+  defaultHandler;
+  register(when, run, priority = 0) {
+    this.rules.push({ when, run, priority });
+    this.rules.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  }
+  setDefault(run) {
+    this.defaultHandler = run;
+  }
+  async run(ctx) {
+    for (const rule of this.rules) {
+      if (await rule.when(ctx)) {
+        return await rule.run(ctx);
+      }
+    }
+    if (this.defaultHandler) {
+      return await this.defaultHandler(ctx);
+    }
+    throw new Error("No handler matched and no default handler defined");
+  }
+};
+__name(_ConditionalRegistry, "ConditionalRegistry");
+let ConditionalRegistry = _ConditionalRegistry;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConditionalRegistry
+});

package/lib/app-supervisor/db-creator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { Predicate } from './condition-registry';
+import type { AppDbCreator, AppDbCreatorOptions } from './types';
+export declare const createDatabaseCondition: Predicate<AppDbCreatorOptions>;
+export declare const createConnectionCondition: Predicate<AppDbCreatorOptions>;
+export declare const createSchemaCondition: Predicate<AppDbCreatorOptions>;
+export declare const createDatabase: AppDbCreator;
+export declare const createConnection: AppDbCreator;
+export declare const createSchema: AppDbCreator;

package/lib/app-supervisor/db-creator.js

@@ -0,0 +1,163 @@
+/**
+ * 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 db_creator_exports = {};
+__export(db_creator_exports, {
+  createConnection: () => createConnection,
+  createConnectionCondition: () => createConnectionCondition,
+  createDatabase: () => createDatabase,
+  createDatabaseCondition: () => createDatabaseCondition,
+  createSchema: () => createSchema,
+  createSchemaCondition: () => createSchemaCondition
+});
+module.exports = __toCommonJS(db_creator_exports);
+var import_db_drivers = require("./db-drivers");
+async function createMySQLDatabase({
+  host,
+  port,
+  username,
+  password,
+  database,
+  driver
+}) {
+  var _a;
+  const conn = await driver.createConnection({
+    host,
+    port,
+    user: username,
+    password
+  });
+  await conn.query(`CREATE DATABASE IF NOT EXISTS \`${database}\``);
+  await (((_a = conn.end) == null ? void 0 : _a.call(conn)) ?? conn.close());
+}
+__name(createMySQLDatabase, "createMySQLDatabase");
+async function withPgClient(options, fn) {
+  const { Client } = (0, import_db_drivers.loadPgModule)();
+  const client = new Client(options);
+  await client.connect();
+  try {
+    await fn(client);
+  } catch (e) {
+    console.log(e);
+  } finally {
+    await client.end();
+  }
+}
+__name(withPgClient, "withPgClient");
+const createDatabaseCondition = /* @__PURE__ */ __name(({ appOptions }) => !(appOptions == null ? void 0 : appOptions.dbConnType) || appOptions.dbConnType === "new_database", "createDatabaseCondition");
+const createConnectionCondition = /* @__PURE__ */ __name(({ appOptions }) => (appOptions == null ? void 0 : appOptions.dbConnType) === "new_connection", "createConnectionCondition");
+const createSchemaCondition = /* @__PURE__ */ __name(({ appOptions }) => appOptions.dbConnType === "new_schema", "createSchemaCondition");
+const createDatabase = /* @__PURE__ */ __name(async ({ app }) => {
+  const { host, port, username, password, dialect, database } = app.options.database;
+  if (dialect === "mysql") {
+    const mysql = (0, import_db_drivers.loadMysqlDriver)();
+    return createMySQLDatabase({
+      host,
+      port,
+      username,
+      password,
+      database,
+      driver: mysql
+    });
+  }
+  if (dialect === "mariadb") {
+    const mariadb = (0, import_db_drivers.loadMariadbDriver)();
+    return createMySQLDatabase({
+      host,
+      port,
+      username,
+      password,
+      database,
+      driver: mariadb
+    });
+  }
+  if (["postgres", "kingbase"].includes(dialect)) {
+    return withPgClient({ host, port, user: username, password, database: dialect }, async (client) => {
+      const exists = await client.query("SELECT 1 FROM pg_database WHERE datname = $1", [database]);
+      if (exists.rowCount === 0) {
+        await client.query(`CREATE DATABASE "${database}"`);
+      }
+    });
+  }
+}, "createDatabase");
+const createConnection = /* @__PURE__ */ __name(async ({ app }) => {
+  const { host, port, username, password, dialect, database, schema } = app.options.database;
+  if (dialect === "mysql") {
+    const mysql = (0, import_db_drivers.loadMysqlDriver)();
+    return createMySQLDatabase({
+      host,
+      port,
+      username,
+      password,
+      database,
+      driver: mysql
+    });
+  }
+  if (dialect === "mariadb") {
+    const mariadb = (0, import_db_drivers.loadMariadbDriver)();
+    return createMySQLDatabase({
+      host,
+      port,
+      username,
+      password,
+      database,
+      driver: mariadb
+    });
+  }
+  if (["postgres", "kingbase"].includes(dialect)) {
+    if (schema) {
+      return withPgClient(
+        { host, port, user: username, password, database },
+        (client) => client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`)
+      );
+    } else {
+      return withPgClient(
+        { host, port, user: username, password, database: dialect },
+        (client) => client.query(`CREATE DATABASE "${database}"`)
+      );
+    }
+  }
+}, "createConnection");
+const createSchema = /* @__PURE__ */ __name(async ({ app }) => {
+  const { host, port, username, password, dialect, schema, database } = app.options.database;
+  if (!["postgres", "kingbase"].includes(dialect)) {
+    throw new Error("Schema is only supported for postgres/kingbase");
+  }
+  return withPgClient(
+    { host, port, user: username, password, database },
+    (client) => client.query(`CREATE SCHEMA IF NOT EXISTS ${schema}`)
+  );
+}, "createSchema");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createConnection,
+  createConnectionCondition,
+  createDatabase,
+  createDatabaseCondition,
+  createSchema,
+  createSchemaCondition
+});

package/lib/app-supervisor/db-drivers.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.
+ */
+export declare function loadMysqlDriver(): any;
+export declare function loadMariadbDriver(): any;
+export declare function loadPgModule(): any;

package/lib/app-supervisor/db-drivers.js

@@ -0,0 +1,52 @@
+/**
+ * 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 db_drivers_exports = {};
+__export(db_drivers_exports, {
+  loadMariadbDriver: () => loadMariadbDriver,
+  loadMysqlDriver: () => loadMysqlDriver,
+  loadPgModule: () => loadPgModule
+});
+module.exports = __toCommonJS(db_drivers_exports);
+function loadMysqlDriver() {
+  return require("mysql2/promise");
+}
+__name(loadMysqlDriver, "loadMysqlDriver");
+function loadMariadbDriver() {
+  return require("mariadb");
+}
+__name(loadMariadbDriver, "loadMariadbDriver");
+function loadPgModule() {
+  return require("pg");
+}
+__name(loadPgModule, "loadPgModule");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadMariadbDriver,
+  loadMysqlDriver,
+  loadPgModule
+});