openloops 0.1.9 → 0.1.11

package/dist/common/core/utils/delete-empty-fields.js

@@ -0,0 +1,66 @@
+"use strict";
+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 delete_empty_fields_exports = {};
+__export(delete_empty_fields_exports, {
+  deleteEmptyFields: () => deleteEmptyFields
+});
+module.exports = __toCommonJS(delete_empty_fields_exports);
+var import_is_plain_object = require("./is-plain-object");
+function safeClone(value) {
+  if (Array.isArray(value)) {
+    return value.map(safeClone);
+  }
+  if ((0, import_is_plain_object.isPlainObject)(value)) {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = safeClone(value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function deleteEmptyFields(object) {
+  const cleanObject = (obj) => {
+    if (Array.isArray(obj)) {
+      obj.forEach(cleanObject);
+      return;
+    }
+    if (!(0, import_is_plain_object.isPlainObject)(obj)) return;
+    Object.keys(obj).forEach((key) => {
+      const value = obj[key];
+      if (Array.isArray(value)) {
+        cleanObject(value);
+      } else if ((0, import_is_plain_object.isPlainObject)(value)) {
+        cleanObject(value);
+        if (Object.keys(value).length === 0) {
+          delete obj[key];
+        }
+      } else if (value === void 0 || value === null) {
+        delete obj[key];
+      }
+    });
+  };
+  const clonedObject = safeClone(object);
+  cleanObject(clonedObject);
+  return clonedObject;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteEmptyFields
+});

package/dist/common/core/utils/delete-empty-fields.mjs

@@ -0,0 +1,43 @@
+import "../../../chunk-XRJFNASX.mjs";
+import { isPlainObject } from "./is-plain-object";
+function safeClone(value) {
+  if (Array.isArray(value)) {
+    return value.map(safeClone);
+  }
+  if (isPlainObject(value)) {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      result[key] = safeClone(value[key]);
+    }
+    return result;
+  }
+  return value;
+}
+function deleteEmptyFields(object) {
+  const cleanObject = (obj) => {
+    if (Array.isArray(obj)) {
+      obj.forEach(cleanObject);
+      return;
+    }
+    if (!isPlainObject(obj)) return;
+    Object.keys(obj).forEach((key) => {
+      const value = obj[key];
+      if (Array.isArray(value)) {
+        cleanObject(value);
+      } else if (isPlainObject(value)) {
+        cleanObject(value);
+        if (Object.keys(value).length === 0) {
+          delete obj[key];
+        }
+      } else if (value === void 0 || value === null) {
+        delete obj[key];
+      }
+    });
+  };
+  const clonedObject = safeClone(object);
+  cleanObject(clonedObject);
+  return clonedObject;
+}
+export {
+  deleteEmptyFields
+};

package/dist/common/core/utils/flatten-object.d.ts

@@ -0,0 +1 @@
+export declare function flattenObject(obj: any, parentKey?: string, result?: {}): any;

package/dist/common/core/utils/flatten-object.js

@@ -0,0 +1,45 @@
+"use strict";
+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 flatten_object_exports = {};
+__export(flatten_object_exports, {
+  flattenObject: () => flattenObject
+});
+module.exports = __toCommonJS(flatten_object_exports);
+var import_is_plain_object = require("./is-plain-object");
+function flattenObject(obj, parentKey = "", result = {}) {
+  if (!(0, import_is_plain_object.isPlainObject)(obj)) {
+    return {};
+  }
+  for (let key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const newKey = parentKey ? `${parentKey}.${key}` : key;
+      const value = obj[key];
+      if ((0, import_is_plain_object.isPlainObject)(value)) {
+        flattenObject(value, newKey, result);
+      } else {
+        result[newKey] = value;
+      }
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  flattenObject
+});

package/dist/common/core/utils/flatten-object.mjs

@@ -0,0 +1,22 @@
+import "../../../chunk-XRJFNASX.mjs";
+import { isPlainObject } from "./is-plain-object";
+function flattenObject(obj, parentKey = "", result = {}) {
+  if (!isPlainObject(obj)) {
+    return {};
+  }
+  for (let key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      const newKey = parentKey ? `${parentKey}.${key}` : key;
+      const value = obj[key];
+      if (isPlainObject(value)) {
+        flattenObject(value, newKey, result);
+      } else {
+        result[newKey] = value;
+      }
+    }
+  }
+  return result;
+}
+export {
+  flattenObject
+};

