@tachybase/database 0.23.8

package/lib/relation-repository/belongs-to-many-repository.js

@@ -0,0 +1,280 @@
+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 __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 belongs_to_many_repository_exports = {};
+__export(belongs_to_many_repository_exports, {
+  BelongsToManyRepository: () => BelongsToManyRepository
+});
+module.exports = __toCommonJS(belongs_to_many_repository_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_sequelize = require("sequelize");
+var import_update_associations = require("../update-associations");
+var import_multiple_relation_repository = require("./multiple-relation-repository");
+var import_relation_repository = require("./relation-repository");
+var _toggle_dec, _set_dec, _add_dec, _destroy_dec, _create_dec, _a, _init;
+const _BelongsToManyRepository = class _BelongsToManyRepository extends (_a = import_multiple_relation_repository.MultipleRelationRepository, _create_dec = [(0, import_relation_repository.transaction)()], _destroy_dec = [(0, import_relation_repository.transaction)((args, transaction2) => {
+  return {
+    filterByTk: args[0],
+    transaction: transaction2
+  };
+})], _add_dec = [(0, import_relation_repository.transaction)((args, transaction2) => {
+  return {
+    tk: args[0],
+    transaction: transaction2
+  };
+})], _set_dec = [(0, import_relation_repository.transaction)((args, transaction2) => {
+  return {
+    tk: args[0],
+    transaction: transaction2
+  };
+})], _toggle_dec = [(0, import_relation_repository.transaction)((args, transaction2) => {
+  return {
+    tk: args[0],
+    transaction: transaction2
+  };
+})], _a) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init, 5, this);
+  }
+  async aggregate(options) {
+    const targetRepository = this.targetCollection.repository;
+    const sourceModel = await this.getSourceModel();
+    const association = this.association;
+    return await targetRepository.aggregate({
+      ...options,
+      optionsTransformer: /* @__PURE__ */ __name((modelOptions) => {
+        modelOptions.include = modelOptions.include || [];
+        const throughWhere = {};
+        throughWhere[association.foreignKey] = sourceModel.get(association.sourceKey);
+        modelOptions.include.push({
+          association: association.oneFromTarget,
+          required: true,
+          attributes: [],
+          where: throughWhere
+        });
+      }, "optionsTransformer")
+    });
+  }
+  async create(options) {
+    if (Array.isArray(options.values)) {
+      return Promise.all(options.values.map((record) => this.create({ ...options, values: record })));
+    }
+    const transaction2 = await this.getTransaction(options);
+    const createAccessor = this.accessors().create;
+    const values = options.values || {};
+    const sourceModel = await this.getSourceModel(transaction2);
+    const createOptions = {
+      ...options,
+      through: values[this.throughName()],
+      transaction: transaction2
+    };
+    const instance = await sourceModel[createAccessor](values, createOptions);
+    await (0, import_update_associations.updateAssociations)(instance, values, { ...options, transaction: transaction2 });
+    return instance;
+  }
+  async destroy(options) {
+    const transaction2 = await this.getTransaction(options);
+    const association = this.association;
+    const throughModel = this.throughModel();
+    const instancesToIds = /* @__PURE__ */ __name((instances) => {
+      return instances.map((instance) => instance.get(this.targetKey()));
+    }, "instancesToIds");
+    const throughTableWhere = [
+      {
+        [throughModel.rawAttributes[association.foreignKey].field]: this.sourceKeyValue
+      }
+    ];
+    let ids;
+    if (options && options["filter"]) {
+      const instances = await this.find({
+        filter: options["filter"],
+        transaction: transaction2
+      });
+      ids = instancesToIds(instances);
+    }
+    if (options && options["filterByTk"]) {
+      const instances = this.association.toInstanceArray(options["filterByTk"]);
+      ids = ids ? import_lodash.default.intersection(ids, instancesToIds(instances)) : instancesToIds(instances);
+    }
+    if (options && !options["filterByTk"] && !options["filter"]) {
+      const sourceModel = await this.getSourceModel(transaction2);
+      const instances = await sourceModel[this.accessors().get]({
+        transaction: transaction2
+      });
+      ids = instancesToIds(instances);
+    }
+    throughTableWhere.push({
+      [throughModel.rawAttributes[association.otherKey].field]: {
+        [import_sequelize.Op.in]: ids
+      }
+    });
+    await this.throughModel().destroy({
+      where: throughTableWhere,
+      transaction: transaction2
+    });
+    await this.targetModel.destroy({
+      where: {
+        [this.targetKey()]: {
+          [import_sequelize.Op.in]: ids
+        }
+      },
+      transaction: transaction2
+    });
+    return true;
+  }
+  async add(options) {
+    await this.setTargets("add", options);
+  }
+  async set(options) {
+    await this.setTargets("set", options);
+  }
+  async toggle(options) {
+    const transaction2 = await this.getTransaction(options);
+    const sourceModel = await this.getSourceModel(transaction2);
+    const has = await sourceModel[this.accessors().hasSingle](options["tk"], {
+      transaction: transaction2
+    });
+    if (has) {
+      await this.remove({
+        ...options,
+        transaction: transaction2
+      });
+    } else {
+      await this.add({
+        ...options,
+        transaction: transaction2
+      });
+    }
+    return;
+  }
+  extendFindOptions(findOptions) {
+    let joinTableAttributes;
+    if (import_lodash.default.get(findOptions, "fields")) {
+      joinTableAttributes = [];
+    }
+    return {
+      ...findOptions,
+      joinTableAttributes
+    };
+  }
+  throughName() {
+    return this.throughModel().name;
+  }
+  throughModel() {
+    return this.association.through.model;
+  }
+  async setTargets(call, options) {
+    const handleKeys = this.convertTks(options);
+    const transaction2 = await this.getTransaction(options, false);
+    const sourceModel = await this.getSourceModel(transaction2);
+    const setObj = handleKeys.reduce((carry, item) => {
+      if (Array.isArray(item)) {
+        carry[item[0]] = item[1];
+      } else {
+        carry[item] = true;
+      }
+      return carry;
+    }, {});
+    const targetKeys = Object.keys(setObj);
+    const association = this.association;
+    const targetObjects = await this.targetModel.findAll({
+      where: {
+        [association["targetKey"]]: targetKeys
+      },
+      transaction: transaction2
+    });
+    await sourceModel[this.accessors()[call]](targetObjects, {
+      transaction: transaction2
+    });
+    for (const [id, throughValues] of Object.entries(setObj)) {
+      if (typeof throughValues === "object") {
+        const instance = await this.targetModel.findByPk(id, {
+          transaction: transaction2
+        });
+        await (0, import_update_associations.updateThroughTableValue)(instance, this.throughName(), throughValues, sourceModel, transaction2);
+      }
+    }
+  }
+};
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "create", _create_dec, _BelongsToManyRepository);
+__decorateElement(_init, 1, "destroy", _destroy_dec, _BelongsToManyRepository);
+__decorateElement(_init, 1, "add", _add_dec, _BelongsToManyRepository);
+__decorateElement(_init, 1, "set", _set_dec, _BelongsToManyRepository);
+__decorateElement(_init, 1, "toggle", _toggle_dec, _BelongsToManyRepository);
+__decoratorMetadata(_init, _BelongsToManyRepository);
+__name(_BelongsToManyRepository, "BelongsToManyRepository");
+let BelongsToManyRepository = _BelongsToManyRepository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BelongsToManyRepository
+});

