@tachybase/database 0.23.8

package/lib/inherited-collection.js

@@ -0,0 +1,138 @@
+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 inherited_collection_exports = {};
+__export(inherited_collection_exports, {
+  InheritedCollection: () => InheritedCollection
+});
+module.exports = __toCommonJS(inherited_collection_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_collection = require("./collection");
+const _InheritedCollection = class _InheritedCollection extends import_collection.Collection {
+  parents;
+  constructor(options, context) {
+    if (!options.inherits) {
+      throw new Error("InheritedCollection must have inherits option");
+    }
+    options.inherits = import_lodash.default.castArray(options.inherits);
+    super(options, context);
+    try {
+      this.bindParents();
+    } catch (err) {
+      if (err instanceof ParentCollectionNotFound) {
+        const listener = /* @__PURE__ */ __name((collection) => {
+          if (options.inherits.includes(collection.name) && options.inherits.every((name) => this.db.collections.has(name))) {
+            this.bindParents();
+            this.db.removeListener("afterDefineCollection", listener);
+          }
+        }, "listener");
+        this.db.addListener("afterDefineCollection", listener);
+      } else {
+        throw err;
+      }
+    }
+  }
+  getParents() {
+    return this.parents;
+  }
+  getFlatParents() {
+    const parents = [];
+    for (const parent of this.parents) {
+      if (parent.isInherited()) {
+        parents.push(...parent.getFlatParents());
+      }
+      parents.push(parent);
+    }
+    return parents;
+  }
+  parentFields() {
+    const fields = /* @__PURE__ */ new Map();
+    for (const parent of this.parents) {
+      if (parent.isInherited()) {
+        for (const [name, field] of parent.parentFields()) {
+          fields.set(name, field.options);
+        }
+      }
+      const parentFields = parent.fields;
+      for (const [name, field] of parentFields) {
+        fields.set(name, field.options);
+      }
+    }
+    return fields;
+  }
+  parentAttributes() {
+    const attributes = {};
+    for (const parent of this.parents) {
+      if (parent.isInherited()) {
+        Object.assign(attributes, parent.parentAttributes());
+      }
+      const parentAttributes = parent.model.tableAttributes;
+      Object.assign(attributes, parentAttributes);
+    }
+    return attributes;
+  }
+  isInherited() {
+    return true;
+  }
+  bindParents() {
+    this.setParents(this.options.inherits);
+    this.setParentFields();
+    this.setFields(this.options.fields, false);
+    this.db.inheritanceMap.setInheritance(this.name, this.options.inherits);
+  }
+  setParents(inherits) {
+    this.parents = import_lodash.default.castArray(inherits).map((name) => {
+      const existCollection = this.db.collections.get(name);
+      if (!existCollection) {
+        throw new ParentCollectionNotFound(name);
+      }
+      return existCollection;
+    });
+  }
+  setParentFields() {
+    for (const [name, fieldOptions] of this.parentFields()) {
+      this.setField(name, {
+        ...fieldOptions,
+        inherit: true
+      });
+    }
+  }
+};
+__name(_InheritedCollection, "InheritedCollection");
+let InheritedCollection = _InheritedCollection;
+const _ParentCollectionNotFound = class _ParentCollectionNotFound extends Error {
+  constructor(name) {
+    super(`parent collection ${name} not found`);
+  }
+};
+__name(_ParentCollectionNotFound, "ParentCollectionNotFound");
+let ParentCollectionNotFound = _ParentCollectionNotFound;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InheritedCollection
+});

package/lib/inherited-map.d.ts

@@ -0,0 +1,21 @@
+declare class TableNode {
+    name: string;
+    parents: Set<TableNode>;
+    children: Set<TableNode>;
+    constructor(name: string);
+}
+export default class InheritanceMap {
+    nodes: Map<string, TableNode>;
+    removeNode(name: string): void;
+    getOrCreateNode(name: string): TableNode;
+    getNode(name: string): TableNode;
+    setInheritance(name: string, inherits: string | string[]): void;
+    isParentNode(name: string): boolean;
+    getChildren(name: string, options?: {
+        deep: boolean;
+    }): Set<string>;
+    getParents(name: string, options?: {
+        deep: boolean;
+    }): Set<string>;
+}
+export {};

package/lib/inherited-map.js