package/dist/common/core/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './delete-empty-fields';
+export * from './is-plain-object';
+export * from './flatten-object';

package/dist/common/core/utils/index.js

@@ -0,0 +1,26 @@
+"use strict";
+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 utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./delete-empty-fields"), module.exports);
+__reExport(utils_exports, require("./is-plain-object"), module.exports);
+__reExport(utils_exports, require("./flatten-object"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./delete-empty-fields"),
+  ...require("./is-plain-object"),
+  ...require("./flatten-object")
+});

package/dist/common/core/utils/index.mjs

@@ -0,0 +1,3 @@
+export * from "./delete-empty-fields";
+export * from "./is-plain-object";
+export * from "./flatten-object";

package/dist/common/core/utils/is-plain-object.d.ts

@@ -0,0 +1 @@
+export declare function isPlainObject(value: any): boolean;

package/dist/common/core/utils/is-plain-object.js

@@ -0,0 +1,32 @@
+"use strict";
+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 is_plain_object_exports = {};
+__export(is_plain_object_exports, {
+  isPlainObject: () => isPlainObject
+});
+module.exports = __toCommonJS(is_plain_object_exports);
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPlainObject
+});

package/dist/common/core/utils/is-plain-object.mjs

@@ -0,0 +1,9 @@
+import "../../../chunk-XRJFNASX.mjs";
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+export {
+  isPlainObject
+};

package/dist/common/decorators/admin-only/admin-only.d.ts

@@ -0,0 +1,2 @@
+export declare function AdminOnly(target: any, propertyKey: string): void;
+export declare function filterAdminOnlyProperties(object: Record<string, any>): Record<string, any>;

package/dist/common/decorators/admin-only/admin-only.js

@@ -0,0 +1,52 @@
+"use strict";
+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 admin_only_exports = {};
+__export(admin_only_exports, {
+  AdminOnly: () => AdminOnly,
+  filterAdminOnlyProperties: () => filterAdminOnlyProperties
+});
+module.exports = __toCommonJS(admin_only_exports);
+const METADATA_KEY = "adminOnly";
+function AdminOnly(target, propertyKey) {
+  Reflect.defineMetadata(METADATA_KEY, true, target, propertyKey);
+}
+const isAdminOnly = (object, key) => Reflect.getMetadata(METADATA_KEY, object, key);
+function filterAdminOnlyProperties(object) {
+  if (object && typeof object === "object") {
+    const newObject = {};
+    for (const [key, value] of Object.entries(object)) {
+      if (!isAdminOnly(object, key)) {
+        if (Array.isArray(value)) {
+          newObject[key] = value.map((item) => filterAdminOnlyProperties(item));
+        } else if (typeof value === "object") {
+          newObject[key] = filterAdminOnlyProperties(value);
+        } else {
+          newObject[key] = value;
+        }
+      }
+    }
+    return newObject;
+  }
+  return object;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdminOnly,
+  filterAdminOnlyProperties
+});

package/dist/common/decorators/admin-only/admin-only.mjs

@@ -0,0 +1,28 @@
+import "../../../chunk-XRJFNASX.mjs";
+const METADATA_KEY = "adminOnly";
+function AdminOnly(target, propertyKey) {
+  Reflect.defineMetadata(METADATA_KEY, true, target, propertyKey);
+}
+const isAdminOnly = (object, key) => Reflect.getMetadata(METADATA_KEY, object, key);
+function filterAdminOnlyProperties(object) {
+  if (object && typeof object === "object") {
+    const newObject = {};
+    for (const [key, value] of Object.entries(object)) {
+      if (!isAdminOnly(object, key)) {
+        if (Array.isArray(value)) {
+          newObject[key] = value.map((item) => filterAdminOnlyProperties(item));
+        } else if (typeof value === "object") {
+          newObject[key] = filterAdminOnlyProperties(value);
+        } else {
+          newObject[key] = value;
+        }
+      }
+    }
+    return newObject;
+  }
+  return object;
+}
+export {
+  AdminOnly,
+  filterAdminOnlyProperties
+};

