@nocobase/database 0.14.0-alpha.2 → 0.14.0-alpha.4

package/lib/collection-importer.js

@@ -32,6 +32,7 @@ __export(collection_importer_exports, {
 });
 module.exports = __toCommonJS(collection_importer_exports);
 var import_path = __toESM(require("path"));
+var import_fs = require("fs");
 var import_promises = require("fs/promises");
 var import_lodash = require("lodash");
 var import_utils = require("@nocobase/utils");
@@ -46,6 +47,9 @@ const _ImporterReader = class _ImporterReader {
     this.extensions = new Set(extensions);
   }
   async read() {
+    if (!(0, import_fs.existsSync)(this.directory)) {
+      return [];
+    }
     const files = await (0, import_promises.readdir)(this.directory, {
       encoding: "utf-8"
     });

package/lib/database.d.ts

@@ -142,7 +142,7 @@ export declare class Database extends EventEmitter implements AsyncEmitter {
     isSqliteMemory(): boolean;
     auth(options?: Omit<QueryOptions, 'retry'> & {
         retry?: number | Pick<QueryOptions, 'retry'>;
-    }): Promise<any>;
+    }): Promise<void>;
     prepare(): Promise<void>;
     reconnect(): Promise<void>;
     closed(): any;

package/lib/database.js

