@akanjs/nest 0.0.4

package/src/exporter.js

@@ -0,0 +1,113 @@
+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 exporter_exports = {};
+__export(exporter_exports, {
+  FileSystem: () => FileSystem,
+  exportToCsv: () => exportToCsv,
+  exportToJson: () => exportToJson,
+  objPath: () => objPath,
+  readJson: () => readJson
+});
+module.exports = __toCommonJS(exporter_exports);
+var fs = __toESM(require("fs"));
+const objPath = (o, p) => p.split(".").reduce((a, v) => a[v], o);
+class FileSystem {
+  filename = "";
+  dirname = "./";
+  writeStream;
+  constructor(dirname = "./", filename = "") {
+    this.dirname = dirname;
+    this.filename = filename;
+  }
+  async init() {
+    return new Promise((resolve, reject) => {
+      fs.mkdirSync(this.dirname, { recursive: true });
+      const writeStream = fs.createWriteStream(`${this.dirname}/${this.filename}.csv`);
+      if (!writeStream) {
+        reject(new Error("No WriteStream"));
+        return;
+      }
+      writeStream.once(`open`, () => {
+        this.writeStream = writeStream;
+        resolve(writeStream);
+      });
+    });
+  }
+  write(body) {
+    if (!this.writeStream)
+      throw new Error("no write stream");
+    return this.writeStream.write(`${body.replace(/\n/g, "")}
+`);
+  }
+  // async finish() {}
+}
+const exportToCsv = async ({ items, path, fields, delimiter, options }) => {
+  return new Promise((resolve, reject) => {
+    const dirs = path.split("/");
+    if (dirs.length > 1) {
+      const dirname = dirs.slice(-1).join("/");
+      if (!fs.existsSync(dirname))
+        fs.mkdirSync(dirname, { recursive: true });
+    }
+    if (!fields)
+      throw new Error("Fields Required");
+    const writeStream = !options?.append && fs.createWriteStream(path);
+    const header = fields.reduce((acc, cur) => acc + (delimiter ?? `,`) + cur) + `
+`;
+    if (!writeStream) {
+      reject(new Error("No WriteStream"));
+      return;
+    }
+    writeStream.once(`open`, () => {
+      writeStream.write(header);
+      for (const item of items) {
+        const data = fields.map((field) => objPath(item, field) || null).map((field) => String(field).replace(/\n/g, "").replace(/,/g, ""));
+        const body = data.reduce((acc, cur) => acc + (delimiter ?? `,`) + cur) + `
+`;
+        if (options?.append)
+          fs.appendFileSync(path, body);
+      }
+      resolve();
+    });
+  });
+};
+const exportToJson = (items, localPath) => {
+  const dirname = localPath.split("/").slice(0, -1).join("/");
+  if (!fs.existsSync(dirname))
+    fs.mkdirSync(dirname, { recursive: true });
+  fs.writeFileSync(localPath, JSON.stringify(items));
+};
+const readJson = (localPath) => JSON.parse(fs.readFileSync(localPath).toString("utf-8"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileSystem,
+  exportToCsv,
+  exportToJson,
+  objPath,
+  readJson
+});

package/src/generateSecrets.d.ts

@@ -0,0 +1,36 @@
+import { BackendEnv, type BaseEnv } from "@akanjs/base";
+import { SshOptions } from "tunnel-ssh";
+export declare const generateJwtSecret: (appName: string, environment: "debug" | "develop" | "main" | "testing") => string;
+export declare const generateAeskey: (appName: string, environment: "debug" | "develop" | "main" | "testing") => string;
+interface RedisEnv {
+    appName: string;
+    appCode: number;
+    environment: BaseEnv["environment"];
+    operationMode: BaseEnv["operationMode"];
+    sshOptions?: SshOptions;
+}
+export declare const generateRedisUri: ({ appName, appCode, environment, operationMode, sshOptions }: RedisEnv) => Promise<string>;
+interface MongoEnv {
+    appName: string;
+    appCode: number;
+    environment: BaseEnv["environment"];
+    operationMode: BaseEnv["operationMode"];
+    username?: string;
+    password?: string;
+    sshOptions?: SshOptions;
+}
+export declare const generateMongoUri: ({ appName, appCode, environment, operationMode, username, password, sshOptions, }: MongoEnv) => Promise<string>;
+interface MeiliEnv {
+    appName: string;
+    appCode: number;
+    environment: BaseEnv["environment"];
+    operationMode: BaseEnv["operationMode"];
+}
+export declare const generateMeiliUri: ({ appName, appCode, environment, operationMode }: MeiliEnv) => string;
+export declare const SALT_ROUNDS = 11;
+export declare const generateHost: (env: BackendEnv) => string;
+export declare const generateMeiliKey: ({ appName, environment }: {
+    appName: string;
+    environment: string;
+}) => string;
+export {};

