@akanjs/nest 0.0.53 → 0.0.55

package/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/nest",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -38,5 +38,11 @@
     "rxjs": "^7.8.1",
     "tunnel-ssh": "^5.2.0",
     "ua-parser-js": "^1.0.40"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
   }
 }

package/src/authGuards.mjs

@@ -0,0 +1,119 @@
+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 { Injectable } from "@nestjs/common";
+import { GqlExecutionContext } from "@nestjs/graphql";
+import * as Auth from "./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() : 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() : 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 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([
+  Injectable()
+], Public);
+let None = class {
+  canActivate() {
+    return false;
+  }
+};
+None = __decorateClass([
+  Injectable()
+], None);
+let Every = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["user", "admin", "superAdmin"]);
+  }
+};
+Every = __decorateClass([
+  Injectable()
+], Every);
+let Owner = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["user", "admin", "superAdmin"]);
+  }
+};
+Owner = __decorateClass([
+  Injectable()
+], Owner);
+let Admin = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["admin", "superAdmin"]);
+  }
+};
+Admin = __decorateClass([
+  Injectable()
+], Admin);
+let SuperAdmin = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["superAdmin"]);
+  }
+};
+SuperAdmin = __decorateClass([
+  Injectable()
+], SuperAdmin);
+let User = class {
+  canActivate(context) {
+    const { account } = getRequest(context);
+    return Auth.allow(account, ["user"]);
+  }
+};
+User = __decorateClass([
+  Injectable()
+], User);
+export {
+  Admin,
+  Every,
+  None,
+  Owner,
+  Public,
+  SuperAdmin,
+  User,
+  getArgs,
+  getRequest,
+  getResponse,
+  getSocket
+};

package/src/authentication.mjs

@@ -0,0 +1,82 @@
+import { dayjs } from "@akanjs/base";
+import { createParamDecorator, UnauthorizedException } from "@nestjs/common";
+import UAParser from "ua-parser-js";
+import { getRequest, getResponse } from "./authGuards";
+const Account = createParamDecorator((option, context) => {
+  const { account } = getRequest(context);
+  return account;
+});
+const Self = createParamDecorator((option, context) => {
+  const { account } = getRequest(context);
+  const self = account.self;
+  if (!self && !option.nullable)
+    throw new UnauthorizedException("No or Invalid Account in Self (User)");
+  return self;
+});
+const Me = createParamDecorator((option, context) => {
+  const { account } = getRequest(context);
+  const me = account.me;
+  if (!me && !option.nullable)
+    throw new UnauthorizedException("No or Invalid Account in Me (Admin)");
+  return me;
+});
+const UserIp = createParamDecorator((option, context) => {
+  const req = getRequest(context);
+  const ip = req.ip;
+  if (!ip && !option.nullable)
+    throw new UnauthorizedException("Invalid IP");
+  return { ip };
+});
+const Access = createParamDecorator((option, context) => {
+  const req = getRequest(context);
+  const res = new UAParser(req.userAgent).getResult();
+  if (!req.userAgent && !option.nullable)
+    throw new 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: dayjs(),
+    period: 0
+  };
+});
+const Req = createParamDecorator((option, context) => {
+  return getRequest(context);
+});
+const Res = createParamDecorator((option, context) => {
+  return getResponse(context);
+});
+const Ws = 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();
+    }
+  };
+});
+export {
+  Access,
+  Account,
+  Me,
+  Req,
+  Res,
+  Self,
+  UserIp,
+  Ws
+};

package/src/authorization.mjs

@@ -0,0 +1,45 @@
+import { baseEnv } from "@akanjs/base";
+import { defaultAccount } from "@akanjs/signal";
+import { AuthenticationError } from "@nestjs/apollo";
+import * as jwt from "jsonwebtoken";
+const verifyToken = (secret, authorization) => {
+  const [type, token] = authorization?.split(" ") ?? [void 0, void 0];
+  if (!token || type !== "Bearer")
+    return defaultAccount;
+  try {
+    const account = jwt.verify(token, secret);
+    if (account.appName !== baseEnv.appName || account.environment !== baseEnv.environment)
+      return 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 defaultAccount;
+  }
+};
+const allow = (account, roles, userId) => {
+  if (!account)
+    throw new 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 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)" : ""}`
+  );
+};
+export {
+  allow,
+  verifyToken
+};

package/src/cacheClient.mjs

@@ -0,0 +1,24 @@
+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 { Inject, Injectable } from "@nestjs/common";
+let CacheClient = class {
+  redis;
+};
+__decorateClass([
+  Inject("REDIS_CLIENT")
+], CacheClient.prototype, "redis", 2);
+CacheClient = __decorateClass([
+  Injectable()
+], CacheClient);
+export {
+  CacheClient
+};

package/src/databaseClient.mjs

@@ -0,0 +1,30 @@
+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 { capitalize } from "@akanjs/common";
+import { Injectable } from "@nestjs/common";
+import { InjectConnection } from "@nestjs/mongoose";
+let DatabaseClient = class {
+  connection;
+  getModel(modelName) {
+    const model = this.connection.models[capitalize(modelName)];
+    return model;
+  }
+};
+__decorateClass([
+  InjectConnection()
+], DatabaseClient.prototype, "connection", 2);
+DatabaseClient = __decorateClass([
+  Injectable()
+], DatabaseClient);
+export {
+  DatabaseClient
+};

package/src/decorators.mjs

