@tachybase/database 0.23.8

package/lib/magic-attribute-model.js

@@ -0,0 +1,203 @@
+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 magic_attribute_model_exports = {};
+__export(magic_attribute_model_exports, {
+  MagicAttributeModel: () => MagicAttributeModel
+});
+module.exports = __toCommonJS(magic_attribute_model_exports);
+var import_utils = require("@tachybase/utils");
+var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
+var import_model = require("./model");
+const Dottie = require("dottie");
+const _MagicAttributeModel = class _MagicAttributeModel extends import_model.Model {
+  get magicAttribute() {
+    const db = this.constructor.database;
+    const collection = db.getCollection(this.constructor.name);
+    return collection.options.magicAttribute || "options";
+  }
+  set(key, value, options) {
+    if (typeof key === "string") {
+      const [column] = key.split(".");
+      if (this.constructor.hasAlias(column)) {
+        return this.setV1(key, value, options);
+      }
+      if (this.constructor.rawAttributes[column]) {
+        return this.setV1(key, value, options);
+      }
+      if (import_lodash.default.isPlainObject(value)) {
+        const opts = super.get(this.magicAttribute) || {};
+        return this.setV1(`${this.magicAttribute}.${key}`, (0, import_utils.merge)(opts == null ? void 0 : opts[key], value), options);
+      }
+      return this.setV1(`${this.magicAttribute}.${key}`, value, options);
+    } else {
+      if (!key) {
+        return;
+      }
+      Object.keys(key).forEach((k) => {
+        this.setV1(k, key[k], options);
+      });
+    }
+    return this.setV1(key, value, options);
+  }
+  setV1(key, value, options) {
+    let values;
+    let originalValue;
+    if (typeof key === "object" && key !== null) {
+      values = key;
+      options = value || {};
+      if (options.reset) {
+        this.dataValues = {};
+        for (const key2 in values) {
+          this.changed(key2, false);
+        }
+      }
+      if (options.raw && // @ts-ignore
+      !(this._options && this._options.include) && !(options && options.attributes) && // @ts-ignore
+      !this.constructor._hasDateAttributes && // @ts-ignore
+      !this.constructor._hasBooleanAttributes) {
+        if (Object.keys(this.dataValues).length) {
+          Object.assign(this.dataValues, values);
+        } else {
+          this.dataValues = values;
+        }
+        this._previousDataValues = { ...this.dataValues };
+      } else {
+        if (options.attributes) {
+          const setKeys = /* @__PURE__ */ __name((data) => {
+            for (const k of data) {
+              if (values[k] === void 0) {
+                continue;
+              }
+              this.set(k, values[k], options);
+            }
+          }, "setKeys");
+          setKeys(options.attributes);
+          if (this.constructor._hasVirtualAttributes) {
+            setKeys(this.constructor._virtualAttributes);
+          }
+          if (this._options.includeNames) {
+            setKeys(this._options.includeNames);
+          }
+        } else {
+          for (const key2 in values) {
+            this.set(key2, values[key2], options);
+          }
+        }
+        if (options.raw) {
+          this._previousDataValues = { ...this.dataValues };
+        }
+      }
+      return this;
+    }
+    if (!options) options = {};
+    if (!options.raw) {
+      originalValue = this.dataValues[key];
+    }
+    if (!options.raw && this._customSetters[key]) {
+      this._customSetters[key].call(this, value, key);
+      const newValue = this.dataValues[key];
+      if (!import_lodash.default.isEqual(newValue, originalValue)) {
+        this._previousDataValues[key] = originalValue;
+        this.changed(key, true);
+      }
+    } else {
+      if (this._options && this._options.include && this._options.includeNames.includes(key)) {
+        this._setInclude(key, value, options);
+        return this;
+      }
+      if (!options.raw) {
+        if (!this._isAttribute(key)) {
+          if (key.includes(".") && this.constructor._jsonAttributes.has(key.split(".")[0])) {
+            const previousNestedValue = Dottie.get(this.dataValues, key);
+            if (!import_lodash.default.isEqual(previousNestedValue, value)) {
+              this._previousDataValues = import_lodash.default.cloneDeep(this._previousDataValues);
+              Dottie.set(this.dataValues, key, value);
+              this.changed(key.split(".")[0], true);
+            }
+          }
+          return this;
+        }
+        if (this.constructor._hasPrimaryKeys && originalValue && this.constructor._isPrimaryKey(key)) {
+          return this;
+        }
+        if (!this.isNewRecord && // @ts-ignore
+        this.constructor._hasReadOnlyAttributes && // @ts-ignore
+        this.constructor._readOnlyAttributes.has(key)) {
+          return this;
+        }
+      }
+      if (!(value instanceof import_sequelize.Utils.SequelizeMethod) && // @ts-ignore
+      Object.prototype.hasOwnProperty.call(this.constructor._dataTypeSanitizers, key)) {
+        value = this.constructor._dataTypeSanitizers[key].call(this, value, options);
+      }
+      if (!options.raw && // True when sequelize method
+      (value instanceof import_sequelize.Utils.SequelizeMethod || // Check for data type type comparators
+      // @ts-ignore
+      !(value instanceof import_sequelize.Utils.SequelizeMethod) && // @ts-ignore
+      this.constructor._dataTypeChanges[key] && // @ts-ignore
+      this.constructor._dataTypeChanges[key].call(this, value, originalValue, options) || // Check default
+      // @ts-ignore
+      !this.constructor._dataTypeChanges[key] && !import_lodash.default.isEqual(value, originalValue))) {
+        this._previousDataValues[key] = originalValue;
+        this.changed(key, true);
+      }
+      this.dataValues[key] = value;
+    }
+    return this;
+  }
+  get(key, value) {
+    if (typeof key === "string") {
+      const [column] = key.split(".");
+      if (this.constructor.hasAlias(column)) {
+        return super.get(key, value);
+      }
+      if (this.constructor.rawAttributes[column]) {
+        return super.get(key, value);
+      }
+      const options = super.get(this.magicAttribute, value);
+      return import_lodash.default.get(options, key);
+    }
+    const data = super.get(key, value);
+    return {
+      ...import_lodash.default.omit(data, this.magicAttribute),
+      ...data[this.magicAttribute]
+    };
+  }
+  async update(values, options) {
+    this._changed = /* @__PURE__ */ new Set();
+    return super.update(values, options);
+  }
+};
+__name(_MagicAttributeModel, "MagicAttributeModel");
+let MagicAttributeModel = _MagicAttributeModel;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MagicAttributeModel
+});

