@tachybase/database 0.23.8

package/lib/repository.js

@@ -0,0 +1,597 @@
+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 repository_exports = {};
+__export(repository_exports, {
+  Repository: () => Repository
+});
+module.exports = __toCommonJS(repository_exports);
+var import_flat = require("flat");
+var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
+var import_must_have_filter_decorator = __toESM(require("./decorators/must-have-filter-decorator"));
+var import_target_collection_decorator = __toESM(require("./decorators/target-collection-decorator"));
+var import_transaction_decorator = require("./decorators/transaction-decorator");
+var import_eager_loading_tree = require("./eager-loading/eager-loading-tree");
+var import_array_field_repository = require("./field-repository/array-field-repository");
+var import_fields = require("./fields");
+var import_filter_parser = __toESM(require("./filter-parser"));
+var import_options_parser = require("./options-parser");
+var import_belongs_to_many_repository = require("./relation-repository/belongs-to-many-repository");
+var import_belongs_to_repository = require("./relation-repository/belongs-to-repository");
+var import_hasmany_repository = require("./relation-repository/hasmany-repository");
+var import_hasone_repository = require("./relation-repository/hasone-repository");
+var import_update_associations = require("./update-associations");
+var import_update_guard = require("./update-guard");
+var _destroy_dec, _updateMany_dec, _update_dec, _createMany_dec, _create_dec, _init;
+const debug = require("debug")("noco-database");
+const transaction = (0, import_transaction_decorator.transactionWrapperBuilder)(function() {
+  return this.collection.model.sequelize.transaction();
+});
+const _RelationRepositoryBuilder = class _RelationRepositoryBuilder {
+  collection;
+  associationName;
+  association;
+  builderMap = {
+    HasOne: import_hasone_repository.HasOneRepository,
+    BelongsTo: import_belongs_to_repository.BelongsToRepository,
+    BelongsToMany: import_belongs_to_many_repository.BelongsToManyRepository,
+    HasMany: import_hasmany_repository.HasManyRepository,
+    ArrayField: import_array_field_repository.ArrayFieldRepository
+  };
+  constructor(collection, associationName) {
+    this.collection = collection;
+    this.associationName = associationName;
+    this.association = this.collection.model.associations[this.associationName];
+    if (!this.association) {
+      const field = collection.getField(associationName);
+      if (field && field instanceof import_fields.ArrayField) {
+        this.association = {
+          associationType: "ArrayField"
+        };
+      }
+    }
+  }
+  of(id) {
+    if (!this.association) {
+      return;
+    }
+    const klass = this.builder()[this.association.associationType];
+    return new klass(this.collection, this.associationName, id);
+  }
+  builder() {
+    return this.builderMap;
+  }
+};
+__name(_RelationRepositoryBuilder, "RelationRepositoryBuilder");
+let RelationRepositoryBuilder = _RelationRepositoryBuilder;
+_create_dec = [transaction()], _createMany_dec = [transaction()], _update_dec = [transaction(), (0, import_must_have_filter_decorator.default)(), import_target_collection_decorator.default], _updateMany_dec = [transaction()], _destroy_dec = [transaction((args, transaction2) => {
+  return {
+    filterByTk: args[0],
+    transaction: transaction2
+  };
+})];
+const _Repository = class _Repository {
+  constructor(collection) {
+    __runInitializers(_init, 5, this);
+    __publicField(this, "database");
+    __publicField(this, "collection");
+    __publicField(this, "model");
+    this.database = collection.context.database;
+    this.collection = collection;
+    this.model = collection.model;
+  }
+  static valuesToFilter(values, filterKeys) {
+    const filterAnd = [];
+    const flattedValues = (0, import_flat.flatten)(values);
+    const keyWithOutArrayIndex = /* @__PURE__ */ __name((key) => {
+      const chunks = key.split(".");
+      return chunks.filter((chunk) => {
+        return !chunk.match(/\d+/);
+      }).join(".");
+    }, "keyWithOutArrayIndex");
+    for (const filterKey of filterKeys) {
+      let filterValue;
+      for (const flattedKey of Object.keys(flattedValues)) {
+        const flattedKeyWithoutIndex = keyWithOutArrayIndex(flattedKey);
+        if (flattedKeyWithoutIndex === filterKey) {
+          if (filterValue) {
+            if (Array.isArray(filterValue)) {
+              filterValue.push(flattedValues[flattedKey]);
+            } else {
+              filterValue = [filterValue, flattedValues[flattedKey]];
+            }
+          } else {
+            filterValue = flattedValues[flattedKey];
+          }
+        }
+      }
+      if (filterValue) {
+        filterAnd.push({
+          [filterKey]: filterValue
+        });
+      }
+    }
+    return {
+      $and: filterAnd
+    };
+  }
+  /**
+   * return count by filter
+   */
+  async count(countOptions) {
+    var _a;
+    let options = countOptions ? import_lodash.default.clone(countOptions) : {};
+    const transaction2 = await this.getTransaction(options);
+    if (countOptions == null ? void 0 : countOptions.filter) {
+      options = {
+        ...options,
+        ...this.parseFilter(countOptions.filter, countOptions)
+      };
+    }
+    if (countOptions == null ? void 0 : countOptions.filterByTk) {
+      options["where"] = {
+        [import_sequelize.Op.and]: [
+          options["where"] || {},
+          {
+            [this.collection.filterTargetKey]: options.filterByTk
+          }
+        ]
+      };
+    }
+    const queryOptions = {
+      ...options,
+      distinct: Boolean(this.collection.model.primaryKeyAttribute)
+    };
+    if (((_a = queryOptions.include) == null ? void 0 : _a.length) === 0) {
+      delete queryOptions.include;
+    }
+    const count = await this.collection.model.count({
+      ...queryOptions,
+      transaction: transaction2
+    });
+    return count;
+  }
+  async aggregate(options) {
+    var _a;
+    const { method, field } = options;
+    const queryOptions = this.buildQueryOptions({
+      ...options,
+      fields: []
+    });
+    (_a = options.optionsTransformer) == null ? void 0 : _a.call(options, queryOptions);
+    const hasAssociationFilter = /* @__PURE__ */ __name(() => {
+      if (queryOptions.include && queryOptions.include.length > 0) {
+        const filterInclude = queryOptions.include.filter((include) => {
+          var _a2;
+          return Object.keys(include.where || {}).length > 0 || ((_a2 = JSON.stringify(queryOptions == null ? void 0 : queryOptions.filter)) == null ? void 0 : _a2.includes(include.association));
+        });
+        return filterInclude.length > 0;
+      }
+      return false;
+    }, "hasAssociationFilter");
+    if (hasAssociationFilter()) {
+      const primaryKeyField = this.model.primaryKeyAttribute;
+      const queryInterface = this.database.sequelize.getQueryInterface();
+      const findOptions = {
+        ...queryOptions,
+        raw: true,
+        includeIgnoreAttributes: false,
+        attributes: [
+          [
+            import_sequelize.Sequelize.literal(
+              `DISTINCT ${queryInterface.quoteIdentifiers(`${this.collection.name}.${primaryKeyField}`)}`
+            ),
+            primaryKeyField
+          ]
+        ]
+      };
+      const ids = await this.model.findAll(findOptions);
+      return await this.model.aggregate(field, method, {
+        ...import_lodash.default.omit(queryOptions, ["where", "include"]),
+        where: {
+          [primaryKeyField]: ids.map((node) => node[primaryKeyField])
+        }
+      });
+    }
+    return await this.model.aggregate(field, method, queryOptions);
+  }
+  /**
+   * find
+   * @param options
+   */
+  async find(options = {}) {
+    if ((options == null ? void 0 : options.targetCollection) && (options == null ? void 0 : options.targetCollection) !== this.collection.name) {
+      return await this.database.getCollection(options.targetCollection).repository.find(options);
+    }
+    const model = this.collection.model;
+    const transaction2 = await this.getTransaction(options);
+    const opts = {
+      subQuery: false,
+      ...this.buildQueryOptions(options)
+    };
+    let rows;
+    if (opts.include && opts.include.length > 0) {
+      const eagerLoadingTree = import_eager_loading_tree.EagerLoadingTree.buildFromSequelizeOptions({
+        model,
+        rootAttributes: opts.attributes,
+        includeOption: opts.include,
+        rootOrder: opts.order,
+        rootQueryOptions: opts,
+        db: this.database
+      });
+      await eagerLoadingTree.load(transaction2);
+      rows = eagerLoadingTree.root.instances;
+    } else {
+      rows = await model.findAll({
+        ...opts,
+        transaction: transaction2
+      });
+    }
+    await this.collection.db.emitAsync("afterRepositoryFind", {
+      findOptions: options,
+      dataCollection: this.collection,
+      data: rows
+    });
+    return rows;
+  }
+  /**
+   * find and count
+   * @param options
+   */
+  async findAndCount(options) {
+    options = {
+      ...options,
+      transaction: await this.getTransaction(options)
+    };
+    const count = await this.count(options);
+    const results = count ? await this.find(options) : [];
+    return [results, count];
+  }
+  /**
+   * Find By Id
+   *
+   */
+  findById(id) {
+    return this.collection.model.findByPk(id);
+  }
+  /**
+   * Find one record from database
+   *
+   * @param options
+   */
+  async findOne(options) {
+    const transaction2 = await this.getTransaction(options);
+    const rows = await this.find({ ...options, limit: 1, transaction: transaction2 });
+    return rows.length === 1 ? rows[0] : null;
+  }
+  /**
+   * Get the first record matching the attributes or create it.
+   */
+  async firstOrCreate(options) {
+    const { filterKeys, values, transaction: transaction2, hooks } = options;
+    const filter = _Repository.valuesToFilter(values, filterKeys);
+    const instance = await this.findOne({ filter, transaction: transaction2 });
+    if (instance) {
+      return instance;
+    }
+    return this.create({ values, transaction: transaction2, hooks });
+  }
+  async updateOrCreate(options) {
+    const { filterKeys, values, transaction: transaction2, hooks } = options;
+    const filter = _Repository.valuesToFilter(values, filterKeys);
+    const instance = await this.findOne({ filter, transaction: transaction2 });
+    if (instance) {
+      return await this.update({
+        filterByTk: instance.get(this.collection.filterTargetKey || this.collection.model.primaryKeyAttribute),
+        values,
+        transaction: transaction2,
+        hooks
+      });
+    }
+    return this.create({ values, transaction: transaction2, hooks });
+  }
+  async create(options) {
+    if (Array.isArray(options.values)) {
+      return this.createMany({
+        ...options,
+        records: options.values
+      });
+    }
+    const transaction2 = await this.getTransaction(options);
+    const guard = import_update_guard.UpdateGuard.fromOptions(this.model, {
+      ...options,
+      action: "create",
+      underscored: this.collection.options.underscored
+    });
+    const values = guard.sanitize(options.values || {});
+    const instance = await this.model.create(values, {
+      ...options,
+      transaction: transaction2
+    });
+    if (!instance) {
+      return;
+    }
+    await (0, import_update_associations.updateAssociations)(instance, values, {
+      ...options,
+      transaction: transaction2
+    });
+    if (options.hooks !== false) {
+      await this.database.emitAsync(`${this.collection.name}.afterCreateWithAssociations`, instance, {
+        ...options,
+        transaction: transaction2
+      });
+      await this.database.emitAsync(`${this.collection.name}.afterSaveWithAssociations`, instance, {
+        ...options,
+        transaction: transaction2
+      });
+      instance.clearChangedWithAssociations();
+    }
+    return instance;
+  }
+  async createMany(options) {
+    const transaction2 = await this.getTransaction(options);
+    const { records } = options;
+    const instances = [];
+    for (const values of records) {
+      const instance = await this.create({ ...options, values, transaction: transaction2 });
+      instances.push(instance);
+    }
+    return instances;
+  }
+  async update(options) {
+    if (Array.isArray(options.values)) {
+      return this.updateMany({
+        ...options,
+        records: options.values
+      });
+    }
+    const transaction2 = await this.getTransaction(options);
+    const guard = import_update_guard.UpdateGuard.fromOptions(this.model, { ...options, underscored: this.collection.options.underscored });
+    const values = guard.sanitize(options.values);
+    if (options.individualHooks === false) {
+      const { model: Model2 } = this.collection;
+      const primaryKeyField = Model2.primaryKeyField || Model2.primaryKeyAttribute;
+      const queryOptions2 = this.buildQueryOptions({
+        ...options,
+        fields: [primaryKeyField]
+      });
+      const rows = await this.find({
+        ...queryOptions2,
+        transaction: transaction2
+      });
+      const [result] = await Model2.update(values, {
+        where: {
+          [primaryKeyField]: rows.map((row) => row.get(primaryKeyField))
+        },
+        fields: options.fields,
+        hooks: options.hooks,
+        validate: options.validate,
+        sideEffects: options.sideEffects,
+        limit: options.limit,
+        silent: options.silent,
+        transaction: transaction2
+      });
+      return result;
+    }
+    const queryOptions = this.buildQueryOptions(options);
+    const instances = await this.find({
+      ...queryOptions,
+      transaction: transaction2
+    });
+    for (const instance of instances) {
+      await (0, import_update_associations.updateModelByValues)(instance, values, {
+        ...options,
+        sanitized: true,
+        transaction: transaction2
+      });
+    }
+    if (options.hooks !== false) {
+      for (const instance of instances) {
+        await this.database.emitAsync(`${this.collection.name}.afterUpdateWithAssociations`, instance, {
+          ...options,
+          transaction: transaction2
+        });
+        await this.database.emitAsync(`${this.collection.name}.afterSaveWithAssociations`, instance, {
+          ...options,
+          transaction: transaction2
+        });
+        instance.clearChangedWithAssociations();
+      }
+    }
+    return instances;
+  }
+  async updateMany(options) {
+    const transaction2 = await this.getTransaction(options);
+    const { records } = options;
+    const instances = [];
+    for (const values of records) {
+      const filterByTk = values[this.model.primaryKeyAttribute];
+      if (!filterByTk) {
+        throw new Error("filterByTk invalid");
+      }
+      const instance = await this.update({ values, filterByTk, transaction: transaction2 });
+      instances.push(instance);
+    }
+    return instances;
+  }
+  async destroy(options) {
+    const transaction2 = await this.getTransaction(options);
+    const modelFilterKey = this.collection.filterTargetKey;
+    options = options;
+    if (options["individualHooks"] === void 0) {
+      options["individualHooks"] = true;
+    }
+    const filterByTk = options.filterByTk && !import_lodash.default.isArray(options.filterByTk) ? [options.filterByTk] : options.filterByTk;
+    if (this.collection.model.primaryKeyAttributes.length !== 1 && filterByTk && !import_lodash.default.get(this.collection.options, "filterTargetKey")) {
+      if (this.collection.model.primaryKeyAttributes.length > 1) {
+        throw new Error(`filterByTk is not supported for composite primary key`);
+      } else {
+        throw new Error(`filterByTk is not supported for collection that has no primary key`);
+      }
+    }
+    if (filterByTk && !options.filter) {
+      return await this.model.destroy({
+        ...options,
+        where: {
+          [modelFilterKey]: {
+            [import_sequelize.Op.in]: filterByTk
+          }
+        },
+        transaction: transaction2
+      });
+    }
+    if (options.filter) {
+      if (this.collection.model.primaryKeyAttributes.length !== 1 && !import_lodash.default.get(this.collection.options, "filterTargetKey")) {
+        const queryOptions = {
+          ...this.buildQueryOptions(options)
+        };
+        return await this.model.destroy({
+          ...queryOptions,
+          transaction: transaction2
+        });
+      }
+      let pks = (await this.find({
+        filter: options.filter,
+        transaction: transaction2
+      })).map((instance) => instance.get(modelFilterKey));
+      if (filterByTk) {
+        pks = import_lodash.default.intersection(
+          pks.map((i) => `${i}`),
+          filterByTk.map((i) => `${i}`)
+        );
+      }
+      return await this.destroy({
+        ...import_lodash.default.omit(options, "filter"),
+        filterByTk: pks,
+        transaction: transaction2
+      });
+    }
+    if (options.truncate) {
+      return await this.model.destroy({
+        ...options,
+        truncate: true,
+        transaction: transaction2
+      });
+    }
+  }
+  /**
+   * @param association target association
+   */
+  relation(association) {
+    return new RelationRepositoryBuilder(this.collection, association);
+  }
+  buildQueryOptions(options) {
+    const parser = new import_options_parser.OptionsParser(options, {
+      collection: this.collection
+    });
+    const params = parser.toSequelizeParams();
+    debug("sequelize query params %o", params);
+    if (options.where && params.where) {
+      params.where = {
+        [import_sequelize.Op.and]: [params.where, options.where]
+      };
+    }
+    return { where: {}, ...options, ...params };
+  }
+  parseFilter(filter, options) {
+    const parser = new import_filter_parser.default(filter, {
+      collection: this.collection,
+      app: {
+        ctx: options == null ? void 0 : options.context
+      }
+    });
+    return parser.toSequelizeParams();
+  }
+  async getTransaction(options, autoGen = false) {
+    if (import_lodash.default.isPlainObject(options) && options.transaction) {
+      return options.transaction;
+    }
+    if (autoGen) {
+      return await this.model.sequelize.transaction();
+    }
+    return null;
+  }
+};
+_init = __decoratorStart(null);
+__decorateElement(_init, 1, "create", _create_dec, _Repository);
+__decorateElement(_init, 1, "createMany", _createMany_dec, _Repository);
+__decorateElement(_init, 1, "update", _update_dec, _Repository);
+__decorateElement(_init, 1, "updateMany", _updateMany_dec, _Repository);
+__decorateElement(_init, 1, "destroy", _destroy_dec, _Repository);
+__decoratorMetadata(_init, _Repository);
+__name(_Repository, "Repository");
+let Repository = _Repository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Repository
+});

package/lib/sql-collection/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sql-model';
+export * from './sql-collection';

package/lib/sql-collection/index.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sql_collection_exports = {};
+module.exports = __toCommonJS(sql_collection_exports);
+__reExport(sql_collection_exports, require("./sql-model"), module.exports);
+__reExport(sql_collection_exports, require("./sql-collection"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./sql-model"),
+  ...require("./sql-collection")
+});

package/lib/sql-collection/query-generator.d.ts

@@ -0,0 +1,10 @@
+import { GroupOption, Order, ProjectionAlias, WhereOptions } from 'sequelize';
+import { SQLModel } from './sql-model';
+export declare function selectQuery(tableName: string, options: {
+    attributes?: (string | ProjectionAlias)[];
+    where?: WhereOptions;
+    order?: Order;
+    group?: GroupOption;
+    limit?: number;
+    offset?: number;
+}, model: SQLModel): string;