@@ -0,0 +1,144 @@
+import "reflect-metadata";
+import { Cron as NestCron, Interval as NestInterval } from "@nestjs/schedule";
+const Try = () => {
+  return function(target, key, descriptor) {
+    const originMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      try {
+        const result = await originMethod.apply(this, args);
+        return result;
+      } catch (e) {
+        this.logger?.warn(`${key} action error return: ${e}`);
+      }
+    };
+  };
+};
+const Cron = (cronTime, { lock = true, serverMode, enabled = true } = {}) => {
+  return function(target, key, descriptor) {
+    const originMethod = descriptor.value;
+    let isRunning = false;
+    descriptor.value = async function(...args) {
+      if (lock && isRunning)
+        return this.logger?.warn(`Cronjob-${key} is already running, skipped`);
+      try {
+        isRunning = true;
+        this.logger?.verbose(`Cron Job-${key} started`);
+        const res = await originMethod.apply(this, args);
+        this.logger?.verbose(`Cron Job-${key} finished`);
+        isRunning = false;
+        return res;
+      } catch (e) {
+        this.logger?.error(`Cron Job-${key} error return: ${e}`);
+        isRunning = false;
+      }
+    };
+    if (!enabled)
+      return;
+    if (!serverMode || process.env.SERVER_MODE === "all" || serverMode === process.env.SERVER_MODE)
+      NestCron(cronTime)(target, key, descriptor);
+  };
+};
+const getIntervalMetaMap = (prototype) => {
+  return Reflect.getMetadata("serviceInterval", prototype) ?? /* @__PURE__ */ new Map();
+};
+const setIntervalMetaMap = (prototype, intervalMetaMap) => {
+  Reflect.defineMetadata("serviceInterval", intervalMetaMap, prototype);
+};
+const Interval = (ms, { lock = true, serverMode, enabled = true } = {}) => {
+  return function(target, key, descriptor) {
+    const intervalMetaMap = getIntervalMetaMap(target);
+    if (intervalMetaMap.has(key))
+      return descriptor;
+    intervalMetaMap.set(key, descriptor.value);
+    setIntervalMetaMap(target, intervalMetaMap);
+    const originMethod = descriptor.value;
+    let isRunning = false;
+    descriptor.value = async function(...args) {
+      if (lock && isRunning)
+        return this.logger?.warn(`Cronjob-${key} is already running, skipped`);
+      try {
+        isRunning = true;
+        this.logger?.verbose(`Interval Job-${key} started`);
+        const res = await originMethod.apply(this, args);
+        this.logger?.verbose(`Interval Job-${key} finished`);
+        isRunning = false;
+        return res;
+      } catch (e) {
+        this.logger?.error(`Cronjob-${key} error return: ${e}`);
+        isRunning = false;
+      }
+    };
+    if (!enabled)
+      return;
+    if (!serverMode || process.env.SERVER_MODE === "all" || serverMode === process.env.SERVER_MODE)
+      NestInterval(ms)(target, key, descriptor);
+  };
+};
+const Transaction = () => {
+  return function(target, key, descriptor) {
+    const originMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      if (!this.connection)
+        throw new Error(`No Connection in function ${key}`);
+      return new Promise((resolve, reject) => {
+        this.connection.transaction(async () => {
+          const res = await originMethod.apply(this, args);
+          resolve(res);
+        }).catch(reject);
+      });
+    };
+    return descriptor;
+  };
+};
+const Cache = (timeout = 1e3, getCacheKey) => {
+  return function(target, key, descriptor) {
+    const originMethod = descriptor.value;
+    const cacheMap = /* @__PURE__ */ new Map();
+    const timerMap = /* @__PURE__ */ new Map();
+    descriptor.value = async function(...args) {
+      const classType = this.__model ? "doc" : this.__databaseModel ? "service" : "class";
+      const model = this.__model ?? this.__databaseModel?.__model;
+      const cache = this.__cache ?? this.__databaseModel?.__cache;
+      const getCacheKeyFn = getCacheKey ?? JSON.stringify;
+      const cacheKey = `${classType}:${model.modelName}:${key}:${getCacheKeyFn(...args)}`;
+      const getCache = async (cacheKey2) => {
+        if (classType === "class")
+          return cacheMap.get(cacheKey2);
+        const cached = await cache.get(cacheKey2);
+        if (cached)
+          return JSON.parse(cached);
+        return null;
+      };
+      const setCache = async (cacheKey2, value) => {
+        if (classType === "class") {
+          const existingTimer = timerMap.get(cacheKey2);
+          if (existingTimer)
+            clearTimeout(existingTimer);
+          cacheMap.set(cacheKey2, value);
+          const timer = setTimeout(() => {
+            cacheMap.delete(cacheKey2);
+            timerMap.delete(cacheKey2);
+          }, timeout);
+          timerMap.set(cacheKey2, timer);
+        } else
+          await cache.set(cacheKey2, JSON.stringify(value), { PX: timeout });
+      };
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        this.logger?.trace(`${model.modelName} cache hit: ${cacheKey}`);
+        return cachedData;
+      }
+      const result = await originMethod.apply(this, args);
+      await setCache(cacheKey, result);
+      this.logger?.trace(`${model.modelName} cache set: ${cacheKey}`);
+      return result;
+    };
+  };
+};
+export {
+  Cache,
+  Cron,
+  Interval,
+  Transaction,
+  Try
+};

package/src/exceptions.mjs

@@ -0,0 +1,57 @@
+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 { Logger } from "@akanjs/common";
+import { Catch, HttpException } from "@nestjs/common";
+let AllExceptionsFilter = class {
+  logger = new 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 HttpException ? exception.getStatus() : null;
+    if (status) {
+      res.status(status).json({
+        statusCode: status,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        path: req.url,
+        message: exception instanceof 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([
+  Catch()
+], AllExceptionsFilter);
+export {
+  AllExceptionsFilter
+};

package/src/exporter.mjs

@@ -0,0 +1,76 @@
+import * as fs from "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"));
+export {
+  FileSystem,
+  exportToCsv,
+  exportToJson,
+  objPath,
+  readJson
+};