package/lib/migration.d.ts

@@ -0,0 +1,35 @@
+import { QueryInterface, Sequelize } from 'sequelize';
+import Database from './database';
+export interface MigrationContext {
+    db: Database;
+    queryInterface: QueryInterface;
+    sequelize: Sequelize;
+}
+export declare class Migration {
+    name: string;
+    context: {
+        db: Database;
+        [key: string]: any;
+    };
+    constructor(context: MigrationContext);
+    get db(): Database;
+    get sequelize(): Sequelize;
+    get queryInterface(): QueryInterface;
+    up(): Promise<void>;
+    down(): Promise<void>;
+}
+export interface MigrationItem {
+    name: string;
+    migration?: typeof Migration | string;
+    context?: any;
+    up?: any;
+    down?: any;
+}
+export declare class Migrations {
+    items: any[];
+    context: any;
+    constructor(context: any);
+    clear(): void;
+    add(item: MigrationItem): void;
+    callback(): (ctx: any) => Promise<any[]>;
+}

package/lib/migration.js

@@ -0,0 +1,103 @@
+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 migration_exports = {};
+__export(migration_exports, {
+  Migration: () => Migration,
+  Migrations: () => Migrations
+});
+module.exports = __toCommonJS(migration_exports);
+var import_utils = require("@tachybase/utils");
+var import_lodash = __toESM(require("lodash"));
+const _Migration = class _Migration {
+  name;
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  get db() {
+    return this.context.db;
+  }
+  get sequelize() {
+    return this.context.db.sequelize;
+  }
+  get queryInterface() {
+    return this.context.db.sequelize.getQueryInterface();
+  }
+  async up() {
+  }
+  async down() {
+  }
+};
+__name(_Migration, "Migration");
+let Migration = _Migration;
+const _Migrations = class _Migrations {
+  items = [];
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  clear() {
+    this.items = [];
+  }
+  add(item) {
+    const Migration2 = item.migration;
+    if (Migration2 && typeof Migration2 === "function") {
+      const migration = new Migration2({ ...this.context, ...item.context });
+      migration.name = item.name;
+      this.items.push(migration);
+    } else {
+      this.items.push(item);
+    }
+  }
+  callback() {
+    return async (ctx) => {
+      return await Promise.all(
+        import_lodash.default.sortBy(this.items, (item) => {
+          const keys = item.name.split("/");
+          return keys.pop() || item.name;
+        }).map(async (item) => {
+          if (typeof item.migration === "string") {
+            const Migration2 = await (0, import_utils.importModule)(item.migration);
+            const migration = new Migration2({ ...this.context, ...item.context });
+            migration.name = item.name;
+            return migration;
+          }
+          return item;
+        })
+      );
+    };
+  }
+};
+__name(_Migrations, "Migrations");
+let Migrations = _Migrations;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Migration,
+  Migrations
+});

