@tachybase/actions 0.23.8

package/lib/actions/list.js

@@ -0,0 +1,225 @@
+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 list_exports = {};
+__export(list_exports, {
+  list: () => list
+});
+module.exports = __toCommonJS(list_exports);
+var import_querystring = __toESM(require("querystring"));
+var import_utils = require("@tachybase/utils");
+var import_sequelize = require("sequelize");
+var import_constants = require("../constants");
+var import_utils2 = require("../utils");
+function totalPage(total, pageSize) {
+  return Math.ceil(total / pageSize);
+}
+__name(totalPage, "totalPage");
+function findArgs(ctx) {
+  var _a, _b, _c;
+  const resourceName = ctx.action.resourceName;
+  const params = ctx.action.params;
+  const includeSort = ((_a = params.sort) == null ? void 0 : _a.filter((item) => item.split(".").length > 1)) ?? [];
+  const sortItems = [];
+  includeSort.forEach((sort2) => {
+    const parts = sort2[0] === "-" ? sort2.slice(1, sort2.length).split(".") : sort2.split(".");
+    const prefix = parts.slice(0, -1).join(".");
+    const sign = sort2[0] === "-" ? "-" : "";
+    const sortItem = sign + parts.slice(-1).join(".");
+    const findIndex = sortItems.findIndex((item) => item.prefix === prefix);
+    if (findIndex !== -1) {
+      sortItems[findIndex].items.push(sortItem);
+    } else {
+      sortItems.push({
+        prefix,
+        sortItems: [sortItem]
+      });
+    }
+  });
+  sortItems.forEach((item) => {
+    var _a2;
+    const i = ((_a2 = params.appends) == null ? void 0 : _a2.findIndex((append) => append === item.prefix)) ?? -1;
+    if (i !== -1) {
+      params.appends[i] = `${item.prefix}(${import_querystring.default.stringify({ sort: item.sortItems })})`;
+    }
+  });
+  params.sort = ((_b = params.sort) == null ? void 0 : _b.filter((item) => item.split(".").length === 1)) ?? [];
+  if (params.tree) {
+    const [collectionName, associationName] = resourceName.split(".");
+    const collection = ctx.db.getCollection(resourceName);
+    if (collection.options.tree && !(associationName && collectionName === collection.name)) {
+      const foreignKey = ((_c = collection.treeParentField) == null ? void 0 : _c.foreignKey) || "parentId";
+      (0, import_utils.assign)(params, { filter: { [foreignKey]: null } }, { filter: "andMerge" });
+    }
+  }
+  const { tree, fields, filter, appends, except, sort } = params;
+  return { tree, filter, fields, appends, except, sort };
+}
+__name(findArgs, "findArgs");
+async function listWithPagination(ctx) {
+  var _a;
+  const { page = import_constants.DEFAULT_PAGE, pageSize = import_constants.DEFAULT_PER_PAGE } = ctx.action.params;
+  const repository = (0, import_utils2.getRepositoryFromParams)(ctx);
+  const resourceName = ctx.action.resourceName;
+  const collection = ctx.db.getCollection(resourceName);
+  const options = {
+    context: ctx,
+    ...findArgs(ctx),
+    ...(0, import_utils2.pageArgsToLimitArgs)(parseInt(String(page)), parseInt(String(pageSize)))
+  };
+  Object.keys(options).forEach((key) => {
+    if (options[key] === void 0) {
+      delete options[key];
+    }
+  });
+  let filterTreeData = [];
+  let filterTreeCount = 0;
+  if (ctx.action.params.tree && options.filter) {
+    const foreignKey = ((_a = collection.treeParentField) == null ? void 0 : _a.foreignKey) || "parentId";
+    const params = Object.values(options.filter).flat()[0] || {};
+    let dataIds = [];
+    if (Object.entries(params).length) {
+      const getParent = /* @__PURE__ */ __name(async (filter = {}) => {
+        const data = await repository.find({
+          filter
+        });
+        dataIds = data.map((item) => item.id);
+      }, "getParent");
+      await getParent(params);
+      const allDataIds = [];
+      for (const dataId of dataIds) {
+        const query = `
+        WITH RECURSIVE tree1 AS (
+            SELECT id, "${foreignKey}"
+            FROM ${collection.name}
+            WHERE id = :dataId
+
+              UNION ALL
+
+              SELECT p.id, p."${foreignKey}"
+              FROM tree1 up
+              JOIN ${collection.name} p ON up."${foreignKey}" = p.id
+          ),
+          tree2 AS (
+              SELECT id, "${foreignKey}"
+              FROM ${collection.name}
+              WHERE id = :dataId
+
+              UNION ALL
+
+            SELECT p.id, p."${foreignKey}"
+            FROM tree2 down
+            JOIN ${collection.name} p ON down.id = p."${foreignKey}"
+        )
+        SELECT DISTINCT *
+        FROM (
+          SELECT *
+          FROM tree1
+          UNION ALL
+          SELECT *
+          FROM tree2
+      ) AS formData;`;
+        const filterTreeDatas = await ctx.db.sequelize.query(query, {
+          replacements: {
+            dataId
+          },
+          type: import_sequelize.QueryTypes.SELECT
+        });
+        const newRows = filterTreeDatas;
+        const filterIds = newRows.map((item) => item.id);
+        allDataIds.push(...filterIds);
+      }
+      const ids = [...new Set(allDataIds)];
+      const where = {
+        id: {
+          [import_sequelize.Op.in]: ids
+        }
+      };
+      const [rows2, count2] = await repository.findAndCount({
+        filter: where,
+        appends: options.appends || []
+      });
+      const _data = rows2.map((item) => item.dataValues);
+      const father = _data.filter((parent) => parent.parentId === null);
+      const transTreeData = /* @__PURE__ */ __name((father2, allRows) => {
+        father2.forEach((parent, index) => {
+          var _a2;
+          const children = allRows.filter((child) => child.parentId === parent.id);
+          const i = index.toString();
+          parent.__index = parent.father || parent.father === "0" ? parent.father + ".children." + i : i;
+          if (children == null ? void 0 : children.length) {
+            const transChild = children.map((child) => {
+              return {
+                ...child,
+                father: parent.__index
+              };
+            });
+            parent.children = transChild;
+          }
+          if ((_a2 = parent.children) == null ? void 0 : _a2.length) {
+            transTreeData(parent.children, allRows);
+          }
+        });
+      }, "transTreeData");
+      transTreeData(father, _data);
+      filterTreeData = father;
+      filterTreeCount = father.length;
+    }
+  }
+  const [rows, count] = await repository.findAndCount(options);
+  ctx.body = {
+    count: filterTreeData.length ? filterTreeCount : count,
+    rows: filterTreeData.length ? filterTreeData : rows,
+    page: Number(page),
+    pageSize: Number(pageSize),
+    totalPage: totalPage(count, pageSize)
+  };
+}
+__name(listWithPagination, "listWithPagination");
+async function listWithNonPaged(ctx) {
+  const repository = (0, import_utils2.getRepositoryFromParams)(ctx);
+  const rows = await repository.find({ context: ctx, ...findArgs(ctx) });
+  ctx.body = rows;
+}
+__name(listWithNonPaged, "listWithNonPaged");
+async function list(ctx, next) {
+  const { paginate } = ctx.action.params;
+  if (paginate === false || paginate === "false") {
+    await listWithNonPaged(ctx);
+    ctx.paginate = false;
+  } else {
+    await listWithPagination(ctx);
+    ctx.paginate = true;
+  }
+  await next();
+}
+__name(list, "list");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  list
+});

