@akanjs/nest 0.0.54 → 0.0.56

package/src/generateSecrets.mjs

@@ -0,0 +1,109 @@
+import { baseEnv } from "@akanjs/base";
+import { createHash } from "crypto";
+import { createTunnel } from "tunnel-ssh";
+const generateHexStringFromSeed = (seed, length = 256) => {
+  let hexString = "";
+  let currentSeed = seed;
+  while (hexString.length < length * 2) {
+    const hash = 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 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}.${baseEnv.serveDomain}`,
+    port: 32767,
+    username: baseEnv.tunnelUsername,
+    password: baseEnv.tunnelPassword
+  }
+}) => {
+  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 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}.${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}.${baseEnv.serveDomain}`;
+};
+const generateMeiliKey = ({ appName, environment }) => {
+  return `meilisearch-key-${appName}-${environment}`;
+};
+export {
+  SALT_ROUNDS,
+  generateAeskey,
+  generateHost,
+  generateJwtSecret,
+  generateMeiliKey,
+  generateMeiliUri,
+  generateMongoUri,
+  generateRedisUri
+};

package/src/index.mjs

@@ -0,0 +1,22 @@
+export * from "./authorization";
+export * from "./authGuards";
+import * as guards from "./authGuards";
+export * from "./authentication";
+export * from "./interceptors";
+export * from "./redis-io.adapter";
+export * from "./pipes";
+import * as Exporter from "./exporter";
+export * from "./exporter";
+export * from "./verifyPayment";
+export * from "./sso";
+export * from "./exceptions";
+export * from "./generateSecrets";
+export * from "./mongoose";
+export * from "./searchClient";
+export * from "./cacheClient";
+export * from "./databaseClient";
+export * from "./decorators";
+export {
+  Exporter,
+  guards
+};

package/src/interceptors.mjs

