openloops 0.1.9 → 0.1.10

package/dist/common/clients/serper-client.mjs

@@ -0,0 +1,41 @@
+import "../../chunk-XRJFNASX.mjs";
+import axios from "axios";
+import { Logger } from "@common/logger";
+import { secretManager } from "@common/utils/secret-manager";
+class SerperClient {
+  logger = new Logger();
+  async searchOnGoogle(params) {
+    const { query, type, page, num, countryCode, languageCode } = params;
+    const apiKey = secretManager.get("SERPER_API_KEY");
+    const inputData = {
+      q: query,
+      type,
+      page,
+      num,
+      ...countryCode ? { gl: countryCode } : {},
+      ...languageCode ? { hl: languageCode } : {},
+      engine: "google"
+    };
+    const config = {
+      method: "post",
+      maxBodyLength: Infinity,
+      url: "https://google.serper.dev/search",
+      headers: {
+        "X-API-KEY": apiKey,
+        "Content-Type": "application/json"
+      },
+      data: inputData
+    };
+    try {
+      this.logger.debug({ ...inputData }, "[Serper Client] Searching on internet...");
+      const { data } = await axios.request(config);
+      this.logger.debug({ ...data }, "[Serper Client] Search results");
+      return data;
+    } catch (error) {
+      this.logger.error(error);
+    }
+  }
+}
+export {
+  SerperClient
+};

package/dist/common/core/base.app.d.ts

@@ -0,0 +1,12 @@
+import { Logger } from '@common/logger';
+import { HttpError, HttpErrorProps } from '@common/error';
+import { CurrentSessionProps } from '@services/app/core/current-session';
+export declare abstract class BaseApp {
+    logger: Logger;
+    secretManager: import("@common/utils/secret-manager").SecretManager;
+    reportError: (error: Error | HttpError | string, details?: object) => Promise<void>;
+    onCatch(error: Error): Promise<void>;
+    throwHttpError(error: HttpErrorProps): void;
+    throwError401(currentSession?: CurrentSessionProps): void;
+    throwError403(currentSession?: CurrentSessionProps): void;
+}

package/dist/common/core/base.app.js