package/lib/actions/move.d.ts

@@ -0,0 +1,18 @@
+import { Collection, SortField, TargetKey } from '@tachybase/database';
+import { Model } from 'sequelize';
+import { Context } from '..';
+export declare function move(ctx: Context, next: any): Promise<void>;
+interface MoveOptions {
+    insertAfter?: boolean;
+}
+export declare class SortAbleCollection {
+    collection: Collection;
+    field: SortField;
+    scopeKey: string;
+    constructor(collection: Collection, fieldName?: string);
+    move(sourceInstanceId: TargetKey, targetInstanceId: TargetKey, options?: MoveOptions): Promise<void>;
+    changeScope(sourceInstanceId: TargetKey, targetScope: any, method?: string): Promise<void>;
+    sticky(sourceInstanceId: TargetKey): Promise<void>;
+    sameScopeMove(sourceInstance: Model, targetInstance: Model, options: MoveOptions, sourceInstanceId: TargetKey): Promise<void>;
+}
+export {};

package/lib/actions/move.js

@@ -0,0 +1,168 @@
+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 move_exports = {};
+__export(move_exports, {
+  SortAbleCollection: () => SortAbleCollection,
+  move: () => move
+});
+module.exports = __toCommonJS(move_exports);
+var import_database = require("@tachybase/database");
+var import_sequelize = require("sequelize");
+var import_utils = require("../utils");
+async function move(ctx, next) {
+  const repository = ctx.databaseRepository || (0, import_utils.getRepositoryFromParams)(ctx);
+  const { sourceId, targetId, sortField, targetScope, sticky, method } = ctx.action.params;
+  if (repository instanceof import_database.BelongsToManyRepository) {
+    throw new Error("Sorting association as 'belongs-to-many' type is not supported.");
+  }
+  if (repository instanceof import_database.HasManyRepository) {
+    const hasManyField = repository.sourceCollection.getField(repository.associationName);
+    if (!hasManyField.options.sortable) {
+      throw new Error(
+        `association ${hasManyField.options.name} in ${repository.sourceCollection.name} is not sortable`
+      );
+    }
+  }
+  const sortAbleCollection = new SortAbleCollection(
+    repository instanceof import_database.Repository ? repository.collection : repository.targetCollection,
+    repository instanceof import_database.Repository ? sortField : `${repository.association.foreignKey}Sort`
+  );
+  if (sourceId && targetId) {
+    await sortAbleCollection.move(sourceId, targetId, {
+      insertAfter: method === "insertAfter"
+    });
+  }
+  if (sourceId && targetScope) {
+    await sortAbleCollection.changeScope(sourceId, targetScope, method);
+  }
+  if (sourceId && sticky) {
+    await sortAbleCollection.sticky(sourceId);
+  }
+  ctx.body = "ok";
+  await next();
+}
+__name(move, "move");
+const _SortAbleCollection = class _SortAbleCollection {
+  collection;
+  field;
+  scopeKey;
+  constructor(collection, fieldName = "sort") {
+    this.collection = collection;
+    this.field = collection.getField(fieldName);
+    if (!(this.field instanceof import_database.SortField)) {
+      throw new Error(`${fieldName} is not a sort field`);
+    }
+    this.scopeKey = this.field.get("scopeKey");
+  }
+  // insert source position to target position
+  async move(sourceInstanceId, targetInstanceId, options = {}) {
+    const sourceInstance = await this.collection.repository.findById(sourceInstanceId);
+    const targetInstance = await this.collection.repository.findById(targetInstanceId);
+    if (this.scopeKey && sourceInstance.get(this.scopeKey) !== targetInstance.get(this.scopeKey)) {
+      await this.collection.repository.update({
+        targetCollection: this.collection.name,
+        filterByTk: sourceInstanceId,
+        values: {
+          [this.scopeKey]: targetInstance.get(this.scopeKey)
+        },
+        silent: false
+      });
+    }
+    await this.sameScopeMove(sourceInstance, targetInstance, options, sourceInstanceId);
+  }
+  async changeScope(sourceInstanceId, targetScope, method) {
+    const sourceInstance = await this.collection.repository.findById(sourceInstanceId);
+    const targetScopeValue = targetScope[this.scopeKey];
+    if (targetScopeValue && sourceInstance.get(this.scopeKey) !== targetScopeValue) {
+      await this.collection.repository.update({
+        targetCollection: this.collection.name,
+        filterByTk: sourceInstanceId,
+        values: {
+          [this.scopeKey]: targetScopeValue
+        },
+        silent: false
+      });
+      if (method === "prepend") {
+        await this.sticky(sourceInstanceId);
+      }
+    }
+  }
+  async sticky(sourceInstanceId) {
+    await this.collection.repository.update({
+      targetCollection: this.collection.name,
+      filterByTk: sourceInstanceId,
+      values: {
+        [this.field.get("name")]: 0
+      },
+      silent: true
+    });
+  }
+  async sameScopeMove(sourceInstance, targetInstance, options, sourceInstanceId) {
+    const fieldName = this.field.get("name");
+    const sourceSort = sourceInstance.get(fieldName);
+    let targetSort = targetInstance.get(fieldName);
+    if (options.insertAfter) {
+      targetSort = targetSort + 1;
+    }
+    const scopeValue = this.scopeKey ? sourceInstance.get(this.scopeKey) : null;
+    let updateCondition;
+    let change;
+    if (targetSort > sourceSort) {
+      updateCondition = {
+        [import_sequelize.Op.gt]: sourceSort,
+        [import_sequelize.Op.lte]: targetSort
+      };
+      change = -1;
+    } else {
+      updateCondition = {
+        [import_sequelize.Op.lt]: sourceSort,
+        [import_sequelize.Op.gte]: targetSort
+      };
+      change = 1;
+    }
+    const where = {
+      [fieldName]: updateCondition
+    };
+    if (scopeValue) {
+      where[this.scopeKey] = {
+        [import_sequelize.Op.eq]: scopeValue
+      };
+    }
+    await this.collection.model.increment(fieldName, {
+      where,
+      by: change,
+      silent: true
+    });
+    await this.collection.repository.update({
+      targetCollection: this.collection.name,
+      filterByTk: sourceInstanceId,
+      values: {
+        [fieldName]: targetSort
+      },
+      silent: true
+    });
+  }
+};
+__name(_SortAbleCollection, "SortAbleCollection");
+let SortAbleCollection = _SortAbleCollection;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SortAbleCollection,
+  move
+});