@@ -0,0 +1,169 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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 __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var _logger, _CACHE_PREFIX, _generateCacheKey, generateCacheKey_fn, _getCache, getCache_fn, _setCache, setCache_fn;
+import { Logger } from "@akanjs/common";
+import { getGqlMeta } from "@akanjs/signal";
+import {
+  Inject,
+  Injectable,
+  RequestTimeoutException
+} from "@nestjs/common";
+import { GqlExecutionContext } from "@nestjs/graphql";
+import { throwError, TimeoutError } from "rxjs";
+import { catchError, map, tap, timeout } from "rxjs/operators";
+import { getArgs, getRequest } from "./authGuards";
+let CacheInterceptor = class {
+  constructor(redis) {
+    this.redis = redis;
+    __privateAdd(this, _generateCacheKey);
+    __privateAdd(this, _getCache);
+    __privateAdd(this, _setCache);
+    __privateAdd(this, _logger, new Logger("CacheInterceptor"));
+    __privateAdd(this, _CACHE_PREFIX, "signal:");
+  }
+  async intercept(context, next) {
+    const handler = context.getHandler();
+    const signalKey = handler.name;
+    const gqlMeta = getGqlMeta(context.getClass(), signalKey);
+    if (gqlMeta.type !== "Query" || !gqlMeta.signalOption.cache) {
+      if (gqlMeta.signalOption.cache)
+        __privateGet(this, _logger).warn(`CacheInterceptor: ${signalKey} is not Query endpoint or cache is not set`);
+      return next.handle();
+    }
+    const args = getArgs(context);
+    const cacheKey = __privateMethod(this, _generateCacheKey, generateCacheKey_fn).call(this, signalKey, args);
+    const cachedData = await __privateMethod(this, _getCache, getCache_fn).call(this, cacheKey);
+    if (cachedData) {
+      __privateGet(this, _logger).debug(`Cache hit for key: ${cacheKey}`);
+      return next.handle().pipe(
+        map(() => cachedData),
+        catchError((error) => {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          __privateGet(this, _logger).error(`Error in cache interceptor for ${cacheKey}: ${errorMessage}`);
+          return throwError(() => error);
+        })
+      );
+    }
+    return next.handle().pipe(
+      map((data) => {
+        const cacheDuration = gqlMeta.signalOption.cache;
+        if (typeof cacheDuration === "number") {
+          void __privateMethod(this, _setCache, setCache_fn).call(this, cacheKey, data, cacheDuration);
+          __privateGet(this, _logger).debug(`Cache set for key: ${cacheKey}`);
+        }
+        return data;
+      }),
+      catchError((error) => {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        __privateGet(this, _logger).error(`Error in cache interceptor for ${cacheKey}: ${errorMessage}`);
+        return throwError(() => error);
+      })
+    );
+  }
+};
+_logger = new WeakMap();
+_CACHE_PREFIX = new WeakMap();
+_generateCacheKey = new WeakSet();
+generateCacheKey_fn = function(signalKey, args) {
+  return `${__privateGet(this, _CACHE_PREFIX)}${signalKey}:${JSON.stringify(args)}`;
+};
+_getCache = new WeakSet();
+getCache_fn = async function(key) {
+  try {
+    const cached = await this.redis.get(key);
+    if (!cached)
+      return null;
+    const { data } = JSON.parse(cached);
+    return data;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    __privateGet(this, _logger).error(`Error retrieving cache for key ${key}: ${errorMessage}`);
+    return null;
+  }
+};
+_setCache = new WeakSet();
+setCache_fn = async function(key, data, ttlMs) {
+  try {
+    const cacheData = { data, timestamp: Date.now() };
+    await this.redis.set(key, JSON.stringify(cacheData), { PX: ttlMs });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    __privateGet(this, _logger).error(`Error setting cache for key ${key}: ${errorMessage}`);
+  }
+};
+CacheInterceptor = __decorateClass([
+  Injectable(),
+  __decorateParam(0, Inject("REDIS_CLIENT"))
+], CacheInterceptor);
+let TimeoutInterceptor = class {
+  intercept(context, next) {
+    const gqlMeta = getGqlMeta(context.getClass(), context.getHandler().name);
+    const timeoutMs = gqlMeta.signalOption.timeout ?? 3e4;
+    if (timeoutMs === 0)
+      return next.handle();
+    return next.handle().pipe(
+      timeout(timeoutMs),
+      catchError((err) => {
+        if (err instanceof TimeoutError)
+          return throwError(() => new RequestTimeoutException());
+        return throwError(() => err);
+      })
+    );
+  }
+};
+TimeoutInterceptor = __decorateClass([
+  Injectable()
+], TimeoutInterceptor);
+let LoggingInterceptor = class {
+  logger = new Logger("IO");
+  intercept(context, next) {
+    const gqlReq = context.getArgByIndex(3);
+    const req = getRequest(context);
+    const reqType = gqlReq?.parentType?.name ?? req.method;
+    const reqName = gqlReq?.fieldName ?? req.url;
+    const before = Date.now();
+    const ip = GqlExecutionContext.create(context).getContext().req.ip;
+    this.logger.debug(`Before ${reqType}-${reqName} / ${ip} / ${before}`);
+    return next.handle().pipe(
+      tap(() => {
+        const after = Date.now();
+        this.logger.debug(`After  ${reqType}-${reqName} / ${ip} / ${after} (${after - before}ms)`);
+      })
+    );
+  }
+};
+LoggingInterceptor = __decorateClass([
+  Injectable()
+], LoggingInterceptor);
+export {
+  CacheInterceptor,
+  LoggingInterceptor,
+  TimeoutInterceptor
+};

package/src/mongoose.mjs

