@akanjs/server 0.9.42 → 0.9.43

package/cjs/src/boot.js

@@ -60,6 +60,7 @@ var import_redis = require("redis");
 var import_base2 = require("./base.module");
 var import_gql = require("./gql");
 var import_module = require("./module");
+var import_schedule2 = require("./schedule");
 var import_searchDaemon = require("./searchDaemon");
 const createNestApp = async ({ registerModules, serverMode = "federation", env, log = true }) => {
   const backendLogger = new import_common.Logger("Backend");
@@ -145,7 +146,8 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
           injects: { SearchClient: import_nest.SearchClient, DatabaseClient: import_nest.DatabaseClient, CacheClient: import_nest.CacheClient }
         }),
         ...["batch", "all"].includes(serverMode) && import_base.baseEnv.operationMode !== "edge" ? [import_searchDaemon.SearchDaemonModule] : [],
-        ...[(0, import_base2.registerBaseModule)(env), ...registerModules(env)].filter((m) => !!m)
+        ...[(0, import_base2.registerBaseModule)(env), ...registerModules(env)].filter((m) => !!m),
+        (0, import_schedule2.makeScheduleModule)(serverMode, env)
       ],
       providers: [import_gql.DateScalar]
     })

package/cjs/src/processor.js

@@ -51,7 +51,7 @@ const processorOf = (sigRef, allSrvs) => {
   const sigMeta = (0, import_signal.getSigMeta)(sigRef);
   const serverMode = process.env.SERVER_MODE ?? "federation";
   const gqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Process").filter(
-    (gqlMeta) => gqlMeta.signalOption.serverType === "all" || serverMode === "all" || gqlMeta.signalOption.serverType === serverMode
+    (gqlMeta) => gqlMeta.signalOption.serverMode === "all" || serverMode === "all" || gqlMeta.signalOption.serverMode === serverMode
   );
   class QueueProcessor {
   }

package/cjs/src/schedule.js