@@ -61,6 +61,7 @@ var import_query_interface_builder = __toESM(require("./query-interface/query-in
 var import_utils2 = require("./utils");
 var import_value_parsers = require("./value-parsers");
 var import_view_collection = require("./view-collection");
+var import_exponential_backoff = require("exponential-backoff");
 const DialectVersionAccessors = {
   sqlite: {
     sql: "select sqlite_version() as version",
@@ -205,7 +206,6 @@ const _Database = class _Database extends import_events.EventEmitter {
       migrations: this.migrations.callback(),
       context,
       storage: new import_umzug.SequelizeStorage({
-        modelName: `${this.options.tablePrefix || ""}migrations`,
         ...migratorOptions.storage,
         sequelize: this.sequelize
       })
@@ -525,25 +525,30 @@ const _Database = class _Database extends import_events.EventEmitter {
   }
   async auth(options = {}) {
     const { retry = 10, ...others } = options;
-    const delay = /* @__PURE__ */ __name((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)), "delay");
-    let count = 1;
+    const startingDelay = 50;
+    const timeMultiple = 2;
+    let attemptNumber = 1;
     const authenticate = /* @__PURE__ */ __name(async () => {
       try {
         await this.sequelize.authenticate(others);
         console.log("Connection has been established successfully.");
-        return true;
       } catch (error) {
-        console.log(`Unable to connect to the database: ${error.message}`);
-        if (count >= retry) {
-          throw new Error("Connection failed, please check your database connection credentials and try again.");
-        }
-        console.log("reconnecting...", count);
-        ++count;
-        await delay(500);
-        return await authenticate();
+        console.log(`Attempt ${attemptNumber}/${retry}: Unable to connect to the database: ${error.message}`);
+        const nextDelay = startingDelay * Math.pow(timeMultiple, attemptNumber - 1);
+        console.log(`Will retry in ${nextDelay}ms...`);
+        attemptNumber++;
+        throw error;
       }
     }, "authenticate");
-    return await authenticate();
+    try {
+      await (0, import_exponential_backoff.backOff)(authenticate, {
+        numOfAttempts: retry,
+        startingDelay,
+        timeMultiple
+      });
+    } catch (error) {
+      throw new Error("Connection failed, please check your database connection credentials and try again.");
+    }
   }
   async prepare() {
     if (this.inDialect("postgres") && this.options.schema && this.options.schema != "public") {

package/lib/helpers.d.ts

@@ -0,0 +1,2 @@
+import { IDatabaseOptions } from './database';
+export declare function parseDatabaseOptionsFromEnv(): Promise<IDatabaseOptions>;

package/lib/helpers.js

@@ -0,0 +1,120 @@
+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 helpers_exports = {};
+__export(helpers_exports, {
+  parseDatabaseOptionsFromEnv: () => parseDatabaseOptionsFromEnv
+});
+module.exports = __toCommonJS(helpers_exports);
+var import_fs = __toESM(require("fs"));
+function getEnvValue(key, defaultValue) {
+  return process.env[key] || defaultValue;
+}
+__name(getEnvValue, "getEnvValue");
+function isFilePath(value) {
+  return import_fs.default.promises.stat(value).then((stats) => stats.isFile()).catch((err) => {
+    if (err.code === "ENOENT") {
+      return false;
+    }
+    throw err;
+  });
+}
+__name(isFilePath, "isFilePath");
+function getValueOrFileContent(envVarName) {
+  const value = getEnvValue(envVarName);
+  if (!value) {
+    return Promise.resolve(null);
+  }
+  return isFilePath(value).then((isFile) => {
+    if (isFile) {
+      return import_fs.default.promises.readFile(value, "utf8");
+    }
+    return value;
+  }).catch((error) => {
+    console.error(`Failed to read file content for environment variable ${envVarName}.`);
+    throw error;
+  });
+}
+__name(getValueOrFileContent, "getValueOrFileContent");
+function extractSSLOptionsFromEnv() {
+  return Promise.all([
+    getValueOrFileContent("DB_DIALECT_OPTIONS_SSL_MODE"),
+    getValueOrFileContent("DB_DIALECT_OPTIONS_SSL_CA"),
+    getValueOrFileContent("DB_DIALECT_OPTIONS_SSL_KEY"),
+    getValueOrFileContent("DB_DIALECT_OPTIONS_SSL_CERT"),
+    getValueOrFileContent("DB_DIALECT_OPTIONS_SSL_REJECT_UNAUTHORIZED")
+  ]).then(([mode, ca, key, cert, rejectUnauthorized]) => {
+    const sslOptions = {};
+    if (mode)
+      sslOptions["mode"] = mode;
+    if (ca)
+      sslOptions["ca"] = ca;
+    if (key)
+      sslOptions["key"] = key;
+    if (cert)
+      sslOptions["cert"] = cert;
+    if (rejectUnauthorized)
+      sslOptions["rejectUnauthorized"] = rejectUnauthorized === "true";
+    return sslOptions;
+  });
+}
+__name(extractSSLOptionsFromEnv, "extractSSLOptionsFromEnv");
+async function parseDatabaseOptionsFromEnv() {
+  const databaseOptions = {
+    logging: process.env.DB_LOGGING == "on" ? customLogger : false,
+    dialect: process.env.DB_DIALECT,
+    storage: process.env.DB_STORAGE,
+    username: process.env.DB_USER,
+    password: process.env.DB_PASSWORD,
+    database: process.env.DB_DATABASE,
+    host: process.env.DB_HOST,
+    port: process.env.DB_PORT,
+    timezone: process.env.DB_TIMEZONE,
+    tablePrefix: process.env.DB_TABLE_PREFIX,
+    schema: process.env.DB_SCHEMA,
+    underscored: process.env.DB_UNDERSCORED === "true"
+  };
+  const sslOptions = await extractSSLOptionsFromEnv();
+  if (Object.keys(sslOptions).length) {
+    databaseOptions.dialectOptions = databaseOptions.dialectOptions || {};
+    databaseOptions.dialectOptions["ssl"] = sslOptions;
+  }
+  return databaseOptions;
+}
+__name(parseDatabaseOptionsFromEnv, "parseDatabaseOptionsFromEnv");
+function customLogger(queryString, queryObject) {
+  console.log(queryString);
+  if (queryObject == null ? void 0 : queryObject.bind) {
+    console.log(queryObject.bind);
+  }
+}
+__name(customLogger, "customLogger");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseDatabaseOptionsFromEnv
+});

package/lib/index.d.ts

@@ -24,3 +24,4 @@ export { snakeCase } from './utils';
 export * from './value-parsers';
 export * from './view-collection';
 export * from './view/view-inference';
+export * from './helpers';

package/lib/index.js

@@ -75,6 +75,7 @@ var import_utils = require("./utils");
 __reExport(src_exports, require("./value-parsers"), module.exports);
 __reExport(src_exports, require("./view-collection"), module.exports);
 __reExport(src_exports, require("./view/view-inference"), module.exports);
+__reExport(src_exports, require("./helpers"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BaseError,
@@ -116,5 +117,6 @@ __reExport(src_exports, require("./view/view-inference"), module.exports);
   ...require("./update-associations"),
   ...require("./value-parsers"),
   ...require("./view-collection"),
-  ...require("./view/view-inference")
+  ...require("./view/view-inference"),
+  ...require("./helpers")
 });

package/lib/update-associations.js

@@ -268,9 +268,6 @@ async function updateMultipleAssociation(model, key, value, options = {}) {
   if (!association) {
     return false;
   }
-  if (association.through && association.through.model.options.view) {
-    return false;
-  }
   if (!["undefined", "string", "number", "object"].includes(typeof value)) {
     return false;
   }

package/lib/update-guard.d.ts

@@ -18,6 +18,7 @@ export declare class UpdateGuard {
     setAssociationKeysToBeUpdate(associationKeysToBeUpdate: AssociationKeysToBeUpdate): void;
     setWhiteList(whiteList: WhiteList): void;
     setBlackList(blackList: BlackList): void;
+    checkValues(values: any): void;
     /**
      * Sanitize values by whitelist blacklist
      * @param values

package/lib/update-guard.js

@@ -71,6 +71,35 @@ const _UpdateGuard = class _UpdateGuard {
   setBlackList(blackList) {
     this.blackList = blackList;
   }
+  checkValues(values) {
+    const dfs = /* @__PURE__ */ __name((values2, model) => {
+      const associations = model.associations;
+      const belongsToManyThroughNames = [];
+      const associationValueKeys = Object.keys(associations).filter((key) => {
+        return Object.keys(values2).includes(key);
+      });
+      const belongsToManyValueKeys = associationValueKeys.filter((key) => {
+        return associations[key].associationType === "BelongsToMany";
+      });
+      const hasManyValueKeys = associationValueKeys.filter((key) => {
+        return associations[key].associationType === "HasMany";
+      });
+      for (const belongsToManyKey of belongsToManyValueKeys) {
+        const association = associations[belongsToManyKey];
+        const through = association.through.model;
+        belongsToManyThroughNames.push(through.name);
+      }
+      for (const hasManyKey of hasManyValueKeys) {
+        const association = associations[hasManyKey];
+        if (belongsToManyThroughNames.includes(association.target.name)) {
+          throw new Error(
+            `HasMany association ${hasManyKey} cannot be used with BelongsToMany association ${association.target.name} with same through model`
+          );
+        }
+      }
+    }, "dfs");
+    dfs(values, this.model);
+  }
   /**
    * Sanitize values by whitelist blacklist
    * @param values
@@ -80,6 +109,7 @@ const _UpdateGuard = class _UpdateGuard {
     if (!this.model) {
       throw new Error("please set model first");
     }
+    this.checkValues(values);
     const associations = this.model.associations;
     const associationsValues = import_lodash.default.pick(values, Object.keys(associations));
     const listOfAssociation = /* @__PURE__ */ __name((list, association) => {

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@nocobase/database",
-  "version": "0.14.0-alpha.2",
+  "version": "0.14.0-alpha.4",
   "description": "",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
   "dependencies": {
-    "@nocobase/logger": "0.14.0-alpha.2",
-    "@nocobase/utils": "0.14.0-alpha.2",
+    "@nocobase/logger": "0.14.0-alpha.4",
+    "@nocobase/utils": "0.14.0-alpha.4",
     "async-mutex": "^0.3.2",
     "cron-parser": "4.4.0",
     "dayjs": "^1.11.8",
     "deepmerge": "^4.2.2",
     "excel-date-to-js": "^1.1.5",
+    "exponential-backoff": "^3.1.1",
     "flat": "^5.0.2",
     "glob": "^7.1.6",
     "graphlib": "^2.1.8",
@@ -29,5 +30,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/database"
   },
-  "gitHead": "ea841d4a1e8c37aa77b4fbae6a6a4937e2aa3c0a"
+  "gitHead": "e2aab7863bbdfd76afc7164272b275e868ac59c0"
 }