package/lib/relation-repository/belongs-to-repository.d.ts

@@ -0,0 +1,6 @@
+import { SingleRelationRepository } from './single-relation-repository';
+export declare class BelongsToRepository extends SingleRelationRepository {
+    filterOptions(sourceModel: any): Promise<{
+        [x: number]: any;
+    }>;
+}

package/lib/relation-repository/belongs-to-repository.js

@@ -0,0 +1,39 @@
+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 belongs_to_repository_exports = {};
+__export(belongs_to_repository_exports, {
+  BelongsToRepository: () => BelongsToRepository
+});
+module.exports = __toCommonJS(belongs_to_repository_exports);
+var import_single_relation_repository = require("./single-relation-repository");
+const _BelongsToRepository = class _BelongsToRepository extends import_single_relation_repository.SingleRelationRepository {
+  async filterOptions(sourceModel) {
+    const association = this.association;
+    return {
+      // @ts-ignore
+      [association.targetKey]: sourceModel.get(association.foreignKey)
+    };
+  }
+};
+__name(_BelongsToRepository, "BelongsToRepository");
+let BelongsToRepository = _BelongsToRepository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BelongsToRepository
+});

package/lib/relation-repository/hasmany-repository.d.ts

@@ -0,0 +1,10 @@
+import { AggregateOptions, DestroyOptions, FindOptions, TargetKey, TK } from '../repository';
+import { AssociatedOptions, MultipleRelationRepository } from './multiple-relation-repository';
+export declare class HasManyRepository extends MultipleRelationRepository {
+    find(options?: FindOptions): Promise<any>;
+    aggregate(options: AggregateOptions): Promise<any>;
+    destroy(options?: TK | DestroyOptions): Promise<boolean>;
+    set(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+    add(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+    accessors(): import("sequelize").MultiAssociationAccessors;
+}

package/lib/relation-repository/hasmany-repository.js

@@ -0,0 +1,182 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __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 __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 hasmany_repository_exports = {};
+__export(hasmany_repository_exports, {
+  HasManyRepository: () => HasManyRepository
+});
+module.exports = __toCommonJS(hasmany_repository_exports);
+var import_lodash = require("lodash");
+var import_sequelize = require("sequelize");
+var import_multiple_relation_repository = require("./multiple-relation-repository");
+var import_relation_repository = require("./relation-repository");
+var _add_dec, _set_dec, _destroy_dec, _a, _init;
+const _HasManyRepository = class _HasManyRepository extends (_a = import_multiple_relation_repository.MultipleRelationRepository, _destroy_dec = [(0, import_relation_repository.transaction)((args, transaction2) => {
+  return {
+    filterByTk: args[0],
+    transaction: transaction2
+  };
+})], _set_dec = [(0, import_relation_repository.transaction)((args, transaction2) => {
+  return {
+    tk: args[0],
+    transaction: transaction2
+  };
+})], _add_dec = [(0, import_relation_repository.transaction)((args, transaction2) => {
+  return {
+    tk: args[0],
+    transaction: transaction2
+  };
+})], _a) {
+  constructor() {
+    super(...arguments);
+    __runInitializers(_init, 5, this);
+  }
+  async find(options) {
+    const targetRepository = this.targetCollection.repository;
+    const addFilter = {
+      [this.association.foreignKey]: this.sourceKeyValue
+    };
+    if (options == null ? void 0 : options.filterByTk) {
+      addFilter[this.associationField.targetKey] = options.filterByTk;
+    }
+    const findOptions = {
+      ...(0, import_lodash.omit)(options, ["filterByTk", "where", "values", "attributes"]),
+      filter: {
+        $and: [options.filter || {}, addFilter]
+      }
+    };
+    return await targetRepository.find(findOptions);
+  }
+  async aggregate(options) {
+    const targetRepository = this.targetCollection.repository;
+    const addFilter = {
+      [this.association.foreignKey]: this.sourceKeyValue
+    };
+    const aggOptions = {
+      ...options,
+      filter: {
+        $and: [options.filter || {}, addFilter]
+      }
+    };
+    return await targetRepository.aggregate(aggOptions);
+  }
+  async destroy(options) {
+    const transaction2 = await this.getTransaction(options);
+    const sourceModel = await this.getSourceModel(transaction2);
+    const where = [
+      {
+        [this.association.foreignKey]: sourceModel.get(this.association.sourceKey)
+      }
+    ];
+    if (options && options["filter"]) {
+      const filterResult = this.parseFilter(options["filter"], options);
+      if (filterResult.include && filterResult.include.length > 0) {
+        return await this.destroyByFilter(options["filter"], transaction2);
+      }
+      where.push(filterResult.where);
+    }
+    if (options && options["filterByTk"]) {
+      if (typeof options === "object" && options["filterByTk"]) {
+        options = options["filterByTk"];
+      }
+      where.push({
+        [this.targetKey()]: options
+      });
+    }
+    await this.targetModel.destroy({
+      where: {
+        [import_sequelize.Op.and]: where
+      },
+      individualHooks: true,
+      transaction: transaction2
+    });
+    return true;
+  }
+  async set(options) {
+    const transaction2 = await this.getTransaction(options);
+    const sourceModel = await this.getSourceModel(transaction2);
+    await sourceModel[this.accessors().set](this.convertTks(options), {
+      transaction: transaction2
+    });
+  }
+  async add(options) {
+    const transaction2 = await this.getTransaction(options);
+    const sourceModel = await this.getSourceModel(transaction2);
+    await sourceModel[this.accessors().add](this.convertTks(options), {
+      transaction: transaction2
+    });
+  }
+  accessors() {
+    return this.association.accessors;
+  }
+};
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "destroy", _destroy_dec, _HasManyRepository);
+__decorateElement(_init, 1, "set", _set_dec, _HasManyRepository);
+__decorateElement(_init, 1, "add", _add_dec, _HasManyRepository);
+__decoratorMetadata(_init, _HasManyRepository);
+__name(_HasManyRepository, "HasManyRepository");
+let HasManyRepository = _HasManyRepository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HasManyRepository
+});