package/dist/common/decorators/admin-only/index.d.ts

@@ -0,0 +1 @@
+export * from './admin-only';

package/dist/common/decorators/admin-only/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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 admin_only_exports = {};
+module.exports = __toCommonJS(admin_only_exports);
+__reExport(admin_only_exports, require("./admin-only"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./admin-only")
+});

package/dist/common/decorators/admin-only/index.mjs

@@ -0,0 +1 @@
+export * from "./admin-only";

package/dist/common/decorators/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mask-in-logs';
+export * from './admin-only';
+export * from './owner-only';

package/dist/common/decorators/index.js

@@ -0,0 +1,26 @@
+"use strict";
+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 decorators_exports = {};
+module.exports = __toCommonJS(decorators_exports);
+__reExport(decorators_exports, require("./mask-in-logs"), module.exports);
+__reExport(decorators_exports, require("./admin-only"), module.exports);
+__reExport(decorators_exports, require("./owner-only"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./mask-in-logs"),
+  ...require("./admin-only"),
+  ...require("./owner-only")
+});

package/dist/common/decorators/index.mjs

@@ -0,0 +1,3 @@
+export * from "./mask-in-logs";
+export * from "./admin-only";
+export * from "./owner-only";

package/dist/common/decorators/mask-in-logs/index.d.ts

@@ -0,0 +1 @@
+export * from './mask-in-logs';

package/dist/common/decorators/mask-in-logs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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 mask_in_logs_exports = {};
+module.exports = __toCommonJS(mask_in_logs_exports);
+__reExport(mask_in_logs_exports, require("./mask-in-logs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./mask-in-logs")
+});

package/dist/common/decorators/mask-in-logs/index.mjs

@@ -0,0 +1 @@
+export * from "./mask-in-logs";

package/dist/common/decorators/mask-in-logs/mask-in-logs.d.ts

@@ -0,0 +1,2 @@
+export declare function MaskInLogs(target: any, propertyKey: string): void;
+export declare function handleMaskInLogs(object: Record<string, any>): Record<string, any>;

package/dist/common/decorators/mask-in-logs/mask-in-logs.js

@@ -0,0 +1,53 @@
+"use strict";
+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 mask_in_logs_exports = {};
+__export(mask_in_logs_exports, {
+  MaskInLogs: () => MaskInLogs,
+  handleMaskInLogs: () => handleMaskInLogs
+});
+module.exports = __toCommonJS(mask_in_logs_exports);
+var import_utils = require("../../core/utils/index.js");
+const METADATA_KEY = "maskInLogs";
+function MaskInLogs(target, propertyKey) {
+  Reflect.defineMetadata(METADATA_KEY, true, target, propertyKey);
+}
+const shouldMaskInLogs = (object, key) => Reflect.getMetadata(METADATA_KEY, object, key);
+function handleMaskInLogs(object) {
+  if (object && (0, import_utils.isPlainObject)(object)) {
+    const newObject = {};
+    for (const [key, value] of Object.entries(object)) {
+      if (shouldMaskInLogs(object, key)) {
+        newObject[key] = "[HIDDEN]";
+      } else if (Array.isArray(value)) {
+        newObject[key] = value.map((item) => handleMaskInLogs(item));
+      } else if (typeof value === "object") {
+        newObject[key] = handleMaskInLogs(value);
+      } else {
+        newObject[key] = value;
+      }
+    }
+    return newObject;
+  }
+  return object;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MaskInLogs,
+  handleMaskInLogs
+});

package/dist/common/decorators/mask-in-logs/mask-in-logs.mjs