package/lib/mock-database.d.ts

@@ -0,0 +1,25 @@
+import { Database, IDatabaseOptions } from './database';
+export declare class MockDatabase extends Database {
+    constructor(options: IDatabaseOptions);
+}
+export declare function getConfigByEnv(): {
+    username: string;
+    password: string;
+    database: string;
+    host: string;
+    port: string;
+    dialect: string;
+    logging: boolean | typeof customLogger;
+    storage: string;
+    define: {
+        charset: string;
+        collate: string;
+    };
+    timezone: string;
+    underscored: boolean;
+    schema: string;
+    dialectOptions: {};
+};
+declare function customLogger(queryString: any, queryObject: any): void;
+export declare function mockDatabase(options?: IDatabaseOptions): MockDatabase;
+export {};

package/lib/mock-database.js

@@ -0,0 +1,126 @@
+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 mock_database_exports = {};
+__export(mock_database_exports, {
+  MockDatabase: () => MockDatabase,
+  getConfigByEnv: () => getConfigByEnv,
+  mockDatabase: () => mockDatabase
+});
+module.exports = __toCommonJS(mock_database_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@tachybase/utils");
+var import_nanoid = require("nanoid");
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_database = require("./database");
+const _MockDatabase = class _MockDatabase extends import_database.Database {
+  constructor(options) {
+    super({
+      storage: ":memory:",
+      dialect: "sqlite",
+      ...options
+    });
+  }
+};
+__name(_MockDatabase, "MockDatabase");
+let MockDatabase = _MockDatabase;
+function getConfigByEnv() {
+  const options = {
+    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,
+    dialect: process.env.DB_DIALECT || "sqlite",
+    logging: process.env.DB_LOGGING === "on" ? customLogger : false,
+    storage: process.env.DB_STORAGE,
+    define: {
+      charset: "utf8mb4",
+      collate: "utf8mb4_unicode_ci"
+    },
+    timezone: process.env.DB_TIMEZONE,
+    underscored: process.env.DB_UNDERSCORED === "true",
+    schema: process.env.DB_SCHEMA !== "public" ? process.env.DB_SCHEMA : void 0,
+    dialectOptions: {}
+  };
+  if (process.env.DB_DIALECT == "postgres") {
+    options.dialectOptions["application_name"] = "tachybase.main";
+  }
+  return options;
+}
+__name(getConfigByEnv, "getConfigByEnv");
+function customLogger(queryString, queryObject) {
+  console.log(queryString);
+  if (queryObject.bind) {
+    console.log(queryObject.bind);
+  }
+}
+__name(customLogger, "customLogger");
+function mockDatabase(options = {}) {
+  const dbOptions = (0, import_utils.merge)(getConfigByEnv(), options);
+  if (process.env["DB_TEST_PREFIX"]) {
+    let configKey = "database";
+    if (dbOptions.dialect === "sqlite") {
+      configKey = "storage";
+    } else {
+      configKey = "database";
+    }
+    const shouldChange = /* @__PURE__ */ __name(() => {
+      if (dbOptions.dialect === "sqlite") {
+        return !dbOptions[configKey].includes(process.env["DB_TEST_PREFIX"]);
+      }
+      return !dbOptions[configKey].startsWith(process.env["DB_TEST_PREFIX"]);
+    }, "shouldChange");
+    if (dbOptions[configKey] && shouldChange()) {
+      const nanoid = (0, import_nanoid.customAlphabet)("1234567890abcdefghijklmnopqrstuvwxyz", 10);
+      const instanceId = `d_${nanoid()}`;
+      const databaseName = `${process.env["DB_TEST_PREFIX"]}_${instanceId}`;
+      if (dbOptions.dialect === "sqlite") {
+        dbOptions.storage = import_path.default.resolve(import_path.default.dirname(dbOptions.storage), databaseName);
+      } else {
+        dbOptions.database = databaseName;
+      }
+    }
+    if (process.env["DB_TEST_DISTRIBUTOR_PORT"]) {
+      dbOptions.hooks = dbOptions.hooks || {};
+      dbOptions.hooks.beforeConnect = async (config) => {
+        const url = `http://127.0.0.1:${process.env["DB_TEST_DISTRIBUTOR_PORT"]}/acquire?via=${db.instanceId}&name=${config.database}`;
+        await (0, import_node_fetch.default)(url);
+      };
+    }
+  }
+  const db = new MockDatabase(dbOptions);
+  return db;
+}
+__name(mockDatabase, "mockDatabase");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MockDatabase,
+  getConfigByEnv,
+  mockDatabase
+});