@@ -0,0 +1,113 @@
+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 inherited_map_exports = {};
+__export(inherited_map_exports, {
+  default: () => InheritanceMap
+});
+module.exports = __toCommonJS(inherited_map_exports);
+var import_lodash = __toESM(require("lodash"));
+const _TableNode = class _TableNode {
+  name;
+  parents;
+  children;
+  constructor(name) {
+    this.name = name;
+    this.parents = /* @__PURE__ */ new Set();
+    this.children = /* @__PURE__ */ new Set();
+  }
+};
+__name(_TableNode, "TableNode");
+let TableNode = _TableNode;
+const _InheritanceMap = class _InheritanceMap {
+  nodes = /* @__PURE__ */ new Map();
+  removeNode(name) {
+    const node = this.nodes.get(name);
+    if (!node) return;
+    for (const parent of node.parents) {
+      parent.children.delete(node);
+    }
+    for (const child of node.children) {
+      child.parents.delete(node);
+    }
+    this.nodes.delete(name);
+  }
+  getOrCreateNode(name) {
+    if (!this.nodes.has(name)) {
+      this.nodes.set(name, new TableNode(name));
+    }
+    return this.getNode(name);
+  }
+  getNode(name) {
+    return this.nodes.get(name);
+  }
+  setInheritance(name, inherits) {
+    const node = this.getOrCreateNode(name);
+    const parents = import_lodash.default.castArray(inherits).map((name2) => this.getOrCreateNode(name2));
+    node.parents = new Set(parents);
+    for (const parent of parents) {
+      parent.children.add(node);
+    }
+  }
+  isParentNode(name) {
+    const node = this.getNode(name);
+    return node && node.children.size > 0;
+  }
+  getChildren(name, options = { deep: true }) {
+    const results = /* @__PURE__ */ new Set();
+    const node = this.getNode(name);
+    if (!node) return results;
+    for (const child of node.children) {
+      results.add(child.name);
+      if (!options.deep) {
+        continue;
+      }
+      for (const grandchild of this.getChildren(child.name)) {
+        results.add(grandchild);
+      }
+    }
+    return results;
+  }
+  getParents(name, options = { deep: true }) {
+    const results = /* @__PURE__ */ new Set();
+    const node = this.getNode(name);
+    if (!node) return results;
+    for (const parent of node.parents) {
+      results.add(parent.name);
+      if (!options.deep) {
+        continue;
+      }
+      for (const grandparent of this.getParents(parent.name)) {
+        results.add(grandparent);
+      }
+    }
+    return results;
+  }
+};
+__name(_InheritanceMap, "InheritanceMap");
+let InheritanceMap = _InheritanceMap;

package/lib/inherited-sync-runner.d.ts

@@ -0,0 +1,4 @@
+export declare class InheritedSyncRunner {
+    static syncInheritModel(model: any, options: any): Promise<void>;
+    static createTable(tableName: any, attributes: any, options: any, model: any, parents: any): Promise<any>;
+}

package/lib/inherited-sync-runner.js