@@ -0,0 +1,57 @@
+"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 base_app_exports = {};
+__export(base_app_exports, {
+  BaseApp: () => BaseApp
+});
+module.exports = __toCommonJS(base_app_exports);
+var import_logger = require("@common/logger");
+var import_error = require("@common/error");
+var import_error2 = require("@common/error");
+var import_secret_manager = require("@common/utils/secret-manager");
+class BaseApp {
+  logger = new import_logger.Logger();
+  secretManager = import_secret_manager.secretManager;
+  reportError = import_error.reportError;
+  async onCatch(error) {
+    await (0, import_error.reportError)(error);
+    throw error;
+  }
+  throwHttpError(error) {
+    throw new import_error2.HttpError(error);
+  }
+  throwError401(currentSession) {
+    this.throwHttpError({
+      statusCode: 401,
+      errorMessage: "{{invalid_token}}: {{not_authenticated_error_details}}",
+      errorDetails: JSON.stringify(currentSession ?? {})
+    });
+  }
+  throwError403(currentSession) {
+    this.throwHttpError({
+      statusCode: 403,
+      errorMessage: "{{forbidden_error}}: {{forbidden_error_details}}",
+      errorDetails: JSON.stringify(currentSession ?? {})
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseApp
+});

package/dist/common/core/base.app.mjs

@@ -0,0 +1,34 @@
+import "../../chunk-XRJFNASX.mjs";
+import { Logger } from "@common/logger";
+import { reportError } from "@common/error";
+import { HttpError } from "@common/error";
+import { secretManager } from "@common/utils/secret-manager";
+class BaseApp {
+  logger = new Logger();
+  secretManager = secretManager;
+  reportError = reportError;
+  async onCatch(error) {
+    await reportError(error);
+    throw error;
+  }
+  throwHttpError(error) {
+    throw new HttpError(error);
+  }
+  throwError401(currentSession) {
+    this.throwHttpError({
+      statusCode: 401,
+      errorMessage: "{{invalid_token}}: {{not_authenticated_error_details}}",
+      errorDetails: JSON.stringify(currentSession ?? {})
+    });
+  }
+  throwError403(currentSession) {
+    this.throwHttpError({
+      statusCode: 403,
+      errorMessage: "{{forbidden_error}}: {{forbidden_error_details}}",
+      errorDetails: JSON.stringify(currentSession ?? {})
+    });
+  }
+}
+export {
+  BaseApp
+};

package/dist/common/core/base.entity.d.ts

@@ -0,0 +1,55 @@
+import 'reflect-metadata';
+import { ObjectId } from 'bson';
+import { CurrentUser } from '@services/app/core';
+export interface BaseEntityProps {
+    _id?: string | ObjectId;
+    __v?: number;
+    ownerId?: string | ObjectId;
+    createdAt?: string | Date;
+    createdBy?: string | ObjectId;
+    updatedAt?: string | Date;
+    updatedBy?: string | ObjectId;
+    deletedAt?: string | Date;
+    deletedBy?: string | ObjectId;
+    deletedReason?: string;
+    archivedAt?: string | Date;
+    archivedBy?: string | ObjectId;
+    sharedWith?: string[] | ObjectId[];
+}
+export interface Document extends BaseEntityProps {
+    toUnset?: Record<string, unknown>;
+}
+export declare class BaseEntity {
+    _id?: ObjectId;
+    __v?: number;
+    ownerId?: ObjectId;
+    createdAt?: Date;
+    createdBy?: ObjectId;
+    updatedAt?: Date;
+    updatedBy?: ObjectId;
+    deletedAt?: Date;
+    deletedBy?: ObjectId;
+    deletedReason?: string;
+    archivedAt?: Date;
+    archivedBy?: ObjectId;
+    sharedWith?: ObjectId[];
+    private toUnset?;
+    static toObjectId(id?: string | ObjectId): ObjectId | undefined;
+    private static toDate;
+    private static toNumber;
+    static clean(json: any): any;
+    constructor(props: BaseEntityProps);
+    toJSON(): Document;
+    setDefaults(): void;
+    setId(id: string | ObjectId): void;
+    setOwner(currentUser?: CurrentUser): void;
+    setCreatedBy(currentUser?: CurrentUser): void;
+    setUpdatedBy(currentUser?: CurrentUser): void;
+    setDeletedBy(currentUser?: CurrentUser): void;
+    setArchivedBy(currentUser?: CurrentUser): void;
+    toDocument(): Document;
+    toFlatDocument(): Document;
+    stringify(): string;
+    unset(fields: (keyof this)[]): {} | undefined;
+    private sanitize;
+}

package/dist/common/core/base.entity.js

@@ -0,0 +1,208 @@
+"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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var base_entity_exports = {};
+__export(base_entity_exports, {
+  BaseEntity: () => BaseEntity
+});
+module.exports = __toCommonJS(base_entity_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_bson = require("bson");
+var import_decorators = require("@common/decorators");
+var import_helpers = require("@common/helpers");
+var import_utils = require("./utils");
+const _BaseEntity = class _BaseEntity {
+  _id;
+  __v;
+  ownerId;
+  createdAt;
+  createdBy;
+  updatedAt;
+  updatedBy;
+  deletedAt;
+  deletedBy;
+  deletedReason;
+  archivedAt;
+  archivedBy;
+  sharedWith;
+  toUnset;
+  static toObjectId(id) {
+    if (!id) return void 0;
+    if (id instanceof import_bson.ObjectId) return id;
+    if (!import_bson.ObjectId.isValid(id)) throw new Error(`Invalid ObjectId: ${id}`);
+    return new import_bson.ObjectId(id);
+  }
+  static toDate(value) {
+    if (!value) return void 0;
+    const date = new Date(value);
+    if (isNaN(date.getTime())) throw new Error("{{value_must_be_a_date}}");
+    return date;
+  }
+  static toNumber(value) {
+    if (value === void 0 || value === null) return void 0;
+    if (typeof value !== "number") throw new Error("{{value_must_be_a_number}}");
+    return value;
+  }
+  static clean(json) {
+    return (0, import_utils.deleteEmptyFields)(json);
+  }
+  constructor(props) {
+    this._id = _BaseEntity.toObjectId(props._id);
+    this.__v = _BaseEntity.toNumber(props.__v);
+    this.ownerId = _BaseEntity.toObjectId(props.ownerId);
+    this.createdAt = _BaseEntity.toDate(props.createdAt);
+    this.createdBy = _BaseEntity.toObjectId(props.createdBy);
+    this.updatedAt = _BaseEntity.toDate(props.updatedAt);
+    this.updatedBy = _BaseEntity.toObjectId(props.updatedBy);
+    this.deletedAt = _BaseEntity.toDate(props.deletedAt);
+    this.deletedBy = _BaseEntity.toObjectId(props.deletedBy);
+    this.deletedReason = (0, import_helpers.sanitizeString)(props.deletedReason);
+    this.archivedAt = _BaseEntity.toDate(props.archivedAt);
+    this.archivedBy = _BaseEntity.toObjectId(props.archivedBy);
+    this.sharedWith = props.sharedWith?.length ? props.sharedWith.map((id) => _BaseEntity.toObjectId(id)) : void 0;
+  }
+  toJSON() {
+    return {
+      _id: this._id,
+      __v: this.__v,
+      ownerId: this.ownerId,
+      createdAt: this.createdAt,
+      createdBy: this.createdBy,
+      updatedAt: this.updatedAt,
+      updatedBy: this.updatedBy,
+      deletedAt: this.deletedAt,
+      deletedBy: this.deletedBy,
+      deletedReason: this.deletedReason,
+      archivedAt: this.archivedAt,
+      archivedBy: this.archivedBy,
+      sharedWith: this.sharedWith?.length ? this.sharedWith.map((id) => id.toHexString()) : void 0,
+      toUnset: this.toUnset
+    };
+  }
+  setDefaults() {
+  }
+  setId(id) {
+    this._id = _BaseEntity.toObjectId(id);
+  }
+  setOwner(currentUser) {
+    if (!currentUser) return;
+    this.ownerId = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setCreatedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.createdAt = /* @__PURE__ */ new Date();
+    this.createdBy = _BaseEntity.toObjectId(currentUser.userId);
+    this.setDefaults();
+  }
+  setUpdatedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.updatedAt = /* @__PURE__ */ new Date();
+    this.updatedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setDeletedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.deletedAt = /* @__PURE__ */ new Date();
+    this.deletedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setArchivedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.archivedAt = /* @__PURE__ */ new Date();
+    this.archivedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  toDocument() {
+    return (0, import_utils.deleteEmptyFields)(this.toJSON());
+  }
+  toFlatDocument() {
+    const { toUnset, ...doc } = this.toDocument();
+    return { ...(0, import_utils.flattenObject)(doc), toUnset };
+  }
+  stringify() {
+    return JSON.stringify((0, import_decorators.handleMaskInLogs)(this), null, 2);
+  }
+  unset(fields) {
+    const toUnset = Array.from(new Set(fields.map((field) => String(field))));
+    if (!toUnset || !Array.isArray(toUnset)) return {};
+    this.toUnset = toUnset.reduce((acc, field) => {
+      acc[field] = "";
+      return acc;
+    }, {});
+    fields.forEach((field) => {
+      delete this[field];
+    });
+  }
+  sanitize(currentUser) {
+    if (!currentUser?.isAdmin()) {
+      for (const key in this) {
+        const isAdminOnly = Reflect.getMetadata("adminOnly", this.constructor.prototype, key);
+        if (isAdminOnly) {
+          delete this[key];
+        }
+      }
+    }
+  }
+};
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "__v", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "ownerId", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "createdAt", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "createdBy", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "updatedAt", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "updatedBy", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "deletedAt", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "deletedBy", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "archivedAt", 2);
+__decorateClass([
+  import_decorators.AdminOnly
+], _BaseEntity.prototype, "archivedBy", 2);
+__decorateClass([
+  import_decorators.OwnerOnly
+], _BaseEntity.prototype, "sharedWith", 2);
+let BaseEntity = _BaseEntity;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseEntity
+});

