@akanjs/nest 0.0.4

package/README.md

@@ -0,0 +1,11 @@
+# akan
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build akan` to build the library.
+
+## Running unit tests
+
+Run `nx test akan` to execute the unit tests via [Jest](https://jestjs.io).

package/index.d.ts

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

package/index.js

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

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@akanjs/nest",
+  "version": "0.0.4",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akan-team/akanjs.git",
+    "directory": "pkgs/@akanjs/nest"
+  },
+  "dependencies": {
+    "@apollo/server": "4.11.2",
+    "@inquirer/prompts": "7.2.1",
+    "@nestjs/apollo": "12.2.2",
+    "@nestjs/common": "10.4.15",
+    "@nestjs/core": "10.4.15",
+    "@nestjs/graphql": "12.2.2",
+    "@nestjs/passport": "10.0.3",
+    "@nestjs/platform-express": "10.4.15",
+    "@nestjs/platform-socket.io": "10.4.15",
+    "@nestjs/websockets": "10.4.15",
+    "@socket.io/redis-adapter": "8.3.0",
+    "@urql/core": "5.1.0",
+    "apple-signin": "1.0.9",
+    "bull": "4.16.5",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.14.1",
+    "dayjs": "1.11.13",
+    "express": "4.21.2",
+    "graphql": "16.10.0",
+    "iap": "1.1.1",
+    "immer": "10.1.1",
+    "jsonwebtoken": "9.0.2",
+    "mongoose": "8.9.3",
+    "next": "15.1.3",
+    "passport": "0.7.0",
+    "passport-apple": "2.0.2",
+    "passport-facebook": "3.0.0",
+    "passport-github": "1.1.0",
+    "passport-google-oauth20": "2.0.0",
+    "passport-kakao": "1.0.1",
+    "passport-naver": "1.0.6",
+    "picocolors": "1.1.1",
+    "pluralize": "8.0.0",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "redis": "4.7.0",
+    "reflect-metadata": "0.2.2",
+    "rxjs": "7.8.1",
+    "socket.io": "4.8.1",
+    "socket.io-client": "4.8.1",
+    "tunnel-ssh": "5.2.0",
+    "ua-parser-js": "1.0.40"
+  },
+  "main": "./index.js"
+}

package/src/authGuards.d.ts

@@ -0,0 +1,51 @@
+import type { Account as SerAccount } from "@akanjs/signal";
+import { CanActivate, ExecutionContext } from "@nestjs/common";
+import type { Socket } from "socket.io";
+export interface RequestContext {
+    account: SerAccount;
+    ip?: string;
+    userAgent?: string;
+    geolocation?: string;
+    headers: Record<string, string | undefined>;
+    cookies?: Record<string, string>;
+}
+export interface ReqType {
+    method: string;
+    url: string;
+    params: object;
+    query: object;
+    body: object;
+}
+export interface GqlReqType {
+    parentType?: {
+        name?: string;
+    };
+    fieldName?: string;
+}
+export declare const getRequest: (context: ExecutionContext) => unknown;
+export declare const getResponse: (context: ExecutionContext) => unknown;
+export declare const getArgs: (context: ExecutionContext) => {
+    [key: string]: any;
+};
+export declare const getSocket: (context: ExecutionContext) => Socket<import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, import("socket.io").DefaultEventsMap, any>;
+export declare class Public implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class None implements CanActivate {
+    canActivate(): boolean;
+}
+export declare class Every implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class Owner implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class Admin implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class SuperAdmin implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}
+export declare class User implements CanActivate {
+    canActivate(context: ExecutionContext): boolean;
+}

package/src/authGuards.js

@@ -0,0 +1,160 @@
+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 __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 __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 authGuards_exports = {};
+__export(authGuards_exports, {
+  Admin: () => Admin,
+  Every: () => Every,
+  None: () => None,
+  Owner: () => Owner,
+  Public: () => Public,
+  SuperAdmin: () => SuperAdmin,
+  User: () => User,
+  getArgs: () => getArgs,
+  getRequest: () => getRequest,
+  getResponse: () => getResponse,
+  getSocket: () => getSocket
+});
+module.exports = __toCommonJS(authGuards_exports);
+var import_common = require("@nestjs/common");
+var import_graphql = require("@nestjs/graphql");
+var Auth = __toESM(require("./authorization"));
+const getRequest = (context) => {
+  const type = context.getType();
+  if (type === "ws")
+    throw new Error("Getting Request in Websocket is not allowed");
+  return type === "http" ? context.switchToHttp().getRequest() : import_graphql.GqlExecutionContext.create(context).getContext().req;
+};
+const getResponse = (context) => {
+  const type = context.getType();
+  if (type === "ws")
+    throw new Error("Getting Response in Websocket is not allowed");
+  return type === "http" ? context.switchToHttp().getResponse() : import_graphql.GqlExecutionContext.create(context).getContext().req.res;
+};
+const getArgs = (context) => {
+  const type = context.getType();
+  if (type === "ws")
+    throw new Error("Getting Args in Websocket is not allowed");
+  if (type === "graphql")
+    return import_graphql.GqlExecutionContext.create(context).getArgs();
+  else if (type === "http") {
+    const { params, query, body } = context.switchToHttp().getRequest();
+    return { ...params, ...query, ...body };
+  } else
+    throw new Error("Getting Args in Unknown context is not allowed");
+};
+const getSocket = (context) => {
+  const type = context.getType();
+  if (type !== "ws")
+    throw new Error("Getting Socket in Http or GraphQL is not allowed");
+  const socket = context.getArgByIndex(0);
+  return socket;
+};
+let Public = class {
+  canActivate(context) {
+    return true;
+  }
+};
+Public = __decorateClass([
+  (0, import_common.Injectable)()
+], Public);
+let None = class {
+  canActivate() {
+    return false;
+  }
+};
+None = __decorateClass([
+  (0, import_common.Injectable)()
+], None);
+let Every = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["user", "admin", "superAdmin"]);
+  }
+};
+Every = __decorateClass([
+  (0, import_common.Injectable)()
+], Every);
+let Owner = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["user", "admin", "superAdmin"]);
+  }
+};
+Owner = __decorateClass([
+  (0, import_common.Injectable)()
+], Owner);
+let Admin = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["admin", "superAdmin"]);
+  }
+};
+Admin = __decorateClass([
+  (0, import_common.Injectable)()
+], Admin);
+let SuperAdmin = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["superAdmin"]);
+  }
+};
+SuperAdmin = __decorateClass([
+  (0, import_common.Injectable)()
+], SuperAdmin);
+let User = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["user"]);
+  }
+};
+User = __decorateClass([
+  (0, import_common.Injectable)()
+], User);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Admin,
+  Every,
+  None,
+  Owner,
+  Public,
+  SuperAdmin,
+  User,
+  getArgs,
+  getRequest,
+  getResponse,
+  getSocket
+});

package/src/authentication.d.ts

@@ -0,0 +1,18 @@
+export declare const Account: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const Self: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const Me: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const UserIp: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const Access: (...dataOrPipes: ({
+    nullable?: boolean;
+} | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const Req: (...dataOrPipes: unknown[]) => ParameterDecorator;
+export declare const Res: (...dataOrPipes: unknown[]) => ParameterDecorator;
+export declare const Ws: (...dataOrPipes: unknown[]) => ParameterDecorator;

package/src/authentication.js

@@ -0,0 +1,122 @@
+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 __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 authentication_exports = {};
+__export(authentication_exports, {
+  Access: () => Access,
+  Account: () => Account,
+  Me: () => Me,
+  Req: () => Req,
+  Res: () => Res,
+  Self: () => Self,
+  UserIp: () => UserIp,
+  Ws: () => Ws
+});
+module.exports = __toCommonJS(authentication_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@nestjs/common");
+var import_ua_parser_js = __toESM(require("ua-parser-js"));
+var import_authGuards = require("./authGuards");
+const Account = (0, import_common.createParamDecorator)((option, context) => {
+  const { account } = (0, import_authGuards.getRequest)(context);
+  return account;
+});
+const Self = (0, import_common.createParamDecorator)((option, context) => {
+  const { account } = (0, import_authGuards.getRequest)(context);
+  const self = account.self;
+  if (!self && !option.nullable)
+    throw new import_common.UnauthorizedException("No or Invalid Account in Self (User)");
+  return self;
+});
+const Me = (0, import_common.createParamDecorator)((option, context) => {
+  const { account } = (0, import_authGuards.getRequest)(context);
+  const me = account.me;
+  if (!me && !option.nullable)
+    throw new import_common.UnauthorizedException("No or Invalid Account in Me (Admin)");
+  return me;
+});
+const UserIp = (0, import_common.createParamDecorator)((option, context) => {
+  const req = (0, import_authGuards.getRequest)(context);
+  const ip = req.ip;
+  if (!ip && !option.nullable)
+    throw new import_common.UnauthorizedException("Invalid IP");
+  return { ip };
+});
+const Access = (0, import_common.createParamDecorator)((option, context) => {
+  const req = (0, import_authGuards.getRequest)(context);
+  const res = new import_ua_parser_js.default(req.userAgent).getResult();
+  if (!req.userAgent && !option.nullable)
+    throw new import_common.UnauthorizedException("Invalid UserAgent");
+  return {
+    ...req.geolocation ? JSON.parse(req.geolocation) : {},
+    osName: res.os.name,
+    osVersion: res.os.version,
+    browserName: res.browser.name,
+    browserVersion: res.browser.version,
+    mobileModel: res.device.model,
+    mobileVendor: res.device.vendor,
+    deviceType: res.device.type ?? "desktop",
+    at: (0, import_base.dayjs)(),
+    period: 0
+  };
+});
+const Req = (0, import_common.createParamDecorator)((option, context) => {
+  return (0, import_authGuards.getRequest)(context);
+});
+const Res = (0, import_common.createParamDecorator)((option, context) => {
+  return (0, import_authGuards.getResponse)(context);
+});
+const Ws = (0, import_common.createParamDecorator)((option, context) => {
+  const socket = context.getArgByIndex(0);
+  const { __subscribe__ } = context.getArgByIndex(1);
+  return {
+    socket,
+    subscribe: __subscribe__,
+    onDisconnect: (handler) => {
+      socket.on("disconnect", handler);
+    },
+    onSubscribe: (handler) => {
+      if (__subscribe__)
+        handler();
+    },
+    onUnsubscribe: (handler) => {
+      if (!__subscribe__)
+        handler();
+    }
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Access,
+  Account,
+  Me,
+  Req,
+  Res,
+  Self,
+  UserIp,
+  Ws
+});

package/src/authorization.d.ts

@@ -0,0 +1,3 @@
+import { Account } from "@akanjs/signal";
+export declare const verifyToken: (secret: string, authorization: string | undefined) => Account;
+export declare const allow: (account: Account | null, roles: ("user" | "admin" | "superAdmin")[], userId?: string) => boolean;

package/src/authorization.js

@@ -0,0 +1,79 @@
+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 __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 authorization_exports = {};
+__export(authorization_exports, {
+  allow: () => allow,
+  verifyToken: () => verifyToken
+});
+module.exports = __toCommonJS(authorization_exports);
+var import_base = require("@akanjs/base");
+var import_signal = require("@akanjs/signal");
+var import_apollo = require("@nestjs/apollo");
+var jwt = __toESM(require("jsonwebtoken"));
+const verifyToken = (secret, authorization) => {
+  const [type, token] = authorization?.split(" ") ?? [void 0, void 0];
+  if (!token || type !== "Bearer")
+    return import_signal.defaultAccount;
+  try {
+    const account = jwt.verify(token, secret);
+    if (account.appName !== import_base.baseEnv.appName || account.environment !== import_base.baseEnv.environment)
+      return import_signal.defaultAccount;
+    return {
+      __InternalArg__: "Account",
+      self: account.self && !account.self.removedAt ? account.self : void 0,
+      me: account.me && !account.me.removedAt ? account.me : void 0,
+      appName: account.appName,
+      environment: account.environment
+    };
+  } catch (e) {
+    return import_signal.defaultAccount;
+  }
+};
+const allow = (account, roles, userId) => {
+  if (!account)
+    throw new import_apollo.AuthenticationError("No Authentication Account");
+  for (const role of roles) {
+    if (role === "user" && account.self?.roles.includes("user"))
+      return true;
+    else if (role === "admin" && account.me?.roles.includes("admin"))
+      return true;
+    else if (role === "superAdmin" && account.me?.roles.includes("superAdmin"))
+      return true;
+  }
+  throw new import_apollo.AuthenticationError(
+    `No Authentication With Roles: ${roles.join(", ")}, Your roles are ${[
+      ...account.self?.roles ?? [],
+      ...account.me?.roles ?? []
+    ].join(", ")}${!account.self?.roles.length && !account.me?.roles.length ? " (No Roles)" : ""}`
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allow,
+  verifyToken
+});

package/src/exceptions.d.ts

@@ -0,0 +1,5 @@
+import { ArgumentsHost, ExceptionFilter } from "@nestjs/common";
+export declare class AllExceptionsFilter implements ExceptionFilter {
+    private readonly logger;
+    catch(exception: Error, host: ArgumentsHost): void;
+}

package/src/exceptions.js

@@ -0,0 +1,78 @@
+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 exceptions_exports = {};
+__export(exceptions_exports, {
+  AllExceptionsFilter: () => AllExceptionsFilter
+});
+module.exports = __toCommonJS(exceptions_exports);
+var import_common = require("@akanjs/common");
+var import_common2 = require("@nestjs/common");
+let AllExceptionsFilter = class {
+  logger = new import_common.Logger("Exception Filter");
+  catch(exception, host) {
+    if (host.getType() !== "http") {
+      const gqlArgs = host.getArgByIndex(1);
+      const gqlReq = host.getArgByIndex(3);
+      const reqType2 = gqlReq?.parentType?.name ?? "unknown";
+      const reqName2 = gqlReq?.fieldName ?? "unknown";
+      this.logger.error(
+        `GraphQL Error
+Request: ${reqType2}-${reqName2}
+Args: ${JSON.stringify(gqlArgs, null, 2)}
+${exception.stack}`
+      );
+      throw exception;
+    }
+    const ctx = host.switchToHttp();
+    const res = ctx.getResponse();
+    const req = ctx.getRequest();
+    const reqType = req.method;
+    const reqName = req.url;
+    const status = exception instanceof import_common2.HttpException ? exception.getStatus() : null;
+    if (status) {
+      res.status(status).json({
+        statusCode: status,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        path: req.url,
+        message: exception instanceof import_common2.HttpException ? exception.getResponse() : exception.message
+      });
+      this.logger.error(
+        `Http Error: ${status}
+Request: ${reqType}-${reqName}
+Body: ${JSON.stringify(req.body, null, 2)}
+${exception.stack}`
+      );
+    }
+  }
+};
+AllExceptionsFilter = __decorateClass([
+  (0, import_common2.Catch)()
+], AllExceptionsFilter);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AllExceptionsFilter
+});

package/src/exporter.d.ts

@@ -0,0 +1,22 @@
+import * as fs from "fs";
+export declare const objPath: (o: unknown, p: string) => unknown;
+export declare class FileSystem {
+    filename: string;
+    dirname: string;
+    writeStream?: fs.WriteStream;
+    constructor(dirname?: string, filename?: string);
+    init(): Promise<unknown>;
+    write(body: string): boolean;
+}
+export interface ExportForm<T> {
+    items: T[];
+    path: string;
+    fields?: string[];
+    options?: {
+        append: boolean;
+    };
+    delimiter?: string;
+}
+export declare const exportToCsv: <T>({ items, path, fields, delimiter, options }: ExportForm<T>) => Promise<void>;
+export declare const exportToJson: <T>(items: T | T[], localPath: string) => void;
+export declare const readJson: (localPath: string) => unknown;