package/lib/relation-repository/hasone-repository.d.ts

@@ -0,0 +1,6 @@
+import { SingleRelationRepository } from './single-relation-repository';
+export declare class HasOneRepository extends SingleRelationRepository {
+    filterOptions(sourceModel: any): {
+        [x: string]: any;
+    };
+}

package/lib/relation-repository/hasone-repository.js

@@ -0,0 +1,39 @@
+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 hasone_repository_exports = {};
+__export(hasone_repository_exports, {
+  HasOneRepository: () => HasOneRepository
+});
+module.exports = __toCommonJS(hasone_repository_exports);
+var import_single_relation_repository = require("./single-relation-repository");
+const _HasOneRepository = class _HasOneRepository extends import_single_relation_repository.SingleRelationRepository {
+  filterOptions(sourceModel) {
+    const association = this.association;
+    return {
+      // @ts-ignore
+      [association.foreignKey]: sourceModel.get(association.sourceKey)
+    };
+  }
+};
+__name(_HasOneRepository, "HasOneRepository");
+let HasOneRepository = _HasOneRepository;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HasOneRepository
+});

package/lib/relation-repository/multiple-relation-repository.d.ts

@@ -0,0 +1,20 @@
+import { MultiAssociationAccessors, Transaction, Transactionable } from 'sequelize';
+import { CommonFindOptions, CountOptions, DestroyOptions, Filter, FindOneOptions, FindOptions, TargetKey, TK, UpdateOptions } from '../repository';
+import { RelationRepository } from './relation-repository';
+export type FindAndCountOptions = CommonFindOptions;
+export interface AssociatedOptions extends Transactionable {
+    tk?: TK;
+}
+export declare abstract class MultipleRelationRepository extends RelationRepository {
+    extendFindOptions(findOptions: any): any;
+    find(options?: FindOptions): Promise<any>;
+    findAndCount(options?: FindAndCountOptions): Promise<[any[], number]>;
+    count(options?: CountOptions): Promise<number>;
+    findOne(options?: FindOneOptions): Promise<any>;
+    remove(options: TargetKey | TargetKey[] | AssociatedOptions): Promise<void>;
+    update(options?: UpdateOptions): Promise<any>;
+    destroy(options?: TK | DestroyOptions): Promise<boolean>;
+    protected destroyByFilter(filter: Filter, transaction?: Transaction): Promise<boolean>;
+    protected filterHasInclude(filter: Filter, options?: any): boolean;
+    protected accessors(): MultiAssociationAccessors;
+}