@@ -0,0 +1,29 @@
+import "../../../chunk-XRJFNASX.mjs";
+import { isPlainObject } from "../../core/utils/index.js";
+const METADATA_KEY = "maskInLogs";
+function MaskInLogs(target, propertyKey) {
+  Reflect.defineMetadata(METADATA_KEY, true, target, propertyKey);
+}
+const shouldMaskInLogs = (object, key) => Reflect.getMetadata(METADATA_KEY, object, key);
+function handleMaskInLogs(object) {
+  if (object && isPlainObject(object)) {
+    const newObject = {};
+    for (const [key, value] of Object.entries(object)) {
+      if (shouldMaskInLogs(object, key)) {
+        newObject[key] = "[HIDDEN]";
+      } else if (Array.isArray(value)) {
+        newObject[key] = value.map((item) => handleMaskInLogs(item));
+      } else if (typeof value === "object") {
+        newObject[key] = handleMaskInLogs(value);
+      } else {
+        newObject[key] = value;
+      }
+    }
+    return newObject;
+  }
+  return object;
+}
+export {
+  MaskInLogs,
+  handleMaskInLogs
+};

package/dist/common/decorators/owner-only/index.d.ts

@@ -0,0 +1 @@
+export * from './owner-only';

package/dist/common/decorators/owner-only/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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 owner_only_exports = {};
+module.exports = __toCommonJS(owner_only_exports);
+__reExport(owner_only_exports, require("./owner-only"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./owner-only")
+});

package/dist/common/decorators/owner-only/index.mjs

@@ -0,0 +1 @@
+export * from "./owner-only";

package/dist/common/decorators/owner-only/owner-only.d.ts

@@ -0,0 +1,2 @@
+export declare function OwnerOnly(target: any, propertyKey: string): void;
+export declare function filterOwnerOnlyProperties(object: Record<string, any>): Record<string, any>;

package/dist/common/decorators/owner-only/owner-only.js

@@ -0,0 +1,52 @@
+"use strict";
+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 owner_only_exports = {};
+__export(owner_only_exports, {
+  OwnerOnly: () => OwnerOnly,
+  filterOwnerOnlyProperties: () => filterOwnerOnlyProperties
+});
+module.exports = __toCommonJS(owner_only_exports);
+const METADATA_KEY = "ownerOnly";
+function OwnerOnly(target, propertyKey) {
+  Reflect.defineMetadata(METADATA_KEY, true, target, propertyKey);
+}
+const isOwnerOnly = (object, key) => Reflect.getMetadata(METADATA_KEY, object, key);
+function filterOwnerOnlyProperties(object) {
+  if (object && typeof object === "object") {
+    const newObject = {};
+    for (const [key, value] of Object.entries(object)) {
+      if (!isOwnerOnly(object, key)) {
+        if (Array.isArray(value)) {
+          newObject[key] = value.map((item) => filterOwnerOnlyProperties(item));
+        } else if (typeof value === "object") {
+          newObject[key] = filterOwnerOnlyProperties(value);
+        } else {
+          newObject[key] = value;
+        }
+      }
+    }
+    return newObject;
+  }
+  return object;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OwnerOnly,
+  filterOwnerOnlyProperties
+});

package/dist/common/decorators/owner-only/owner-only.mjs

@@ -0,0 +1,28 @@
+import "../../../chunk-XRJFNASX.mjs";
+const METADATA_KEY = "ownerOnly";
+function OwnerOnly(target, propertyKey) {
+  Reflect.defineMetadata(METADATA_KEY, true, target, propertyKey);
+}
+const isOwnerOnly = (object, key) => Reflect.getMetadata(METADATA_KEY, object, key);
+function filterOwnerOnlyProperties(object) {
+  if (object && typeof object === "object") {
+    const newObject = {};
+    for (const [key, value] of Object.entries(object)) {
+      if (!isOwnerOnly(object, key)) {
+        if (Array.isArray(value)) {
+          newObject[key] = value.map((item) => filterOwnerOnlyProperties(item));
+        } else if (typeof value === "object") {
+          newObject[key] = filterOwnerOnlyProperties(value);
+        } else {
+          newObject[key] = value;
+        }
+      }
+    }
+    return newObject;
+  }
+  return object;
+}
+export {
+  OwnerOnly,
+  filterOwnerOnlyProperties
+};