package/src/generateSecrets.js

@@ -0,0 +1,139 @@
+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 generateSecrets_exports = {};
+__export(generateSecrets_exports, {
+  SALT_ROUNDS: () => SALT_ROUNDS,
+  generateAeskey: () => generateAeskey,
+  generateHost: () => generateHost,
+  generateJwtSecret: () => generateJwtSecret,
+  generateMeiliKey: () => generateMeiliKey,
+  generateMeiliUri: () => generateMeiliUri,
+  generateMongoUri: () => generateMongoUri,
+  generateRedisUri: () => generateRedisUri
+});
+module.exports = __toCommonJS(generateSecrets_exports);
+var import_base = require("@akanjs/base");
+var import_crypto = require("crypto");
+var import_tunnel_ssh = require("tunnel-ssh");
+const generateHexStringFromSeed = (seed, length = 256) => {
+  let hexString = "";
+  let currentSeed = seed;
+  while (hexString.length < length * 2) {
+    const hash = (0, import_crypto.createHash)("sha256").update(currentSeed).digest("hex");
+    hexString += hash;
+    currentSeed = hash;
+  }
+  return hexString.substring(0, length * 2);
+};
+const generateJwtSecret = (appName, environment) => {
+  const seed = `${appName}-${environment}-jwt-secret`;
+  return generateHexStringFromSeed(seed);
+};
+const generateAeskey = (appName, environment) => {
+  const seed = `${appName}-${environment}-aes-key`;
+  return (0, import_crypto.createHash)("sha256").update(seed).digest("hex");
+};
+const DEFAULT_CLOUD_PORT = 3e4;
+const getEnvironmentPort = (environment) => environment === "main" ? 2e3 : environment === "develop" ? 1e3 : environment === "debug" ? 0 : 0;
+const getServicePort = (appCode, service) => (service === "redis" ? 300 : service === "mongo" ? 400 : 500) + appCode % 10 * 10 + (appCode >= 10 ? 5 : 0);
+const createDatabaseTunnel = async ({
+  appName,
+  environment,
+  type,
+  port,
+  sshOptions = {
+    host: `${appName}-${environment}.${import_base.baseEnv.serveDomain}`,
+    port: 32767,
+    username: "root",
+    password: import_base.baseEnv.repoName
+  }
+}) => {
+  const tunnelOptions = { autoClose: true, reconnectOnError: false };
+  const serverOptions = { port };
+  const forwardOptions = {
+    srcAddr: "0.0.0.0",
+    srcPort: port,
+    dstAddr: `${type}-0.${type}-svc.${appName}-${environment}`,
+    dstPort: type === "mongo" ? 27017 : type === "redis" ? 6379 : 7700
+  };
+  const [server, client] = await (0, import_tunnel_ssh.createTunnel)(tunnelOptions, serverOptions, sshOptions, forwardOptions);
+  return `localhost:${port}`;
+};
+const generateRedisUri = async ({ appName, appCode, environment, operationMode, sshOptions }) => {
+  if (process.env.REDIS_URI)
+    return process.env.REDIS_URI;
+  const port = operationMode === "local" ? DEFAULT_CLOUD_PORT + getEnvironmentPort(environment) + getServicePort(appCode, "redis") : 6379;
+  const url = operationMode === "cloud" ? `redis-svc.${appName}-${environment}.svc.cluster.local` : operationMode === "local" ? await createDatabaseTunnel({ appName, environment, type: "redis", port, sshOptions }) : "localhost:6379";
+  const uri = `redis://${url}`;
+  return uri;
+};
+const generateMongoUri = async ({
+  appName,
+  appCode,
+  environment,
+  operationMode,
+  username = `${appName}-${environment}-mongo-user`,
+  password,
+  sshOptions
+}) => {
+  if (process.env.MONGO_URI)
+    return process.env.MONGO_URI;
+  const record = operationMode === "cloud" ? "mongodb+srv" : "mongodb";
+  const port = operationMode === "local" ? DEFAULT_CLOUD_PORT + getEnvironmentPort(environment) + getServicePort(appCode, "mongo") : 27017;
+  const url = operationMode === "cloud" ? `mongo-svc.${appName}-${environment}.svc.cluster.local` : operationMode === "local" ? await createDatabaseTunnel({ appName, environment, type: "mongo", port, sshOptions }) : "localhost:27017";
+  const usernameEncoded = password ? encodeURIComponent(username) : null;
+  const passwordEncoded = password ? encodeURIComponent(password) : null;
+  const dbName = `${appName}-${environment}`;
+  const directConnection = operationMode === "cloud" ? false : true;
+  const authInfo = usernameEncoded ? `${usernameEncoded}:${passwordEncoded}@` : "";
+  const uri = `${record}://${authInfo}${url}/${dbName}?authSource=${dbName}&readPreference=primary&ssl=false&retryWrites=true&directConnection=${directConnection}`;
+  return uri;
+};
+const generateMeiliUri = ({ appName, appCode, environment, operationMode }) => {
+  if (process.env.MEILI_URI)
+    return process.env.MEILI_URI;
+  const protocol = operationMode === "local" ? "https" : "http";
+  const url = operationMode === "cloud" ? `meili-0.meili-svc.${appName}-${environment}.svc.cluster.local:7700` : operationMode === "local" ? `${appName}-${environment}.${import_base.baseEnv.serveDomain}/search` : "localhost:7700";
+  const uri = `${protocol}://${url}`;
+  return uri;
+};
+const SALT_ROUNDS = 11;
+const generateHost = (env) => {
+  if (process.env.HOST_NAME)
+    return process.env.HOST_NAME;
+  else if (env.hostname)
+    return env.hostname;
+  else if (env.operationMode === "local")
+    return "localhost";
+  else
+    return `${env.appName}-${env.environment}.${import_base.baseEnv.serveDomain}`;
+};
+const generateMeiliKey = ({ appName, environment }) => {
+  return `meilisearch-key-${appName}-${environment}`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SALT_ROUNDS,
+  generateAeskey,
+  generateHost,
+  generateJwtSecret,
+  generateMeiliKey,
+  generateMeiliUri,
+  generateMongoUri,
+  generateRedisUri
+});