package/dist/common/core/base.entity.mjs

@@ -0,0 +1,179 @@
+import {
+  __decorateClass
+} from "../../chunk-XRJFNASX.mjs";
+import "reflect-metadata";
+import { ObjectId } from "bson";
+import { AdminOnly, OwnerOnly, handleMaskInLogs } from "@common/decorators";
+import { sanitizeString } from "@common/helpers";
+import { deleteEmptyFields, flattenObject } from "./utils";
+const _BaseEntity = class _BaseEntity {
+  _id;
+  __v;
+  ownerId;
+  createdAt;
+  createdBy;
+  updatedAt;
+  updatedBy;
+  deletedAt;
+  deletedBy;
+  deletedReason;
+  archivedAt;
+  archivedBy;
+  sharedWith;
+  toUnset;
+  static toObjectId(id) {
+    if (!id) return void 0;
+    if (id instanceof ObjectId) return id;
+    if (!ObjectId.isValid(id)) throw new Error(`Invalid ObjectId: ${id}`);
+    return new ObjectId(id);
+  }
+  static toDate(value) {
+    if (!value) return void 0;
+    const date = new Date(value);
+    if (isNaN(date.getTime())) throw new Error("{{value_must_be_a_date}}");
+    return date;
+  }
+  static toNumber(value) {
+    if (value === void 0 || value === null) return void 0;
+    if (typeof value !== "number") throw new Error("{{value_must_be_a_number}}");
+    return value;
+  }
+  static clean(json) {
+    return deleteEmptyFields(json);
+  }
+  constructor(props) {
+    this._id = _BaseEntity.toObjectId(props._id);
+    this.__v = _BaseEntity.toNumber(props.__v);
+    this.ownerId = _BaseEntity.toObjectId(props.ownerId);
+    this.createdAt = _BaseEntity.toDate(props.createdAt);
+    this.createdBy = _BaseEntity.toObjectId(props.createdBy);
+    this.updatedAt = _BaseEntity.toDate(props.updatedAt);
+    this.updatedBy = _BaseEntity.toObjectId(props.updatedBy);
+    this.deletedAt = _BaseEntity.toDate(props.deletedAt);
+    this.deletedBy = _BaseEntity.toObjectId(props.deletedBy);
+    this.deletedReason = sanitizeString(props.deletedReason);
+    this.archivedAt = _BaseEntity.toDate(props.archivedAt);
+    this.archivedBy = _BaseEntity.toObjectId(props.archivedBy);
+    this.sharedWith = props.sharedWith?.length ? props.sharedWith.map((id) => _BaseEntity.toObjectId(id)) : void 0;
+  }
+  toJSON() {
+    return {
+      _id: this._id,
+      __v: this.__v,
+      ownerId: this.ownerId,
+      createdAt: this.createdAt,
+      createdBy: this.createdBy,
+      updatedAt: this.updatedAt,
+      updatedBy: this.updatedBy,
+      deletedAt: this.deletedAt,
+      deletedBy: this.deletedBy,
+      deletedReason: this.deletedReason,
+      archivedAt: this.archivedAt,
+      archivedBy: this.archivedBy,
+      sharedWith: this.sharedWith?.length ? this.sharedWith.map((id) => id.toHexString()) : void 0,
+      toUnset: this.toUnset
+    };
+  }
+  setDefaults() {
+  }
+  setId(id) {
+    this._id = _BaseEntity.toObjectId(id);
+  }
+  setOwner(currentUser) {
+    if (!currentUser) return;
+    this.ownerId = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setCreatedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.createdAt = /* @__PURE__ */ new Date();
+    this.createdBy = _BaseEntity.toObjectId(currentUser.userId);
+    this.setDefaults();
+  }
+  setUpdatedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.updatedAt = /* @__PURE__ */ new Date();
+    this.updatedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setDeletedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.deletedAt = /* @__PURE__ */ new Date();
+    this.deletedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  setArchivedBy(currentUser) {
+    if (!currentUser) return;
+    this.sanitize(currentUser);
+    this.archivedAt = /* @__PURE__ */ new Date();
+    this.archivedBy = _BaseEntity.toObjectId(currentUser.userId);
+  }
+  toDocument() {
+    return deleteEmptyFields(this.toJSON());
+  }
+  toFlatDocument() {
+    const { toUnset, ...doc } = this.toDocument();
+    return { ...flattenObject(doc), toUnset };
+  }
+  stringify() {
+    return JSON.stringify(handleMaskInLogs(this), null, 2);
+  }
+  unset(fields) {
+    const toUnset = Array.from(new Set(fields.map((field) => String(field))));
+    if (!toUnset || !Array.isArray(toUnset)) return {};
+    this.toUnset = toUnset.reduce((acc, field) => {
+      acc[field] = "";
+      return acc;
+    }, {});
+    fields.forEach((field) => {
+      delete this[field];
+    });
+  }
+  sanitize(currentUser) {
+    if (!currentUser?.isAdmin()) {
+      for (const key in this) {
+        const isAdminOnly = Reflect.getMetadata("adminOnly", this.constructor.prototype, key);
+        if (isAdminOnly) {
+          delete this[key];
+        }
+      }
+    }
+  }
+};
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "__v", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "ownerId", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "createdAt", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "createdBy", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "updatedAt", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "updatedBy", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "deletedAt", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "deletedBy", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "archivedAt", 2);
+__decorateClass([
+  AdminOnly
+], _BaseEntity.prototype, "archivedBy", 2);
+__decorateClass([
+  OwnerOnly
+], _BaseEntity.prototype, "sharedWith", 2);
+let BaseEntity = _BaseEntity;
+export {
+  BaseEntity
+};

