@tachybase/database 0.23.8

package/lib/filter-parser.js

@@ -0,0 +1,230 @@
+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 filter_parser_exports = {};
+__export(filter_parser_exports, {
+  default: () => FilterParser
+});
+module.exports = __toCommonJS(filter_parser_exports);
+var import_flat = require("flat");
+var import_lodash = __toESM(require("lodash"));
+const debug = require("debug")("noco-database");
+const _FilterParser = class _FilterParser {
+  collection;
+  database;
+  model;
+  filter;
+  context;
+  constructor(filter, context) {
+    const { collection } = context;
+    this.collection = collection;
+    this.context = context;
+    this.model = collection.model;
+    this.filter = this.prepareFilter(filter);
+    this.database = collection.context.database;
+  }
+  prepareFilter(filter) {
+    if (import_lodash.default.isPlainObject(filter)) {
+      const renamedKey = {};
+      for (const key of Object.keys(filter)) {
+        if (key.endsWith(".$exists") || key.endsWith(".$notExists")) {
+          const keyArr = key.split(".");
+          if (keyArr[keyArr.length - 2] == "id") {
+            continue;
+          }
+          keyArr.splice(keyArr.length - 1, 0, "id");
+          renamedKey[key] = keyArr.join(".");
+        }
+      }
+      for (const [oldKey, newKey] of Object.entries(renamedKey)) {
+        filter[newKey] = filter[oldKey];
+        delete filter[oldKey];
+      }
+    }
+    return filter;
+  }
+  toSequelizeParams() {
+    debug("filter %o", this.filter);
+    if (!this.filter) {
+      return {};
+    }
+    const filter = this.filter;
+    const model = this.model;
+    const operators = this.database.operators;
+    const originalFiler = import_lodash.default.cloneDeep(filter || {});
+    const flattenedFilter = (0, import_flat.flatten)(filter || {});
+    debug("flattened filter %o", flattenedFilter);
+    const include = {};
+    const where = {};
+    let skipPrefix = null;
+    const associations = model.associations;
+    debug("associations %O", associations);
+    for (const [key, _value] of Object.entries(flattenedFilter)) {
+      let value = _value;
+      if (skipPrefix && key.startsWith(skipPrefix)) {
+        continue;
+      }
+      if ((key == "$or" || key == "$and") && Array.isArray(value) && value.length == 0) {
+        continue;
+      }
+      debug('handle filter key "%s: "%s"', key, value);
+      const keys = key.split(".");
+      const paths = [];
+      const origins = [];
+      while (keys.length) {
+        debug("keys: %o, paths: %o, origins: %o", keys, paths, origins);
+        const firstKey = keys.shift();
+        origins.push(firstKey);
+        debug("origins: %o", origins);
+        if (firstKey.startsWith("$")) {
+          if (operators.has(firstKey)) {
+            debug("%s is operator", firstKey);
+            const opKey = operators.get(firstKey);
+            debug("operator key %s, operator: %o", firstKey, opKey);
+            if (typeof opKey === "symbol") {
+              paths.push(opKey);
+              continue;
+            } else if (typeof opKey === "function") {
+              skipPrefix = origins.join(".");
+              const queryValue = import_lodash.default.get((0, import_flat.unflatten)(originalFiler), skipPrefix);
+              const [fieldName, fullName] = this.getFieldNameFromQueryPath(skipPrefix);
+              value = opKey(queryValue, {
+                app: this.context.app,
+                db: this.database,
+                path: skipPrefix,
+                fullName,
+                fieldName,
+                fieldPath: `${this.collection.name}.${fullName}`,
+                model: this.model
+              });
+              break;
+            }
+          } else {
+            paths.push(firstKey);
+            continue;
+          }
+        }
+        if (!import_lodash.default.isNaN(parseInt(firstKey))) {
+          paths.push(firstKey);
+          continue;
+        }
+        if (!associations[firstKey]) {
+          paths.push(firstKey);
+          continue;
+        }
+        const associationKeys = [];
+        associationKeys.push(firstKey);
+        debug("associationKeys %o", associationKeys);
+        const existInclude = import_lodash.default.get(include, firstKey);
+        if (!existInclude) {
+          import_lodash.default.set(include, firstKey, {
+            association: firstKey,
+            attributes: []
+            // out put empty fields by default
+          });
+        }
+        let target = associations[firstKey].target;
+        debug("association target %o", target);
+        while (target) {
+          const attr = keys.shift();
+          origins.push(attr);
+          if (target.rawAttributes[attr]) {
+            associationKeys.push(target.rawAttributes[attr].field || attr);
+            target = null;
+          } else if (target.associations[attr]) {
+            associationKeys.push(attr);
+            const assoc = [];
+            associationKeys.forEach((associationKey, index) => {
+              if (index > 0) {
+                assoc.push("include");
+              }
+              assoc.push(associationKey);
+            });
+            const existInclude2 = import_lodash.default.get(include, assoc);
+            if (!existInclude2) {
+              import_lodash.default.set(include, assoc, {
+                association: attr,
+                attributes: []
+              });
+            }
+            target = target.associations[attr].target;
+          } else {
+            throw new Error(`${attr} neither ${firstKey}'s association nor ${firstKey}'s attribute`);
+          }
+        }
+        debug("associationKeys %o", associationKeys);
+        if (associationKeys.length > 1) {
+          paths.push(`$${associationKeys.join(".")}$`);
+        } else {
+          paths.push(firstKey);
+        }
+      }
+      debug("where %o, paths %o, value, %o", where, paths, value);
+      const values = import_lodash.default.get(where, paths);
+      if (values && typeof values === "object" && value && typeof value === "object") {
+        value = { ...value, ...values };
+      }
+      import_lodash.default.set(where, paths, value);
+    }
+    const toInclude = /* @__PURE__ */ __name((items) => {
+      return Object.values(items).map((item) => {
+        if (item.include) {
+          item.include = toInclude(item.include);
+        }
+        return item;
+      });
+    }, "toInclude");
+    debug("where %o, include %o", where, include);
+    const results = { where, include: toInclude(include) };
+    const traverseInclude = /* @__PURE__ */ __name((include2) => {
+      for (const item of include2) {
+        if (item.include) {
+          traverseInclude(item.include);
+        }
+        item.fromFilter = true;
+      }
+    }, "traverseInclude");
+    traverseInclude(results.include);
+    return results;
+  }
+  getFieldNameFromQueryPath(queryPath) {
+    const paths = queryPath.split(".");
+    let fieldName;
+    const fullPaths = [];
+    for (const path of paths) {
+      if (path.startsWith("$") || !import_lodash.default.isNaN(parseInt(path))) {
+        continue;
+      }
+      fullPaths.push(path);
+      fieldName = path;
+    }
+    return [fieldName, fullPaths.join(".")];
+  }
+};
+__name(_FilterParser, "FilterParser");
+let FilterParser = _FilterParser;