package/src/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./authorization";
+export * from "./authGuards";
+export * as guards from "./authGuards";
+export * from "./authentication";
+export * from "./interceptors";
+export * as Inquirer from "./inquirer";
+export * from "./redis-io.adapter";
+export * from "./pipes";
+export * as Exporter from "./exporter";
+export * from "./exporter";
+export * from "./verifyPayment";
+export * from "./sso";
+export * from "./exceptions";
+export * from "./generateSecrets";
+export * from "./mongoose";

package/src/index.js

@@ -0,0 +1,68 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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 src_exports = {};
+__export(src_exports, {
+  Exporter: () => Exporter,
+  Inquirer: () => Inquirer,
+  guards: () => guards
+});
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./authorization"), module.exports);
+__reExport(src_exports, require("./authGuards"), module.exports);
+var guards = __toESM(require("./authGuards"));
+__reExport(src_exports, require("./authentication"), module.exports);
+__reExport(src_exports, require("./interceptors"), module.exports);
+var Inquirer = __toESM(require("./inquirer"));
+__reExport(src_exports, require("./redis-io.adapter"), module.exports);
+__reExport(src_exports, require("./pipes"), module.exports);
+var Exporter = __toESM(require("./exporter"));
+__reExport(src_exports, require("./exporter"), module.exports);
+__reExport(src_exports, require("./verifyPayment"), module.exports);
+__reExport(src_exports, require("./sso"), module.exports);
+__reExport(src_exports, require("./exceptions"), module.exports);
+__reExport(src_exports, require("./generateSecrets"), module.exports);
+__reExport(src_exports, require("./mongoose"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Exporter,
+  Inquirer,
+  guards,
+  ...require("./authorization"),
+  ...require("./authGuards"),
+  ...require("./authentication"),
+  ...require("./interceptors"),
+  ...require("./redis-io.adapter"),
+  ...require("./pipes"),
+  ...require("./exporter"),
+  ...require("./verifyPayment"),
+  ...require("./sso"),
+  ...require("./exceptions"),
+  ...require("./generateSecrets"),
+  ...require("./mongoose")
+});

package/src/inquirer.d.ts