@@ -0,0 +1,175 @@
+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 inherited_sync_runner_exports = {};
+__export(inherited_sync_runner_exports, {
+  InheritedSyncRunner: () => InheritedSyncRunner
+});
+module.exports = __toCommonJS(inherited_sync_runner_exports);
+var import_lodash = __toESM(require("lodash"));
+const _InheritedSyncRunner = class _InheritedSyncRunner {
+  static async syncInheritModel(model, options) {
+    const { transaction } = options;
+    const inheritedCollection = model.collection;
+    const db = inheritedCollection.context.database;
+    const dialect = db.sequelize.getDialect();
+    const queryInterface = db.sequelize.getQueryInterface();
+    if (dialect != "postgres") {
+      throw new Error("Inherit model is only supported on postgres");
+    }
+    const parents = inheritedCollection.parents;
+    if (!parents) {
+      throw new Error(
+        `Inherit model ${inheritedCollection.name} can't be created without parents, parents option is ${import_lodash.default.castArray(inheritedCollection.options.inherits).join(", ")}`
+      );
+    }
+    for (const parent of parents) {
+      if (Object.keys(parent.model.rawAttributes).length === 0) {
+        throw new Error(
+          `can't inherit from collection ${parent.options.name} because it has no attributes, please define at least one attribute in parent collection`
+        );
+      }
+    }
+    const tableName = inheritedCollection.getTableNameWithSchema();
+    const attributes = model.tableAttributes;
+    const childAttributes = import_lodash.default.pickBy(attributes, (value) => {
+      return !value.inherit;
+    });
+    if (!await inheritedCollection.existsInDb({
+      transaction
+    })) {
+      let maxSequenceVal = 0;
+      let maxSequenceName;
+      if (childAttributes.id && childAttributes.id.autoIncrement) {
+        for (const parent of parents) {
+          const sequenceNameResult = await queryInterface.sequelize.query(
+            `SELECT column_default
+           FROM information_schema.columns
+           WHERE table_name = '${parent.model.tableName}'
+             and table_schema = '${parent.collectionSchema()}'
+             and "column_name" = 'id';`,
+            {
+              transaction
+            }
+          );
+          if (!sequenceNameResult[0].length) {
+            continue;
+          }
+          const columnDefault = sequenceNameResult[0][0]["column_default"];
+          if (!columnDefault) {
+            throw new Error(`Can't find sequence name of parent collection ${parent.options.name}`);
+          }
+          const regex = new RegExp(/nextval\('(.*)'::regclass\)/);
+          const match = regex.exec(columnDefault);
+          const sequenceName = match[1];
+          const sequenceCurrentValResult = await queryInterface.sequelize.query(
+            `select last_value
+           from ${sequenceName}`,
+            {
+              transaction
+            }
+          );
+          const sequenceCurrentVal = parseInt(sequenceCurrentValResult[0][0]["last_value"]);
+          if (sequenceCurrentVal > maxSequenceVal) {
+            maxSequenceName = sequenceName;
+            maxSequenceVal = sequenceCurrentVal;
+          }
+        }
+      }
+      await this.createTable(tableName, childAttributes, options, model, parents);
+      if (maxSequenceName) {
+        const parentsDeep = Array.from(db.inheritanceMap.getParents(inheritedCollection.name)).map(
+          (parent) => db.getCollection(parent).getTableNameWithSchema()
+        );
+        const sequenceTables = [...parentsDeep, tableName];
+        for (const sequenceTable of sequenceTables) {
+          const tableName2 = sequenceTable.tableName;
+          const schemaName = sequenceTable.schema;
+          const idColumnSql = `SELECT column_name
+           FROM information_schema.columns
+           WHERE table_name = '${tableName2}'
+             and column_name = 'id'
+             and table_schema = '${schemaName}';
+          `;
+          const idColumnQuery = await queryInterface.sequelize.query(idColumnSql, {
+            transaction
+          });
+          if (idColumnQuery[0].length == 0) {
+            continue;
+          }
+          await queryInterface.sequelize.query(
+            `alter table ${db.utils.quoteTable(sequenceTable)}
+            alter column id set default nextval('${maxSequenceName}')`,
+            {
+              transaction
+            }
+          );
+        }
+      }
+    }
+    if (options.alter) {
+      const columns = await queryInterface.describeTable(tableName, options);
+      for (const attribute in childAttributes) {
+        const columnName = childAttributes[attribute].field;
+        if (!columns[columnName]) {
+          await queryInterface.addColumn(tableName, columnName, childAttributes[columnName], options);
+        }
+      }
+    }
+  }
+  static async createTable(tableName, attributes, options, model, parents) {
+    let sql = "";
+    options = { ...options };
+    if (options && options.uniqueKeys) {
+      import_lodash.default.forOwn(options.uniqueKeys, (uniqueKey) => {
+        if (uniqueKey.customIndex === void 0) {
+          uniqueKey.customIndex = true;
+        }
+      });
+    }
+    if (model) {
+      options.uniqueKeys = options.uniqueKeys || model.uniqueKeys;
+    }
+    const queryGenerator = model.queryGenerator;
+    attributes = import_lodash.default.mapValues(attributes, (attribute) => model.sequelize.normalizeAttribute(attribute));
+    attributes = queryGenerator.attributesToSQL(attributes, { table: tableName, context: "createTable" });
+    sql = `${queryGenerator.createTableQuery(tableName, attributes, options)}`.replace(
+      ";",
+      ` INHERITS (${parents.map((t) => {
+        return t.getTableNameWithSchema();
+      }).join(", ")});`
+    );
+    return await model.sequelize.query(sql, options);
+  }
+};
+__name(_InheritedSyncRunner, "InheritedSyncRunner");
+let InheritedSyncRunner = _InheritedSyncRunner;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InheritedSyncRunner
+});

package/lib/listeners/adjacency-list.d.ts

@@ -0,0 +1,2 @@
+import { CollectionOptions } from '../collection';
+export declare const beforeDefineAdjacencyListCollection: (options: CollectionOptions) => void;

package/lib/listeners/adjacency-list.js

