@akanjs/nest 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/nest",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -21,6 +21,7 @@
     "@nestjs/passport": "^10.0.3",
     "@nestjs/platform-express": "^10.4.15",
     "@nestjs/platform-socket.io": "^10.4.15",
+    "@nestjs/schedule": "^4.1.2",
     "@nestjs/websockets": "^10.4.15",
     "@socket.io/redis-adapter": "^8.3.0",
     "@urql/core": "^5.1.0",

package/src/decorators.d.ts

@@ -0,0 +1,13 @@
+import "reflect-metadata";
+import { CronExpression } from "@nestjs/schedule";
+export declare const Try: () => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+interface TimerOptions {
+    lock?: boolean;
+    serverMode?: "federation" | "batch";
+    enabled?: boolean;
+}
+export declare const Cron: (cronTime: CronExpression | string, { lock, serverMode, enabled }?: TimerOptions) => (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare const Interval: (ms: number, { lock, serverMode, enabled }?: TimerOptions) => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor | undefined;
+export declare const Transaction: () => (target: any, key: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
+export declare const Cache: (timeout?: number, getCacheKey?: (...args: any) => string) => MethodDecorator;
+export {};

package/src/decorators.js

@@ -0,0 +1,171 @@
+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 decorators_exports = {};
+__export(decorators_exports, {
+  Cache: () => Cache,
+  Cron: () => Cron,
+  Interval: () => Interval,
+  Transaction: () => Transaction,
+  Try: () => Try
+});
+module.exports = __toCommonJS(decorators_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_schedule = require("@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)
+      (0, import_schedule.Cron)(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)
+      (0, import_schedule.Interval)(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;
+    };
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cache,
+  Cron,
+  Interval,
+  Transaction,
+  Try
+});

package/src/exporter.js

@@ -86,7 +86,7 @@ const exportToCsv = async ({ items, path, fields, delimiter, options }) => {
     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 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)

package/src/index.d.ts

@@ -16,3 +16,4 @@ export * from "./mongoose";
 export * from "./searchClient";
 export * from "./cacheClient";
 export * from "./databaseClient";
+export * from "./decorators";

package/src/index.js

@@ -51,6 +51,7 @@ __reExport(src_exports, require("./mongoose"), module.exports);
 __reExport(src_exports, require("./searchClient"), module.exports);
 __reExport(src_exports, require("./cacheClient"), module.exports);
 __reExport(src_exports, require("./databaseClient"), module.exports);
+__reExport(src_exports, require("./decorators"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Exporter,
@@ -70,5 +71,6 @@ __reExport(src_exports, require("./databaseClient"), module.exports);
   ...require("./mongoose"),
   ...require("./searchClient"),
   ...require("./cacheClient"),
-  ...require("./databaseClient")
+  ...require("./databaseClient"),
+  ...require("./decorators")
 });