@tachybase/database 0.23.8

package/lib/collection.js

@@ -0,0 +1,686 @@
+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 __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __decoratorStart = (base) => [, , , __create((base == null ? void 0 : base[__knownSymbol("metadata")]) ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var collection_exports = {};
+__export(collection_exports, {
+  Collection: () => Collection
+});
+module.exports = __toCommonJS(collection_exports);
+var import_events = require("events");
+var import_deepmerge = __toESM(require("deepmerge"));
+var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
+var import_model = require("./model");
+var import_adjacency_list_repository = require("./repositories/tree-repository/adjacency-list-repository");
+var import_repository = require("./repository");
+var import_utils = require("./utils");
+var _setField_dec, _a, _init;
+function EnsureAtomicity(originalMethod, context) {
+  const newMethod = /* @__PURE__ */ __name(function(...args) {
+    const model = this.model;
+    const beforeAssociationKeys = Object.keys(model.associations);
+    const beforeRawAttributes = Object.keys(model.rawAttributes);
+    try {
+      return originalMethod.apply(this, args);
+    } catch (error) {
+      const afterAssociationKeys = Object.keys(model.associations);
+      const createdAssociationKeys = import_lodash.default.difference(afterAssociationKeys, beforeAssociationKeys);
+      for (const key of createdAssociationKeys) {
+        delete this.model.associations[key];
+      }
+      const afterRawAttributes = Object.keys(model.rawAttributes);
+      const createdRawAttributes = import_lodash.default.difference(afterRawAttributes, beforeRawAttributes);
+      for (const key of createdRawAttributes) {
+        delete this.model.rawAttributes[key];
+      }
+      throw error;
+    }
+  }, "newMethod");
+  return newMethod;
+}
+__name(EnsureAtomicity, "EnsureAtomicity");
+const _Collection = class _Collection extends (_a = import_events.EventEmitter, _setField_dec = [EnsureAtomicity], _a) {
+  constructor(options, context) {
+    super();
+    __runInitializers(_init, 5, this);
+    __publicField(this, "options");
+    __publicField(this, "context");
+    __publicField(this, "isThrough");
+    __publicField(this, "fields", /* @__PURE__ */ new Map());
+    __publicField(this, "model");
+    __publicField(this, "repository");
+    this.context = context;
+    this.options = options;
+    this.checkOptions(options);
+    this.bindFieldEventListener();
+    this.modelInit();
+    this.db.modelCollection.set(this.model, this);
+    this.db.tableNameCollectionMap.set(this.getTableNameWithSchemaAsString(), this);
+    if (!options.inherits) {
+      this.setFields(options.fields);
+    }
+    this.setRepository(options.repository);
+    this.setSortable(options.sortable);
+  }
+  get filterTargetKey() {
+    var _a2;
+    const targetKey = (_a2 = this.options) == null ? void 0 : _a2.filterTargetKey;
+    if (targetKey && this.model.getAttributes()[targetKey]) {
+      return targetKey;
+    }
+    if (this.model.primaryKeyAttributes.length > 1) {
+      return null;
+    }
+    return this.model.primaryKeyAttribute;
+  }
+  get name() {
+    return this.options.name;
+  }
+  get origin() {
+    return this.options.origin || "core";
+  }
+  get titleField() {
+    return this.options.titleField || this.model.primaryKeyAttribute;
+  }
+  get db() {
+    return this.context.database;
+  }
+  get treeParentField() {
+    for (const [_2, field] of this.fields) {
+      if (field.options.treeParent) {
+        return field;
+      }
+    }
+  }
+  get treeChildrenField() {
+    for (const [_2, field] of this.fields) {
+      if (field.options.treeChildren) {
+        return field;
+      }
+    }
+  }
+  tableName() {
+    const { name, tableName } = this.options;
+    const tName = tableName || name;
+    return this.options.underscored ? (0, import_utils.snakeCase)(tName) : tName;
+  }
+  /**
+   * TODO
+   */
+  modelInit() {
+    if (this.model) {
+      return;
+    }
+    const { name, model, autoGenId = true } = this.options;
+    let M = import_model.Model;
+    if (this.context.database.sequelize.isDefined(name)) {
+      const m = this.context.database.sequelize.model(name);
+      if (m.isThrough) {
+        this.model = m;
+        this.model.database = this.context.database;
+        this.model.collection = this;
+        return;
+      }
+    }
+    if (typeof model === "string") {
+      M = this.context.database.models.get(model) || import_model.Model;
+    } else if (model) {
+      M = model;
+    }
+    this.model = class extends M {
+    };
+    this.model.init(null, this.sequelizeModelOptions());
+    if (!autoGenId) {
+      this.model.removeAttribute("id");
+    }
+    this.model.database = this.context.database;
+    this.model.collection = this;
+  }
+  setRepository(repository) {
+    let repo = import_repository.Repository;
+    if (typeof repository === "string") {
+      repo = this.context.database.repositories.get(repository) || import_repository.Repository;
+    }
+    if (this.options.tree == "adjacency-list" || this.options.tree == "adjacencyList") {
+      repo = import_adjacency_list_repository.AdjacencyListRepository;
+    }
+    this.repository = new repo(this);
+  }
+  forEachField(callback) {
+    return [...this.fields.values()].forEach(callback);
+  }
+  findField(callback) {
+    return [...this.fields.values()].find(callback);
+  }
+  hasField(name) {
+    return this.fields.has(name);
+  }
+  getField(name) {
+    return this.fields.get(name);
+  }
+  getFields() {
+    return [...this.fields.values()];
+  }
+  addField(name, options) {
+    return this.setField(name, options);
+  }
+  checkFieldType(name, options) {
+    if (!this.options.underscored) {
+      return;
+    }
+    const fieldName = options.field || (0, import_utils.snakeCase)(name);
+    const field = this.findField((f) => {
+      if (f.name === name) {
+        return false;
+      }
+      if (f.field) {
+        return f.field === fieldName;
+      }
+      return (0, import_utils.snakeCase)(f.name) === fieldName;
+    });
+    if (!field) {
+      return;
+    }
+    if (options.type !== field.type) {
+      throw new Error(`fields with same column must be of the same type ${JSON.stringify(options)}`);
+    }
+  }
+  correctOptions(options) {
+    if (options.primaryKey && options.autoIncrement) {
+      delete options.defaultValue;
+    }
+  }
+  setField(name, options) {
+    (0, import_utils.checkIdentifier)(name);
+    this.checkFieldType(name, options);
+    const { database } = this.context;
+    if (options.source) {
+      const [sourceCollectionName, sourceFieldName] = options.source.split(".");
+      const sourceCollection = this.db.collections.get(sourceCollectionName);
+      if (!sourceCollection) {
+        this.db.logger.warn(
+          `source collection "${sourceCollectionName}" not found for field "${name}" at collection "${this.name}"`
+        );
+      } else {
+        const sourceField = sourceCollection.fields.get(sourceFieldName);
+        if (!sourceField) {
+          this.db.logger.warn(
+            `source field "${sourceFieldName}" not found for field "${name}" at collection "${this.name}"`
+          );
+        } else {
+          options = { ...import_lodash.default.omit(sourceField.options, ["name", "primaryKey"]), ...options };
+        }
+      }
+    }
+    this.correctOptions(options);
+    this.emit("field.beforeAdd", name, options, { collection: this });
+    const field = database.buildField(
+      { name, ...options },
+      {
+        ...this.context,
+        collection: this
+      }
+    );
+    const oldField = this.fields.get(name);
+    if (oldField && oldField.options.inherit && field.typeToString() != oldField.typeToString()) {
+      throw new Error(
+        `Field type conflict: cannot set "${name}" on "${this.name}" to ${options.type}, parent "${name}" type is ${oldField.options.type}`
+      );
+    }
+    if (this.options.autoGenId !== false && options.primaryKey) {
+      this.model.removeAttribute("id");
+    }
+    this.removeField(name);
+    this.fields.set(name, field);
+    this.emit("field.afterAdd", field);
+    this.db.emit("field.afterAdd", {
+      collection: this,
+      field
+    });
+    if (this.isParent()) {
+      for (const child of this.context.database.inheritanceMap.getChildren(this.name, {
+        deep: false
+      })) {
+        const childCollection = this.db.getCollection(child);
+        const existField = childCollection.getField(name);
+        if (!existField || existField.options.inherit) {
+          childCollection.setField(name, {
+            ...options,
+            inherit: true
+          });
+        }
+      }
+    }
+    return field;
+  }
+  setFields(fields, resetFields = true) {
+    if (!Array.isArray(fields)) {
+      return;
+    }
+    if (resetFields) {
+      this.resetFields();
+    }
+    for (const { name, ...options } of fields) {
+      this.addField(name, options);
+    }
+  }
+  resetFields() {
+    const fieldNames = this.fields.keys();
+    for (const fieldName of fieldNames) {
+      this.removeField(fieldName);
+    }
+  }
+  remove() {
+    return this.context.database.removeCollection(this.name);
+  }
+  async removeFieldFromDb(name, options) {
+    const field = this.getField(name);
+    if (!field) {
+      return;
+    }
+    const attribute = this.model.rawAttributes[name];
+    if (!attribute) {
+      field.remove();
+      return;
+    }
+    if (this.isInherited() && this.parentFields().has(name)) {
+      return;
+    }
+    if (this.model._virtualAttributes.has(this.name)) {
+      field.remove();
+      return;
+    }
+    if (this.model.options.timestamps !== false) {
+      let timestampsFields = ["createdAt", "updatedAt", "deletedAt"];
+      if (this.db.options.underscored) {
+        timestampsFields = timestampsFields.map((fieldName) => (0, import_utils.snakeCase)(fieldName));
+      }
+      if (timestampsFields.includes(field.columnName())) {
+        this.fields.delete(name);
+        return;
+      }
+    }
+    const sortable = this.options.sortable;
+    if (sortable) {
+      let sortField;
+      if (sortable === true) {
+        sortField = "sort";
+      } else if (typeof sortable === "string") {
+        sortField = sortable;
+      } else if (sortable.name) {
+        sortField = sortable.name || "sort";
+      }
+      if (field.name === sortField) {
+        return;
+      }
+    }
+    if (this.isView()) {
+      field.remove();
+      return;
+    }
+    const columnReferencesCount = import_lodash.default.filter(this.model.rawAttributes, (attr) => attr.field == field.columnName()).length;
+    if (await field.existsInDb({
+      transaction: options == null ? void 0 : options.transaction
+    }) && columnReferencesCount == 1) {
+      const columns = await this.model.sequelize.getQueryInterface().describeTable(this.getTableNameWithSchema(), options);
+      if (Object.keys(columns).length == 1) {
+        await this.removeFromDb({
+          ...options,
+          cascade: true,
+          dropCollection: false
+        });
+      } else {
+        const queryInterface = this.db.sequelize.getQueryInterface();
+        await queryInterface.removeColumn(this.getTableNameWithSchema(), field.columnName(), options);
+      }
+    }
+    field.remove();
+  }
+  async removeFromDb(options) {
+    if (!this.isView() && await this.existsInDb({
+      transaction: options == null ? void 0 : options.transaction
+    })) {
+      const queryInterface = this.db.sequelize.getQueryInterface();
+      await queryInterface.dropTable(this.getTableNameWithSchema(), options);
+    }
+    if ((options == null ? void 0 : options.dropCollection) !== false) {
+      return this.remove();
+    }
+  }
+  async existsInDb(options) {
+    return this.db.queryInterface.collectionTableExists(this, options);
+  }
+  removeField(name) {
+    if (!this.fields.has(name)) {
+      return;
+    }
+    const field = this.fields.get(name);
+    const bool = this.fields.delete(name);
+    if (bool) {
+      if (this.isParent()) {
+        for (const child of this.db.inheritanceMap.getChildren(this.name, {
+          deep: false
+        })) {
+          const childCollection = this.db.getCollection(child);
+          const existField = childCollection.getField(name);
+          if (existField && existField.options.inherit) {
+            childCollection.removeField(name);
+          }
+        }
+      }
+      this.emit("field.afterRemove", field);
+    }
+    return field;
+  }
+  /**
+   * TODO
+   */
+  updateOptions(options, mergeOptions) {
+    let newOptions = import_lodash.default.cloneDeep(options);
+    newOptions = (0, import_deepmerge.default)(this.options, newOptions, mergeOptions);
+    this.context.database.emit("beforeUpdateCollection", this, newOptions);
+    this.options = newOptions;
+    this.setFields(options.fields, false);
+    if (options.repository) {
+      this.setRepository(options.repository);
+    }
+    this.context.database.emit("afterUpdateCollection", this);
+    return this;
+  }
+  setSortable(sortable) {
+    if (!sortable) {
+      return;
+    }
+    if (sortable === true) {
+      this.setField("sort", {
+        type: "sort",
+        hidden: true
+      });
+    }
+    if (typeof sortable === "string") {
+      this.setField(sortable, {
+        type: "sort",
+        hidden: true
+      });
+    } else if (typeof sortable === "object") {
+      const { name, ...opts } = sortable;
+      this.setField(name || "sort", { type: "sort", hidden: true, ...opts });
+    }
+  }
+  /**
+   * TODO
+   *
+   * @param name
+   * @param options
+   */
+  updateField(name, options) {
+    if (!this.hasField(name)) {
+      throw new Error(`field ${name} not exists`);
+    }
+    if (options.name && options.name !== name) {
+      this.removeField(name);
+    }
+    this.setField(options.name || name, options);
+  }
+  addIndex(index) {
+    if (!index) {
+      return;
+    }
+    const indexes = this.model.options.indexes || [];
+    let indexName = [];
+    let indexItem;
+    if (typeof index === "string") {
+      indexItem = {
+        fields: [index]
+      };
+      indexName = [index];
+    } else if (Array.isArray(index)) {
+      indexItem = {
+        fields: index
+      };
+      indexName = index;
+    } else if (index == null ? void 0 : index.fields) {
+      indexItem = index;
+      indexName = index.fields;
+    }
+    if (import_lodash.default.isEqual(this.model.primaryKeyAttributes, indexName)) {
+      return;
+    }
+    const name = this.model.primaryKeyAttributes.join(",");
+    if (name.startsWith(`${indexName.join(",")},`)) {
+      return;
+    }
+    for (const item of indexes) {
+      if (import_lodash.default.isEqual(item.fields, indexName)) {
+        return;
+      }
+      const name2 = item.fields.join(",");
+      if (name2.startsWith(`${indexName.join(",")},`)) {
+        return;
+      }
+    }
+    if (!indexItem) {
+      return;
+    }
+    indexes.push(indexItem);
+    const tableName = this.model.getTableName();
+    this.model._indexes = this.model.options.indexes.map((index2) => import_sequelize.Utils.nameIndex(this.model._conformIndex(index2), tableName)).map((item) => {
+      if (item.name && item.name.length > 63) {
+        item.name = "i_" + (0, import_utils.md5)(item.name);
+      }
+      return item;
+    });
+    this.refreshIndexes();
+  }
+  removeIndex(fields) {
+    if (!fields) {
+      return;
+    }
+    const indexes = this.model._indexes;
+    this.model._indexes = indexes.filter((item) => {
+      return !import_lodash.default.isEqual(item.fields, fields);
+    });
+    this.refreshIndexes();
+  }
+  refreshIndexes() {
+    const indexes = this.model._indexes;
+    this.model._indexes = import_lodash.default.uniqBy(
+      indexes.filter((item) => {
+        return item.fields.every(
+          (field) => Object.values(this.model.rawAttributes).find((fieldVal) => fieldVal.field === field)
+        );
+      }).map((item) => {
+        if (this.options.underscored) {
+          item.fields = item.fields.map((field) => (0, import_utils.snakeCase)(field));
+        }
+        return item;
+      }),
+      "name"
+    );
+  }
+  async sync(syncOptions) {
+    const modelNames = /* @__PURE__ */ new Set([this.model.name]);
+    const { associations } = this.model;
+    for (const associationKey in associations) {
+      const association = associations[associationKey];
+      modelNames.add(association.target.name);
+      if (association.through) {
+        modelNames.add(association.through.model.name);
+      }
+    }
+    const models = [];
+    this.context.database.sequelize.modelManager.forEachModel((model) => {
+      if (modelNames.has(model.name)) {
+        models.push(model);
+      }
+    });
+    for (const model of models) {
+      await model.sync(
+        syncOptions || {
+          force: false,
+          alter: {
+            drop: false
+          }
+        }
+      );
+    }
+  }
+  isInherited() {
+    return false;
+  }
+  isParent() {
+    return this.context.database.inheritanceMap.isParentNode(this.name);
+  }
+  getTableNameWithSchema() {
+    const tableName = this.model.tableName;
+    if (this.collectionSchema() && this.db.inDialect("postgres")) {
+      return this.db.utils.addSchema(tableName, this.collectionSchema());
+    }
+    return tableName;
+  }
+  tableNameAsString(options) {
+    const tableNameWithSchema = this.getTableNameWithSchema();
+    if (import_lodash.default.isString(tableNameWithSchema)) {
+      return tableNameWithSchema;
+    }
+    const schema = tableNameWithSchema.schema;
+    const tableName = tableNameWithSchema.tableName;
+    if ((options == null ? void 0 : options.ignorePublicSchema) && schema === "public") {
+      return tableName;
+    }
+    return `${schema}.${tableName}`;
+  }
+  getTableNameWithSchemaAsString() {
+    const tableName = this.model.tableName;
+    if (this.collectionSchema() && this.db.inDialect("postgres")) {
+      return `${this.collectionSchema()}.${tableName}`;
+    }
+    return tableName;
+  }
+  quotedTableName() {
+    return this.db.utils.quoteTable(this.getTableNameWithSchema());
+  }
+  collectionSchema() {
+    if (this.options.schema) {
+      return this.options.schema;
+    }
+    if (this.db.options.schema) {
+      return this.db.options.schema;
+    }
+    if (this.db.inDialect("postgres")) {
+      return "public";
+    }
+    return void 0;
+  }
+  isView() {
+    return false;
+  }
+  sequelizeModelOptions() {
+    const { name } = this.options;
+    return {
+      ...import_lodash.default.omit(this.options, ["name", "fields", "model", "targetKey"]),
+      modelName: name,
+      sequelize: this.context.database.sequelize,
+      tableName: this.tableName()
+    };
+  }
+  bindFieldEventListener() {
+    this.on("field.afterAdd", (field) => {
+      field.bind();
+    });
+    this.on("field.afterRemove", (field) => {
+      field.unbind();
+      this.db.emit("field.afterRemove", field);
+    });
+  }
+  checkOptions(options) {
+    (0, import_utils.checkIdentifier)(options.name);
+    this.checkTableName();
+  }
+  checkTableName() {
+    const tableName = this.tableName();
+    for (const [k, collection] of this.db.collections) {
+      if (collection.name != this.options.name && tableName === collection.tableName() && collection.collectionSchema() === this.collectionSchema()) {
+        throw new Error(`collection ${collection.name} and ${this.name} have same tableName "${tableName}"`);
+      }
+    }
+  }
+};
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "setField", _setField_dec, _Collection);
+__decoratorMetadata(_init, _Collection);
+__name(_Collection, "Collection");
+let Collection = _Collection;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Collection
+});

package/lib/database-utils/index.d.ts

@@ -0,0 +1,9 @@
+import Database from '../database';
+export default class DatabaseUtils {
+    db: Database;
+    constructor(db: Database);
+    addSchema(tableName: any, schema?: any): any;
+    quoteTable(tableName: any): any;
+    schema(): string;
+}
+export * from './traverseJSON';