@@ -0,0 +1,60 @@
+import { Logger } from "@akanjs/common";
+import mongoose from "mongoose";
+const initMongoDB = ({
+  logging,
+  threshold = 5e3,
+  sendReport = false
+}) => {
+  const mongoDBLogger = new Logger("MongoDB");
+  if (logging)
+    mongoose.set("debug", function(collection, method, ...methodArgs) {
+      mongoDBLogger.verbose(
+        `${collection}.${method}(${methodArgs.slice(0, -1).map((arg) => JSON.stringify(arg)).join(", ")})`
+      );
+    });
+  const originalExec = mongoose.Query.prototype.exec;
+  const getQueryInfo = (queryAgent) => {
+    const model = queryAgent.model;
+    const collectionName = model.collection.collectionName;
+    const dbName = model.db.name;
+    const query = queryAgent.getQuery();
+    const queryOptions = queryAgent.getOptions();
+    return { dbName, collectionName, query, queryOptions };
+  };
+  mongoose.Query.prototype.exec = function(...args) {
+    const start = Date.now();
+    return originalExec.apply(this, args).then((result) => {
+      const duration = Date.now() - start;
+      const { dbName, collectionName, query, queryOptions } = getQueryInfo(this);
+      if (logging)
+        mongoDBLogger.verbose(
+          `Queried ${dbName}.${collectionName}.query(${JSON.stringify(query)}, ${JSON.stringify(
+            queryOptions
+          )}) - ${duration}ms`
+        );
+      return result;
+    });
+  };
+  const originalAggregate = mongoose.Model.aggregate;
+  const getAggregateInfo = (aggregateModel) => {
+    const dbName = aggregateModel.db.db?.databaseName ?? "unknown";
+    const collectionName = aggregateModel.collection.collectionName;
+    return { dbName, collectionName };
+  };
+  mongoose.Model.aggregate = function(...args) {
+    const startTime = Date.now();
+    return originalAggregate.apply(this, args).then((result) => {
+      const duration = Date.now() - startTime;
+      const { dbName, collectionName } = getAggregateInfo(this);
+      if (logging)
+        mongoDBLogger.verbose(
+          `Aggregated ${dbName}.${collectionName}.aggregate(${args.map((arg) => JSON.stringify(arg)).join(", ")}) - ${duration}ms`
+        );
+      return result;
+    });
+  };
+  mongoose.set("transactionAsyncLocalStorage", true);
+};
+export {
+  initMongoDB
+};

package/src/pipes.mjs

@@ -0,0 +1,118 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+import { dayjs, Float, getNonArrayModel, Int, isGqlScalar, JSON as GqlJSON } from "@akanjs/base";
+import { deserializeArg } from "@akanjs/signal";
+import { Injectable } from "@nestjs/common";
+import { Readable } from "stream";
+let ArrayifyPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value : value.split(",");
+  }
+};
+ArrayifyPipe = __decorateClass([
+  Injectable()
+], ArrayifyPipe);
+let IntPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(parseInt) : [parseInt(value)];
+  }
+};
+IntPipe = __decorateClass([
+  Injectable()
+], IntPipe);
+let FloatPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(parseFloat) : [parseFloat(value)];
+  }
+};
+FloatPipe = __decorateClass([
+  Injectable()
+], FloatPipe);
+let BooleanPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map((v) => Boolean(v)) : [Boolean(value)];
+  }
+};
+BooleanPipe = __decorateClass([
+  Injectable()
+], BooleanPipe);
+let DayjsPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(dayjs) : [dayjs(value)];
+  }
+};
+DayjsPipe = __decorateClass([
+  Injectable()
+], DayjsPipe);
+let JSONPipe = class {
+  transform(value, metadata) {
+    const transformable = typeof value === "string" && value.length;
+    const obj = transformable ? JSON.parse(atob(value)) : value;
+    return obj;
+  }
+};
+JSONPipe = __decorateClass([
+  Injectable()
+], JSONPipe);
+const convertToFileStream = (value) => ({
+  filename: value.originalname,
+  mimetype: value.mimetype,
+  encoding: value.encoding,
+  createReadStream: () => Readable.from(value.buffer)
+});
+let MulterToUploadPipe = class {
+  transform(value, metadata) {
+    return Array.isArray(value) ? value.map(convertToFileStream) : convertToFileStream(value);
+  }
+};
+MulterToUploadPipe = __decorateClass([
+  Injectable()
+], MulterToUploadPipe);
+const gqlScalarPipeMap = /* @__PURE__ */ new Map([
+  [Int, IntPipe],
+  [Float, FloatPipe],
+  [Boolean, BooleanPipe],
+  [Date, DayjsPipe],
+  [GqlJSON, JSONPipe]
+]);
+const getQueryPipes = (modelRef, arrDepth) => {
+  const pipes = arrDepth ? [ArrayifyPipe] : [];
+  const scalarPipe = gqlScalarPipeMap.get(modelRef);
+  if (scalarPipe)
+    pipes.push(scalarPipe);
+  return pipes;
+};
+const getBodyPipes = (argMeta) => {
+  const [returnRef] = getNonArrayModel(argMeta.returns());
+  if (returnRef.prototype !== Date.prototype && !isGqlScalar(returnRef))
+    return [];
+  let BodyPipe = class {
+    transform(value, metadata) {
+      return deserializeArg(argMeta, value);
+    }
+  };
+  BodyPipe = __decorateClass([
+    Injectable()
+  ], BodyPipe);
+  return [BodyPipe];
+};
+export {
+  ArrayifyPipe,
+  BooleanPipe,
+  DayjsPipe,
+  FloatPipe,
+  IntPipe,
+  JSONPipe,
+  MulterToUploadPipe,
+  getBodyPipes,
+  getQueryPipes
+};