package/lib/model-hook.d.ts

@@ -0,0 +1,12 @@
+import { SequelizeHooks } from 'sequelize/types/hooks';
+import Database from './database';
+export declare class ModelHook {
+    database: Database;
+    boundEvents: Set<string>;
+    constructor(database: Database);
+    match(event: string | symbol): keyof SequelizeHooks | null;
+    findModelName(hookArgs: any): any;
+    bindEvent(type: any): void;
+    hasBoundEvent(type: any): boolean;
+    buildSequelizeHook(type: any): (...args: any[]) => Promise<void>;
+}

package/lib/model-hook.js

@@ -0,0 +1,92 @@
+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 model_hook_exports = {};
+__export(model_hook_exports, {
+  ModelHook: () => ModelHook
+});
+module.exports = __toCommonJS(model_hook_exports);
+var import_lodash = __toESM(require("lodash"));
+const { hooks } = require("sequelize/lib/hooks");
+const _ModelHook = class _ModelHook {
+  database;
+  boundEvents = /* @__PURE__ */ new Set();
+  constructor(database) {
+    this.database = database;
+  }
+  match(event) {
+    if (!import_lodash.default.isString(event)) {
+      return null;
+    }
+    const type = event.split(".").pop();
+    return type in hooks ? type : null;
+  }
+  findModelName(hookArgs) {
+    var _a, _b;
+    for (const arg of hookArgs) {
+      if (arg == null ? void 0 : arg._previousDataValues) {
+        return arg.constructor.name;
+      }
+      if (import_lodash.default.isPlainObject(arg)) {
+        if (arg["model"]) {
+          return arg["model"].name;
+        }
+        const plural = (_a = arg == null ? void 0 : arg.name) == null ? void 0 : _a.plural;
+        if (this.database.sequelize.isDefined(plural)) {
+          return plural;
+        }
+        const singular = (_b = arg == null ? void 0 : arg.name) == null ? void 0 : _b.singular;
+        if (this.database.sequelize.isDefined(singular)) {
+          return singular;
+        }
+      }
+    }
+    return null;
+  }
+  bindEvent(type) {
+    this.boundEvents.add(type);
+  }
+  hasBoundEvent(type) {
+    return this.boundEvents.has(type);
+  }
+  buildSequelizeHook(type) {
+    return async (...args) => {
+      const modelName = this.findModelName(args);
+      if (modelName) {
+        await this.database.emitAsync(`${modelName}.${type}`, ...args);
+      }
+      await this.database.emitAsync(type, ...args);
+    };
+  }
+};
+__name(_ModelHook, "ModelHook");
+let ModelHook = _ModelHook;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModelHook
+});

package/lib/model.d.ts

@@ -0,0 +1,23 @@
+import { Model as SequelizeModel } from 'sequelize';
+import { Collection } from './collection';
+import { Database } from './database';
+interface IModel {
+    [key: string]: any;
+}
+export declare class Model<TModelAttributes extends {} = any, TCreationAttributes extends {} = TModelAttributes> extends SequelizeModel<TModelAttributes, TCreationAttributes> implements IModel {
+    static database: Database;
+    static collection: Collection;
+    [key: string]: any;
+    protected _changedWithAssociations: Set<unknown>;
+    protected _previousDataValuesWithAssociations: {};
+    get db(): Database;
+    static sync(options: any): Promise<any>;
+    toChangedWithAssociations(): void;
+    changedWithAssociations(key?: string, value?: any): boolean | unknown[] | this;
+    clearChangedWithAssociations(): void;
+    toJSON<T extends TModelAttributes>(): T;
+    private hiddenObjKey;
+    private sortAssociations;
+    private sortArray;
+}
+export {};