package/lib/actions/proxy-to-repository.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '../index';
+export declare function proxyToRepository(paramKeys: string[], repositoryMethod: string): (ctx: Context, next: any) => Promise<void>;

package/lib/actions/proxy-to-repository.js

@@ -0,0 +1,50 @@
+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 proxy_to_repository_exports = {};
+__export(proxy_to_repository_exports, {
+  proxyToRepository: () => proxyToRepository
+});
+module.exports = __toCommonJS(proxy_to_repository_exports);
+var import_lodash = __toESM(require("lodash"));
+var import_utils = require("../utils");
+function proxyToRepository(paramKeys, repositoryMethod) {
+  return async function(ctx, next) {
+    const repository = (0, import_utils.getRepositoryFromParams)(ctx);
+    const callObj = import_lodash.default.pick(ctx.action.params, paramKeys);
+    callObj.context = ctx;
+    ctx.body = await repository[repositoryMethod](callObj);
+    ctx.status = 200;
+    await next();
+  };
+}
+__name(proxyToRepository, "proxyToRepository");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  proxyToRepository
+});

package/lib/actions/remove.d.ts

@@ -0,0 +1 @@
+export declare const remove: (ctx: import("..").Context, next: any) => Promise<void>;

package/lib/actions/remove.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 remove_exports = {};
+__export(remove_exports, {
+  remove: () => remove
+});
+module.exports = __toCommonJS(remove_exports);
+var import_utils = require("../utils");
+const remove = (0, import_utils.RelationRepositoryActionBuilder)("remove");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  remove
+});