@@ -0,0 +1,42 @@
+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 adjacency_list_exports = {};
+__export(adjacency_list_exports, {
+  beforeDefineAdjacencyListCollection: () => beforeDefineAdjacencyListCollection
+});
+module.exports = __toCommonJS(adjacency_list_exports);
+const beforeDefineAdjacencyListCollection = /* @__PURE__ */ __name((options) => {
+  if (!options.tree) {
+    return;
+  }
+  (options.fields || []).forEach((field) => {
+    if (field.treeParent || field.treeChildren) {
+      if (!field.target) {
+        field.target = options.name;
+      }
+      if (!field.foreignKey) {
+        field.foreignKey = "parentId";
+      }
+    }
+  });
+}, "beforeDefineAdjacencyListCollection");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  beforeDefineAdjacencyListCollection
+});

package/lib/listeners/append-child-collection-name-after-repository-find.d.ts

@@ -0,0 +1,6 @@
+import Database from '../database';
+export declare const appendChildCollectionNameAfterRepositoryFind: (db: Database) => ({ findOptions, dataCollection, data }: {
+    findOptions: any;
+    dataCollection: any;
+    data: any;
+}) => void;

package/lib/listeners/append-child-collection-name-after-repository-find.js

@@ -0,0 +1,66 @@
+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 append_child_collection_name_after_repository_find_exports = {};
+__export(append_child_collection_name_after_repository_find_exports, {
+  appendChildCollectionNameAfterRepositoryFind: () => appendChildCollectionNameAfterRepositoryFind
+});
+module.exports = __toCommonJS(append_child_collection_name_after_repository_find_exports);
+const setRowAttribute = /* @__PURE__ */ __name((row, attribute, value, raw) => {
+  if (raw) {
+    row[attribute] = value;
+  } else {
+    row.set(attribute, value, { raw: true });
+  }
+}, "setRowAttribute");
+const appendChildCollectionNameAfterRepositoryFind = /* @__PURE__ */ __name((db) => {
+  return ({ findOptions, dataCollection, data }) => {
+    if (findOptions.targetCollection) {
+      const collection = db.getCollection(findOptions.targetCollection);
+      for (const row of data) {
+        setRowAttribute(row, "__collection", collection.name, findOptions.raw);
+        setRowAttribute(row, "__schemaName", collection.collectionSchema(), findOptions.raw);
+        setRowAttribute(row, "__tableName", collection.model.tableName, findOptions.raw);
+      }
+      return;
+    }
+    if (dataCollection.isParent()) {
+      for (const row of data) {
+        if (row.__collection) {
+          continue;
+        }
+        const fullTableName = findOptions.raw ? `${row["__schemaName"]}.${row["__tableName"]}` : `${row.get("__schemaName")}.${row.get("__tableName")}`;
+        const rowCollection = db.tableNameCollectionMap.get(fullTableName);
+        if (!rowCollection) {
+          db.logger.warn(
+            `Can not find collection by table name ${JSON.stringify(row)}, current collections: ${Array.from(
+              db.tableNameCollectionMap.keys()
+            ).join(", ")}`
+          );
+          return;
+        }
+        const rowCollectionName = rowCollection.name;
+        setRowAttribute(row, "__collection", rowCollectionName, findOptions.raw);
+      }
+    }
+  };
+}, "appendChildCollectionNameAfterRepositoryFind");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendChildCollectionNameAfterRepositoryFind
+});

package/lib/listeners/index.d.ts

@@ -0,0 +1,2 @@
+import { Database } from '../database';
+export declare const registerBuiltInListeners: (db: Database) => void;

package/lib/listeners/index.js

@@ -0,0 +1,33 @@
+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 listeners_exports = {};
+__export(listeners_exports, {
+  registerBuiltInListeners: () => registerBuiltInListeners
+});
+module.exports = __toCommonJS(listeners_exports);
+var import_adjacency_list = require("./adjacency-list");
+var import_append_child_collection_name_after_repository_find = require("./append-child-collection-name-after-repository-find");
+const registerBuiltInListeners = /* @__PURE__ */ __name((db) => {
+  db.on("beforeDefineCollection", import_adjacency_list.beforeDefineAdjacencyListCollection);
+  db.on("afterRepositoryFind", (0, import_append_child_collection_name_after_repository_find.appendChildCollectionNameAfterRepositoryFind)(db));
+}, "registerBuiltInListeners");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerBuiltInListeners
+});

package/lib/magic-attribute-model.d.ts

@@ -0,0 +1,8 @@
+import { Model } from './model';
+export declare class MagicAttributeModel extends Model {
+    get magicAttribute(): string;
+    set(key: any, value?: any, options?: any): this;
+    setV1(key?: any, value?: any, options?: any): this;
+    get(key?: any, value?: any): any;
+    update(values?: any, options?: any): Promise<this>;
+}