@@ -0,0 +1,20 @@
+interface ChoiceType {
+    color?: string;
+    name: string;
+    value: string;
+}
+interface NumberChoiceType {
+    color?: string;
+    name: string;
+    value: string;
+}
+export declare const input: (message: string) => Promise<string>;
+export declare const select: (message: string, choices: ChoiceType[]) => Promise<string>;
+export declare const confirm: (message: string) => Promise<boolean>;
+export declare const checkbox: (message: string, choices: ChoiceType[]) => Promise<string[]>;
+export declare const editor: (message: string) => Promise<string>;
+export declare const number: (message: string) => Promise<number | undefined>;
+export declare const rawlist: (message: string, choices: NumberChoiceType[]) => Promise<string>;
+export declare const password: (message: string) => Promise<string>;
+export declare const expand: (message: string, choices: ChoiceType[]) => Promise<string>;
+export {};

package/src/inquirer.js

@@ -0,0 +1,114 @@
+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 inquirer_exports = {};
+__export(inquirer_exports, {
+  checkbox: () => checkbox,
+  confirm: () => confirm,
+  editor: () => editor,
+  expand: () => expand,
+  input: () => input,
+  number: () => number,
+  password: () => password,
+  rawlist: () => rawlist,
+  select: () => select
+});
+module.exports = __toCommonJS(inquirer_exports);
+var import_prompts = require("@inquirer/prompts");
+var import_picocolors = __toESM(require("picocolors"));
+const input = async (message) => {
+  return await (0, import_prompts.input)({ message });
+};
+const select = async (message, choices) => {
+  return await (0, import_prompts.select)({
+    message,
+    choices: choices.map((choice) => {
+      return {
+        name: choice.color ? import_picocolors.default.bgRed(import_picocolors.default.white(choice.name)) : choice.name,
+        value: choice.value
+      };
+    })
+  });
+};
+const confirm = async (message) => {
+  return await (0, import_prompts.confirm)({ message });
+};
+const checkbox = async (message, choices) => {
+  return await (0, import_prompts.checkbox)({
+    message,
+    choices: choices.map((choice) => {
+      return {
+        name: choice.color ? import_picocolors.default.bgRed(import_picocolors.default.white(choice.name)) : choice.name,
+        value: choice.value
+      };
+    })
+  });
+};
+const editor = async (message) => {
+  return await (0, import_prompts.editor)({ message });
+};
+const number = async (message) => {
+  return await (0, import_prompts.number)({ message });
+};
+const rawlist = async (message, choices) => {
+  return await (0, import_prompts.rawlist)({
+    message,
+    choices: choices.map((choice) => {
+      return {
+        name: choice.color ? import_picocolors.default.bgRed(import_picocolors.default.white(choice.name)) : choice.name,
+        value: choice.value
+      };
+    })
+  });
+};
+const password = async (message) => {
+  return await (0, import_prompts.password)({ message });
+};
+const expand = async (message, choices) => {
+  return await (0, import_prompts.expand)({
+    message,
+    choices: choices.map((choice) => {
+      return {
+        key: choice.value,
+        name: choice.color ? import_picocolors.default.bgRed(import_picocolors.default.white(choice.name)) : choice.name,
+        value: choice.value
+      };
+    })
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkbox,
+  confirm,
+  editor,
+  expand,
+  input,
+  number,
+  password,
+  rawlist,
+  select
+});

package/src/interceptors.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from "@akanjs/common";
+import { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
+import type { RedisClientType } from "redis";
+import { Observable } from "rxjs";
+export declare class CacheInterceptor implements NestInterceptor {
+    private redis;
+    logger: Logger;
+    constructor(redis: RedisClientType);
+    setCache(key: string, value: any, expire: number): Promise<void>;
+    getCache<T = object>(key: string): Promise<T | null>;
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}
+export declare class TimeoutInterceptor implements NestInterceptor {
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}
+export declare class LoggingInterceptor implements NestInterceptor {
+    logger: Logger;
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+}

package/src/interceptors.js

@@ -0,0 +1,132 @@
+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, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, 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 __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+var interceptors_exports = {};
+__export(interceptors_exports, {
+  CacheInterceptor: () => CacheInterceptor,
+  LoggingInterceptor: () => LoggingInterceptor,
+  TimeoutInterceptor: () => TimeoutInterceptor
+});
+module.exports = __toCommonJS(interceptors_exports);
+var import_common = require("@akanjs/common");
+var import_signal = require("@akanjs/signal");
+var import_common2 = require("@nestjs/common");
+var import_graphql = require("@nestjs/graphql");
+var import_rxjs = require("rxjs");
+var import_operators = require("rxjs/operators");
+var import_authGuards = require("./authGuards");
+let CacheInterceptor = class {
+  constructor(redis) {
+    this.redis = redis;
+  }
+  logger = new import_common.Logger("CacheInterceptor");
+  async setCache(key, value, expire) {
+    await this.redis.set(key, JSON.stringify(value), { PX: expire });
+  }
+  async getCache(key) {
+    const cached = await this.redis.get(key);
+    return cached ? JSON.parse(cached) : null;
+  }
+  intercept(context, next) {
+    const signalKey = context.getHandler().name;
+    const gqlMeta = (0, import_signal.getGqlMeta)(context.getClass(), signalKey);
+    const cacheExpireMs = gqlMeta.signalOption.cache;
+    if (gqlMeta.type !== "Query" || !cacheExpireMs) {
+      if (cacheExpireMs)
+        this.logger.warn(`CacheInterceptor: ${signalKey} is not Query endpoint or cache is not set`);
+      return next.handle();
+    }
+    const args = (0, import_authGuards.getArgs)(context);
+    const cacheKey = `signal:${signalKey}:${JSON.stringify(args)}`;
+    const cacheResult$ = (0, import_rxjs.from)(this.getCache(cacheKey));
+    return (0, import_rxjs.forkJoin)([cacheResult$]).pipe(
+      (0, import_rxjs.switchMap)(([cacheResult]) => {
+        if (cacheResult) {
+          this.logger.trace(`CacheHit-${cacheKey}`);
+          return (0, import_rxjs.of)(cacheResult);
+        } else
+          return next.handle().pipe(
+            (0, import_rxjs.map)((resData) => {
+              void this.setCache(cacheKey, resData, cacheExpireMs);
+              this.logger.trace(`CacheSet-${cacheKey}`);
+              return resData;
+            })
+          );
+      })
+    );
+  }
+};
+CacheInterceptor = __decorateClass([
+  (0, import_common2.Injectable)(),
+  __decorateParam(0, (0, import_common2.Inject)("REDIS_CLIENT"))
+], CacheInterceptor);
+let TimeoutInterceptor = class {
+  intercept(context, next) {
+    const gqlMeta = (0, import_signal.getGqlMeta)(context.getClass(), context.getHandler().name);
+    const timeoutMs = gqlMeta.signalOption.timeout ?? 3e4;
+    if (timeoutMs === 0)
+      return next.handle();
+    return next.handle().pipe(
+      (0, import_operators.timeout)(timeoutMs),
+      (0, import_operators.catchError)((err) => {
+        if (err instanceof import_rxjs.TimeoutError)
+          return (0, import_rxjs.throwError)(() => new import_common2.RequestTimeoutException());
+        return (0, import_rxjs.throwError)(() => err);
+      })
+    );
+  }
+};
+TimeoutInterceptor = __decorateClass([
+  (0, import_common2.Injectable)()
+], TimeoutInterceptor);
+let LoggingInterceptor = class {
+  logger = new import_common.Logger("IO");
+  intercept(context, next) {
+    const gqlReq = context.getArgByIndex(3);
+    const req = (0, import_authGuards.getRequest)(context);
+    const reqType = gqlReq?.parentType?.name ?? req.method;
+    const reqName = gqlReq?.fieldName ?? req.url;
+    const before = Date.now();
+    const ip = import_graphql.GqlExecutionContext.create(context).getContext().req.ip;
+    this.logger.debug(`Before ${reqType}-${reqName} / ${ip} / ${before}`);
+    return next.handle().pipe(
+      (0, import_operators.tap)(() => {
+        const after = Date.now();
+        this.logger.debug(`After  ${reqType}-${reqName} / ${ip} / ${after} (${after - before}ms)`);
+      })
+    );
+  }
+};
+LoggingInterceptor = __decorateClass([
+  (0, import_common2.Injectable)()
+], LoggingInterceptor);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheInterceptor,
+  LoggingInterceptor,
+  TimeoutInterceptor
+});

package/src/mongoose.d.ts

@@ -0,0 +1,5 @@
+export declare const initMongoDB: ({ logging, threshold, sendReport, }: {
+    logging: boolean;
+    threshold?: number;
+    sendReport?: boolean;
+}) => void;