package/lib/actions/set.d.ts

@@ -0,0 +1 @@
+export declare const set: (ctx: import("..").Context, next: any) => Promise<void>;

package/lib/actions/set.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 set_exports = {};
+__export(set_exports, {
+  set: () => set
+});
+module.exports = __toCommonJS(set_exports);
+var import_utils = require("../utils");
+const set = (0, import_utils.RelationRepositoryActionBuilder)("set");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  set
+});

package/lib/actions/toggle.d.ts

@@ -0,0 +1,2 @@
+import { Context } from '..';
+export declare function toggle(ctx: Context, next: any): Promise<any>;

package/lib/actions/toggle.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 toggle_exports = {};
+__export(toggle_exports, {
+  toggle: () => toggle
+});
+module.exports = __toCommonJS(toggle_exports);
+var import_database = require("@tachybase/database");
+var import_utils = require("../utils");
+async function toggle(ctx, next) {
+  const repository = (0, import_utils.getRepositoryFromParams)(ctx);
+  if (!(repository instanceof import_database.BelongsToManyRepository)) {
+    return await next();
+  }
+  await repository.toggle(ctx.action.params.values);
+  ctx.body = "ok";
+  await next();
+}
+__name(toggle, "toggle");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toggle
+});

package/lib/actions/update-or-create.d.ts

@@ -0,0 +1 @@
+export declare const updateOrCreate: (ctx: import("..").Context, next: any) => Promise<void>;

package/lib/actions/update-or-create.js

@@ -0,0 +1,28 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 update_or_create_exports = {};
+__export(update_or_create_exports, {
+  updateOrCreate: () => updateOrCreate
+});
+module.exports = __toCommonJS(update_or_create_exports);
+var import_proxy_to_repository = require("./proxy-to-repository");
+const updateOrCreate = (0, import_proxy_to_repository.proxyToRepository)(["values", "filterKeys"], "updateOrCreate");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  updateOrCreate
+});

package/lib/actions/update.d.ts

@@ -0,0 +1 @@
+export declare const update: (ctx: import("..").Context, next: any) => Promise<void>;

package/lib/actions/update.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 update_exports = {};
+__export(update_exports, {
+  update: () => update
+});
+module.exports = __toCommonJS(update_exports);
+var import_proxy_to_repository = require("./proxy-to-repository");
+const update = (0, import_proxy_to_repository.proxyToRepository)(
+  [
+    "filterByTk",
+    "values",
+    "whitelist",
+    "blacklist",
+    "filter",
+    "updateAssociationValues",
+    "forceUpdate",
+    "targetCollection"
+  ],
+  "update"
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  update
+});

package/lib/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_PAGE = 1;
+export declare const DEFAULT_PER_PAGE = 20;