package/lib/helpers.d.ts

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

package/lib/helpers.js

@@ -0,0 +1,167 @@
+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, {
+  checkDatabaseVersion: () => checkDatabaseVersion,
+  parseDatabaseOptionsFromEnv: () => parseDatabaseOptionsFromEnv
+});
+module.exports = __toCommonJS(helpers_exports);
+var import_fs = __toESM(require("fs"));
+var import_semver = __toESM(require("semver"));
+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");
+const dialectVersionAccessors = {
+  sqlite: {
+    sql: "select sqlite_version() as version",
+    get: /* @__PURE__ */ __name((v) => v, "get"),
+    version: "3.x"
+  },
+  mysql: {
+    sql: "select version() as version",
+    get: /* @__PURE__ */ __name((v) => {
+      const m = /([\d+.]+)/.exec(v);
+      return m[0];
+    }, "get"),
+    version: ">=8.0.17"
+  },
+  mariadb: {
+    sql: "select version() as version",
+    get: /* @__PURE__ */ __name((v) => {
+      const m = /([\d+.]+)/.exec(v);
+      return m[0];
+    }, "get"),
+    version: ">=10.9"
+  },
+  postgres: {
+    sql: "select version() as version",
+    get: /* @__PURE__ */ __name((v) => {
+      const m = /([\d+.]+)/.exec(v);
+      return import_semver.default.minVersion(m[0]).version;
+    }, "get"),
+    version: ">=10"
+  }
+};
+async function checkDatabaseVersion(db) {
+  var _a;
+  const dialect = db.sequelize.getDialect();
+  const accessor = dialectVersionAccessors[dialect];
+  if (!accessor) {
+    throw new Error(`unsupported dialect ${dialect}`);
+  }
+  const result = await db.sequelize.query(accessor.sql, {
+    type: "SELECT"
+  });
+  const version = accessor.get((_a = result == null ? void 0 : result[0]) == null ? void 0 : _a.version);
+  const versionResult = import_semver.default.satisfies(version, accessor.version);
+  if (!versionResult) {
+    throw new Error(`to use ${dialect}, please ensure the version is ${accessor.version}`);
+  }
+  return true;
+}
+__name(checkDatabaseVersion, "checkDatabaseVersion");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkDatabaseVersion,
+  parseDatabaseOptionsFromEnv
+});

package/lib/index.d.ts

@@ -0,0 +1,30 @@
+export { BaseError, DataTypes, fn, literal, Op, Transaction, UniqueConstraintError, ValidationError, ValidationErrorItem, where, } from 'sequelize';
+export type { BelongsToGetAssociationMixin, HasManyCountAssociationsMixin, HasManyCreateAssociationMixin, HasManyGetAssociationsMixin, ModelStatic, SyncOptions, } from 'sequelize';
+export * from './collection';
+export * from './collection-group-manager';
+export * from './collection-importer';
+export * from './database';
+export { Database as default } from './database';
+export * from './field-repository/array-field-repository';
+export * from './fields';
+export * from './filter-match';
+export { default as FilterParser } from './filter-parser';
+export * from './inherited-collection';
+export * from './magic-attribute-model';
+export * from './migration';
+export * from './mock-database';
+export * from './model';
+export * from './relation-repository/belongs-to-many-repository';
+export * from './relation-repository/belongs-to-repository';
+export * from './relation-repository/hasmany-repository';
+export * from './relation-repository/multiple-relation-repository';
+export * from './relation-repository/single-relation-repository';
+export * from './repository';
+export * from './update-associations';
+export { snakeCase } from './utils';
+export * from './database-utils';
+export * from './value-parsers';
+export * from './view-collection';
+export * from './view/view-inference';
+export * from './sql-collection';
+export * from './helpers';