package/src/redis-io.adapter.mjs

@@ -0,0 +1,61 @@
+import { Logger, sleep } from "@akanjs/common";
+import { IoAdapter } from "@nestjs/platform-socket.io";
+import { createAdapter } from "@socket.io/redis-adapter";
+import { createClient } from "redis";
+class RedisIoAdapter extends IoAdapter {
+  adapterConstructor;
+  logger = new Logger("RedisIoAdapter");
+  server;
+  pubClient;
+  subClient;
+  option;
+  constructor(appOrHttpServer, option) {
+    super(appOrHttpServer);
+    this.option = option;
+  }
+  async connectToRedis(url) {
+    this.pubClient = createClient({ url });
+    this.subClient = this.pubClient.duplicate();
+    this.pubClient.on("disconnect", (err) => {
+      this.logger.error(`Redis pub database is disconnected. Error: ${err}`);
+      void this.pubClient.connect();
+    });
+    this.subClient.on("disconnect", (err) => {
+      this.logger.error(`Redis sub database is disconnected. Error: ${err}`);
+      void this.subClient.connect();
+    });
+    this.pubClient.on("error", (err) => {
+      this.logger.error(`Redis pub database is errored. Error: ${err}`);
+      const reconnect = async () => {
+        await this.pubClient.quit();
+        await sleep(1e3);
+        await this.pubClient.connect();
+      };
+      void reconnect();
+    });
+    this.subClient.on("error", (err) => {
+      this.logger.error(`Redis sub database is errored. Error: ${err}`);
+      const reconnect = async () => {
+        await this.subClient.quit();
+        await sleep(1e3);
+        await this.subClient.connect();
+      };
+      void reconnect();
+    });
+    await Promise.all([this.pubClient.connect(), this.subClient.connect()]);
+    this.adapterConstructor = createAdapter(this.pubClient, this.subClient);
+  }
+  createIOServer(port, options) {
+    this.server = super.createIOServer(port, options);
+    this.server.adapter(this.adapterConstructor);
+    return this.server;
+  }
+  async destroy() {
+    await Promise.all([this.pubClient.quit(), this.subClient.quit()]);
+    await this.close(this.server);
+    this.logger.log("RedisIoAdapter is closed");
+  }
+}
+export {
+  RedisIoAdapter
+};

package/src/searchClient.mjs

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+import { DEFAULT_PAGE_SIZE } from "@akanjs/constant";
+import { Inject, Injectable } from "@nestjs/common";
+let SearchClient = class {
+  meili;
+  async getIndexNames() {
+    const { results } = await this.meili.getIndexes({ limit: 1e3 });
+    return results.map((index) => index.uid);
+  }
+  async getSearchResult(indexName, option) {
+    const { skip = 0, limit = DEFAULT_PAGE_SIZE, sort = "", searchString } = option;
+    if (!searchString) {
+      const { results, total } = await this.meili.index(indexName).getDocuments({ offset: skip, limit });
+      return { docs: results, skip, limit, sort, total };
+    }
+    const { hits, estimatedTotalHits } = await this.meili.index(indexName).search(searchString, { offset: skip, limit });
+    return { docs: hits, skip, limit, sort, total: estimatedTotalHits, query: searchString };
+  }
+  async upsertDocuments(indexName, documents) {
+    const task = await this.meili.index(indexName).addDocuments(documents);
+    return task;
+  }
+  async dropIndex(indexName) {
+    const task = await this.meili.index(indexName).delete();
+    return task;
+  }
+};
+__decorateClass([
+  Inject("MEILI_CLIENT")
+], SearchClient.prototype, "meili", 2);
+SearchClient = __decorateClass([
+  Injectable()
+], SearchClient);
+export {
+  SearchClient
+};