@@ -0,0 +1,231 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+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 schedule_exports = {};
+__export(schedule_exports, {
+  makeScheduleModule: () => makeScheduleModule
+});
+module.exports = __toCommonJS(schedule_exports);
+var import_common = require("@akanjs/common");
+var import_service = require("@akanjs/service");
+var import_signal = require("@akanjs/signal");
+var import_common2 = require("@nestjs/common");
+var import_cron = require("cron");
+const makeScheduleModule = (serverMode, backendEnv) => {
+  var _cronMap, _timeoutMap, _intervalMap, _lockMap;
+  const srvRefs = (0, import_service.getAllServiceRefs)();
+  const sigRefs = (0, import_signal.getAllSignalRefs)();
+  const initMetas = [];
+  const cronMetas = [];
+  const intervalMetas = [];
+  const timeoutMetas = [];
+  const destroyMetas = [];
+  sigRefs.forEach((sigRef) => {
+    const gqlMetas = (0, import_signal.getGqlMetas)(sigRef);
+    gqlMetas.forEach((gqlMeta) => {
+      const { enabled, operationMode, serverMode: targetServerMode, scheduleType } = gqlMeta.signalOption;
+      if (gqlMeta.type !== "Schedule")
+        return;
+      else if (!enabled)
+        return;
+      else if (operationMode && !operationMode.includes(backendEnv.operationMode))
+        return;
+      else if (targetServerMode && targetServerMode !== "all" && serverMode !== "all" && targetServerMode !== serverMode)
+        return;
+      switch (scheduleType) {
+        case "init":
+          initMetas.push(gqlMeta);
+          break;
+        case "cron":
+          cronMetas.push(gqlMeta);
+          break;
+        case "interval":
+          intervalMetas.push(gqlMeta);
+          break;
+        case "timeout":
+          timeoutMetas.push(gqlMeta);
+          break;
+        case "destroy":
+          destroyMetas.push(gqlMeta);
+          break;
+        default:
+          break;
+      }
+    });
+  });
+  let Schedule = class {
+    constructor() {
+      __publicField(this, "logger", new import_common2.Logger("Schedule"));
+      __privateAdd(this, _cronMap, /* @__PURE__ */ new Map());
+      __privateAdd(this, _timeoutMap, /* @__PURE__ */ new Map());
+      __privateAdd(this, _intervalMap, /* @__PURE__ */ new Map());
+      __privateAdd(this, _lockMap, /* @__PURE__ */ new Map());
+    }
+    async onModuleInit() {
+      await Promise.all(
+        initMetas.map(async (gqlMeta) => {
+          const fn = gqlMeta.descriptor.value;
+          const before = Date.now();
+          this.logger.debug(`Init Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Init After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+        })
+      );
+      timeoutMetas.forEach((gqlMeta) => {
+        const fn = gqlMeta.descriptor.value;
+        const timeout = gqlMeta.signalOption.scheduleTime;
+        const timer = setTimeout(async () => {
+          const before = Date.now();
+          this.logger.debug(`Timemout Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Timemout After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+          __privateGet(this, _timeoutMap).delete(fn);
+        }, timeout);
+        __privateGet(this, _timeoutMap).set(fn, timer);
+      });
+      intervalMetas.forEach((gqlMeta) => {
+        const lock = gqlMeta.signalOption.lock;
+        const fn = gqlMeta.descriptor.value;
+        const interval = gqlMeta.signalOption.scheduleTime;
+        const timer = setInterval(async () => {
+          if (lock) {
+            if (__privateGet(this, _lockMap).get(fn)) {
+              this.logger.warn(`${gqlMeta.key} is locked, skipping...`);
+              return;
+            }
+            __privateGet(this, _lockMap).set(fn, true);
+          }
+          const before = Date.now();
+          this.logger.debug(`Interval Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Interval After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+          if (lock)
+            __privateGet(this, _lockMap).set(fn, false);
+        }, interval);
+        __privateGet(this, _intervalMap).set(fn, timer);
+      });
+      cronMetas.forEach((gqlMeta) => {
+        const lock = gqlMeta.signalOption.lock;
+        const fn = gqlMeta.descriptor.value;
+        const cronTime = gqlMeta.signalOption.scheduleCron;
+        if (!cronTime)
+          throw new Error(`Cron time is not found for ${gqlMeta.key}`);
+        const cronJob = import_cron.CronJob.from({
+          cronTime,
+          onTick: async () => {
+            if (lock) {
+              if (__privateGet(this, _lockMap).get(fn)) {
+                this.logger.warn(`${gqlMeta.key} is locked, skipping...`);
+                return;
+              }
+              __privateGet(this, _lockMap).set(fn, true);
+            }
+            const before = Date.now();
+            this.logger.debug(`Cron Before ${gqlMeta.key} / ${before}`);
+            await fn.apply(this);
+            const after = Date.now();
+            this.logger.debug(`Cron After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+            if (lock)
+              __privateGet(this, _lockMap).set(fn, false);
+          },
+          start: true
+        });
+        __privateGet(this, _cronMap).set(fn, cronJob);
+      });
+    }
+    async onModuleDestroy() {
+      __privateGet(this, _timeoutMap).forEach((timer, fn) => {
+        clearTimeout(timer);
+        __privateGet(this, _timeoutMap).delete(fn);
+      });
+      __privateGet(this, _intervalMap).forEach((timer, fn) => {
+        clearInterval(timer);
+        __privateGet(this, _intervalMap).delete(fn);
+      });
+      await Promise.all(
+        [...__privateGet(this, _cronMap).entries()].map(async ([fn, cronJob]) => {
+          await cronJob.stop();
+          __privateGet(this, _cronMap).delete(fn);
+        })
+      );
+      await Promise.all(
+        destroyMetas.map(async (gqlMeta) => {
+          const fn = gqlMeta.descriptor.value;
+          const before = Date.now();
+          this.logger.debug(`Destroy Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Destroy After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+        })
+      );
+    }
+  };
+  _cronMap = new WeakMap();
+  _timeoutMap = new WeakMap();
+  _intervalMap = new WeakMap();
+  _lockMap = new WeakMap();
+  Schedule = __decorateClass([
+    (0, import_common2.Injectable)()
+  ], Schedule);
+  srvRefs.forEach((srvRef) => {
+    const serviceMeta = (0, import_service.getServiceMeta)(srvRef);
+    if (!serviceMeta)
+      throw new Error(`Service ${srvRef.name} is not found`);
+    (0, import_common2.Inject)(srvRef)(Schedule.prototype, (0, import_common.lowerlize)(serviceMeta.name));
+  });
+  let ScheduleModule = class {
+  };
+  ScheduleModule = __decorateClass([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({ providers: [Schedule] })
+  ], ScheduleModule);
+  return ScheduleModule;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeScheduleModule
+});

package/cjs/src/searchDaemon.js

@@ -217,9 +217,7 @@ let SearchDaemonModule = class {
 };
 SearchDaemonModule = __decorateClass([
   (0, import_common2.Global)(),
-  (0, import_common2.Module)({
-    providers: [SearchDaemon]
-  })
+  (0, import_common2.Module)({ providers: [SearchDaemon] })
 ], SearchDaemonModule);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/esm/src/boot.js

@@ -51,6 +51,7 @@ import { createClient } from "redis";
 import { registerBaseModule } from "./base.module";
 import { DateScalar } from "./gql";
 import { useGlobals } from "./module";
+import { makeScheduleModule } from "./schedule";
 import { SearchDaemonModule } from "./searchDaemon";
 const createNestApp = async ({ registerModules, serverMode = "federation", env, log = true }) => {
   const backendLogger = new Logger("Backend");
@@ -136,7 +137,8 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
           injects: { SearchClient, DatabaseClient, CacheClient }
         }),
         ...["batch", "all"].includes(serverMode) && baseEnv.operationMode !== "edge" ? [SearchDaemonModule] : [],
-        ...[registerBaseModule(env), ...registerModules(env)].filter((m) => !!m)
+        ...[registerBaseModule(env), ...registerModules(env)].filter((m) => !!m),
+        makeScheduleModule(serverMode, env)
       ],
       providers: [DateScalar]
     })

package/esm/src/processor.js

@@ -33,7 +33,7 @@ const processorOf = (sigRef, allSrvs) => {
   const sigMeta = getSigMeta(sigRef);
   const serverMode = process.env.SERVER_MODE ?? "federation";
   const gqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Process").filter(
-    (gqlMeta) => gqlMeta.signalOption.serverType === "all" || serverMode === "all" || gqlMeta.signalOption.serverType === serverMode
+    (gqlMeta) => gqlMeta.signalOption.serverMode === "all" || serverMode === "all" || gqlMeta.signalOption.serverMode === serverMode
   );
   class QueueProcessor {
   }

package/esm/src/schedule.js

@@ -0,0 +1,210 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+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);
+};
+import { lowerlize } from "@akanjs/common";
+import { getAllServiceRefs, getServiceMeta } from "@akanjs/service";
+import { getAllSignalRefs, getGqlMetas } from "@akanjs/signal";
+import { Global, Inject, Injectable, Logger, Module } from "@nestjs/common";
+import { CronJob } from "cron";
+const makeScheduleModule = (serverMode, backendEnv) => {
+  var _cronMap, _timeoutMap, _intervalMap, _lockMap;
+  const srvRefs = getAllServiceRefs();
+  const sigRefs = getAllSignalRefs();
+  const initMetas = [];
+  const cronMetas = [];
+  const intervalMetas = [];
+  const timeoutMetas = [];
+  const destroyMetas = [];
+  sigRefs.forEach((sigRef) => {
+    const gqlMetas = getGqlMetas(sigRef);
+    gqlMetas.forEach((gqlMeta) => {
+      const { enabled, operationMode, serverMode: targetServerMode, scheduleType } = gqlMeta.signalOption;
+      if (gqlMeta.type !== "Schedule")
+        return;
+      else if (!enabled)
+        return;
+      else if (operationMode && !operationMode.includes(backendEnv.operationMode))
+        return;
+      else if (targetServerMode && targetServerMode !== "all" && serverMode !== "all" && targetServerMode !== serverMode)
+        return;
+      switch (scheduleType) {
+        case "init":
+          initMetas.push(gqlMeta);
+          break;
+        case "cron":
+          cronMetas.push(gqlMeta);
+          break;
+        case "interval":
+          intervalMetas.push(gqlMeta);
+          break;
+        case "timeout":
+          timeoutMetas.push(gqlMeta);
+          break;
+        case "destroy":
+          destroyMetas.push(gqlMeta);
+          break;
+        default:
+          break;
+      }
+    });
+  });
+  let Schedule = class {
+    constructor() {
+      __publicField(this, "logger", new Logger("Schedule"));
+      __privateAdd(this, _cronMap, /* @__PURE__ */ new Map());
+      __privateAdd(this, _timeoutMap, /* @__PURE__ */ new Map());
+      __privateAdd(this, _intervalMap, /* @__PURE__ */ new Map());
+      __privateAdd(this, _lockMap, /* @__PURE__ */ new Map());
+    }
+    async onModuleInit() {
+      await Promise.all(
+        initMetas.map(async (gqlMeta) => {
+          const fn = gqlMeta.descriptor.value;
+          const before = Date.now();
+          this.logger.debug(`Init Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Init After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+        })
+      );
+      timeoutMetas.forEach((gqlMeta) => {
+        const fn = gqlMeta.descriptor.value;
+        const timeout = gqlMeta.signalOption.scheduleTime;
+        const timer = setTimeout(async () => {
+          const before = Date.now();
+          this.logger.debug(`Timemout Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Timemout After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+          __privateGet(this, _timeoutMap).delete(fn);
+        }, timeout);
+        __privateGet(this, _timeoutMap).set(fn, timer);
+      });
+      intervalMetas.forEach((gqlMeta) => {
+        const lock = gqlMeta.signalOption.lock;
+        const fn = gqlMeta.descriptor.value;
+        const interval = gqlMeta.signalOption.scheduleTime;
+        const timer = setInterval(async () => {
+          if (lock) {
+            if (__privateGet(this, _lockMap).get(fn)) {
+              this.logger.warn(`${gqlMeta.key} is locked, skipping...`);
+              return;
+            }
+            __privateGet(this, _lockMap).set(fn, true);
+          }
+          const before = Date.now();
+          this.logger.debug(`Interval Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Interval After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+          if (lock)
+            __privateGet(this, _lockMap).set(fn, false);
+        }, interval);
+        __privateGet(this, _intervalMap).set(fn, timer);
+      });
+      cronMetas.forEach((gqlMeta) => {
+        const lock = gqlMeta.signalOption.lock;
+        const fn = gqlMeta.descriptor.value;
+        const cronTime = gqlMeta.signalOption.scheduleCron;
+        if (!cronTime)
+          throw new Error(`Cron time is not found for ${gqlMeta.key}`);
+        const cronJob = CronJob.from({
+          cronTime,
+          onTick: async () => {
+            if (lock) {
+              if (__privateGet(this, _lockMap).get(fn)) {
+                this.logger.warn(`${gqlMeta.key} is locked, skipping...`);
+                return;
+              }
+              __privateGet(this, _lockMap).set(fn, true);
+            }
+            const before = Date.now();
+            this.logger.debug(`Cron Before ${gqlMeta.key} / ${before}`);
+            await fn.apply(this);
+            const after = Date.now();
+            this.logger.debug(`Cron After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+            if (lock)
+              __privateGet(this, _lockMap).set(fn, false);
+          },
+          start: true
+        });
+        __privateGet(this, _cronMap).set(fn, cronJob);
+      });
+    }
+    async onModuleDestroy() {
+      __privateGet(this, _timeoutMap).forEach((timer, fn) => {
+        clearTimeout(timer);
+        __privateGet(this, _timeoutMap).delete(fn);
+      });
+      __privateGet(this, _intervalMap).forEach((timer, fn) => {
+        clearInterval(timer);
+        __privateGet(this, _intervalMap).delete(fn);
+      });
+      await Promise.all(
+        [...__privateGet(this, _cronMap).entries()].map(async ([fn, cronJob]) => {
+          await cronJob.stop();
+          __privateGet(this, _cronMap).delete(fn);
+        })
+      );
+      await Promise.all(
+        destroyMetas.map(async (gqlMeta) => {
+          const fn = gqlMeta.descriptor.value;
+          const before = Date.now();
+          this.logger.debug(`Destroy Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Destroy After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+        })
+      );
+    }
+  };
+  _cronMap = new WeakMap();
+  _timeoutMap = new WeakMap();
+  _intervalMap = new WeakMap();
+  _lockMap = new WeakMap();
+  Schedule = __decorateClass([
+    Injectable()
+  ], Schedule);
+  srvRefs.forEach((srvRef) => {
+    const serviceMeta = getServiceMeta(srvRef);
+    if (!serviceMeta)
+      throw new Error(`Service ${srvRef.name} is not found`);
+    Inject(srvRef)(Schedule.prototype, lowerlize(serviceMeta.name));
+  });
+  let ScheduleModule = class {
+  };
+  ScheduleModule = __decorateClass([
+    Global(),
+    Module({ providers: [Schedule] })
+  ], ScheduleModule);
+  return ScheduleModule;
+};
+export {
+  makeScheduleModule
+};

package/esm/src/searchDaemon.js

@@ -202,9 +202,7 @@ let SearchDaemonModule = class {
 };
 SearchDaemonModule = __decorateClass([
   Global(),
-  Module({
-    providers: [SearchDaemon]
-  })
+  Module({ providers: [SearchDaemon] })
 ], SearchDaemonModule);
 export {
   SearchDaemonModule,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/server",
-  "version": "0.9.42",
+  "version": "0.9.43",
   "sourceType": "module",
   "publishConfig": {
     "access": "public"
@@ -30,6 +30,7 @@
     "@nestjs/websockets": "^10.4.15",
     "body-parser": "^1.20.3",
     "cookie-parser": "^1.4.7",
+    "cron": "^4.3.3",
     "dayjs": "^1.11.13",
     "graphql": "^16.10.0",
     "graphql-type-json": "^0.3.2",

package/src/schedule.d.ts

@@ -0,0 +1,4 @@
+import type { BackendEnv } from "@akanjs/base";
+export declare const makeScheduleModule: (serverMode: "federation" | "batch" | "all" | "none", backendEnv: BackendEnv) => {
+    new (): {};
+};