package/lib/index.js

@@ -0,0 +1,114 @@
+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 __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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  BaseError: () => import_sequelize.BaseError,
+  DataTypes: () => import_sequelize.DataTypes,
+  FilterParser: () => import_filter_parser.default,
+  Op: () => import_sequelize.Op,
+  Transaction: () => import_sequelize.Transaction,
+  UniqueConstraintError: () => import_sequelize.UniqueConstraintError,
+  ValidationError: () => import_sequelize.ValidationError,
+  ValidationErrorItem: () => import_sequelize.ValidationErrorItem,
+  default: () => import_database.Database,
+  fn: () => import_sequelize.fn,
+  literal: () => import_sequelize.literal,
+  snakeCase: () => import_utils.snakeCase,
+  where: () => import_sequelize.where
+});
+module.exports = __toCommonJS(src_exports);
+var import_sequelize = require("sequelize");
+__reExport(src_exports, require("./collection"), module.exports);
+__reExport(src_exports, require("./collection-group-manager"), module.exports);
+__reExport(src_exports, require("./collection-importer"), module.exports);
+__reExport(src_exports, require("./database"), module.exports);
+var import_database = require("./database");
+__reExport(src_exports, require("./field-repository/array-field-repository"), module.exports);
+__reExport(src_exports, require("./fields"), module.exports);
+__reExport(src_exports, require("./filter-match"), module.exports);
+var import_filter_parser = __toESM(require("./filter-parser"));
+__reExport(src_exports, require("./inherited-collection"), module.exports);
+__reExport(src_exports, require("./magic-attribute-model"), module.exports);
+__reExport(src_exports, require("./migration"), module.exports);
+__reExport(src_exports, require("./mock-database"), module.exports);
+__reExport(src_exports, require("./model"), module.exports);
+__reExport(src_exports, require("./relation-repository/belongs-to-many-repository"), module.exports);
+__reExport(src_exports, require("./relation-repository/belongs-to-repository"), module.exports);
+__reExport(src_exports, require("./relation-repository/hasmany-repository"), module.exports);
+__reExport(src_exports, require("./relation-repository/multiple-relation-repository"), module.exports);
+__reExport(src_exports, require("./relation-repository/single-relation-repository"), module.exports);
+__reExport(src_exports, require("./repository"), module.exports);
+__reExport(src_exports, require("./update-associations"), module.exports);
+var import_utils = require("./utils");
+__reExport(src_exports, require("./database-utils"), module.exports);
+__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("./sql-collection"), module.exports);
+__reExport(src_exports, require("./helpers"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseError,
+  DataTypes,
+  FilterParser,
+  Op,
+  Transaction,
+  UniqueConstraintError,
+  ValidationError,
+  ValidationErrorItem,
+  fn,
+  literal,
+  snakeCase,
+  where,
+  ...require("./collection"),
+  ...require("./collection-group-manager"),
+  ...require("./collection-importer"),
+  ...require("./database"),
+  ...require("./field-repository/array-field-repository"),
+  ...require("./fields"),
+  ...require("./filter-match"),
+  ...require("./inherited-collection"),
+  ...require("./magic-attribute-model"),
+  ...require("./migration"),
+  ...require("./mock-database"),
+  ...require("./model"),
+  ...require("./relation-repository/belongs-to-many-repository"),
+  ...require("./relation-repository/belongs-to-repository"),
+  ...require("./relation-repository/hasmany-repository"),
+  ...require("./relation-repository/multiple-relation-repository"),
+  ...require("./relation-repository/single-relation-repository"),
+  ...require("./repository"),
+  ...require("./update-associations"),
+  ...require("./database-utils"),
+  ...require("./value-parsers"),
+  ...require("./view-collection"),
+  ...require("./view/view-inference"),
+  ...require("./sql-collection"),
+  ...require("./helpers")
+});

package/lib/inherited-collection.d.ts

@@ -0,0 +1,14 @@
+import { Field } from '.';
+import { Collection, CollectionContext, CollectionOptions } from './collection';
+export declare class InheritedCollection extends Collection {
+    parents?: Collection[];
+    constructor(options: CollectionOptions, context: CollectionContext);
+    getParents(): Collection<any, any>[];
+    getFlatParents(): any[];
+    parentFields(): Map<string, Field>;
+    parentAttributes(): {};
+    isInherited(): boolean;
+    protected bindParents(): void;
+    protected setParents(inherits: string | string[]): void;
+    protected setParentFields(): void;
+}