package/dist/common/core/base.use-case.d.ts

@@ -0,0 +1,15 @@
+import { CurrentUser, CurrentSession } from '@services/app/core';
+import { HttpError } from '@common/error';
+import { BaseApp } from './base.app';
+export interface BaseUseCaseParams {
+    currentUser?: CurrentUser;
+    currentSession?: CurrentSession;
+}
+export interface BaseUseCaseOutput {
+    message?: string;
+    data?: any;
+    error?: any;
+}
+export declare abstract class BaseUseCase<TReq, TRes> extends BaseApp {
+    abstract execute(params?: TReq): Promise<TRes | HttpError>;
+}

package/dist/common/core/base.use-case.js

@@ -0,0 +1,30 @@
+"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 base_use_case_exports = {};
+__export(base_use_case_exports, {
+  BaseUseCase: () => BaseUseCase
+});
+module.exports = __toCommonJS(base_use_case_exports);
+var import_base = require("./base.app");
+class BaseUseCase extends import_base.BaseApp {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseUseCase
+});

package/dist/common/core/base.use-case.mjs

@@ -0,0 +1,7 @@
+import "../../chunk-XRJFNASX.mjs";
+import { BaseApp } from "./base.app";
+class BaseUseCase extends BaseApp {
+}
+export {
+  BaseUseCase
+};

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

@@ -0,0 +1 @@
+export {};

package/dist/common/core/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/common/core/utils/delete-empty-fields.d.ts

@@ -0,0 +1 @@
+export declare function deleteEmptyFields(object: any): any;