@akanjs/server 0.9.42 → 0.9.44

package/cjs/src/boot.js

@@ -56,10 +56,12 @@ var import_dgram = __toESM(require("dgram"));
 var import_events = __toESM(require("events"));
 var import_graphql_upload = require("graphql-upload");
 var import_meilisearch = require("meilisearch");
+var import_mongoose2 = __toESM(require("mongoose"));
 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");
@@ -109,9 +111,10 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
           provide: "MEILI_CLIENT",
           useFactory: () => new import_meilisearch.MeiliSearch({ host: meiliUri, apiKey: (0, import_nest.generateMeiliKey)(env) })
         },
-        { provide: "GLOBAL_ENV", useValue: env }
+        { provide: "GLOBAL_ENV", useValue: env },
+        { provide: "MONGO_CLIENT", useValue: import_mongoose2.default.connection }
       ],
-      exports: ["REDIS_CLIENT", "MEILI_CLIENT", "GLOBAL_ENV"]
+      exports: ["REDIS_CLIENT", "MEILI_CLIENT", "GLOBAL_ENV", "MONGO_CLIENT"]
     })
   ], GlobalProvideModule);
   let AppModule = class {
@@ -145,7 +148,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/schema.js

@@ -206,13 +206,42 @@ const schemaOf = (modelRef, docRef, middleware) => {
     schema.methods[name] = Object.getOwnPropertyDescriptor(docRef.prototype, name)?.value;
   });
   schema.pre("save", async function(next) {
-    const model = this.constructor;
-    if (this.isNew)
-      model.addSummary(["total", this.status]);
-    else if (!!this.removedAt && this.isModified("removedAt"))
-      model.subSummary(["total", this.status]);
+    const saveType = this.isNew ? "create" : this.isModified("removedAt") ? this.removedAt ? "remove" : "create" : "update";
+    const saveListeners = [
+      ...this.constructor.preSaveListenerSet,
+      ...saveType === "create" ? [...this.constructor.preCreateListenerSet] : saveType === "update" ? [...this.constructor.preUpdateListenerSet] : [...this.constructor.preRemoveListenerSet]
+    ];
+    await Promise.all(
+      saveListeners.map(async (listener) => {
+        try {
+          await listener(this, saveType);
+        } catch (e) {
+          import_common.Logger.error(
+            `Pre Save Listener Error ${this.constructor.modelName}: ${e instanceof Error ? e.message : typeof e === "string" ? e : "unknown error"}`
+          );
+        }
+      })
+    );
     next();
   });
+  schema.post("save", async function() {
+    const saveType = this.isNew ? "create" : this.isModified("removedAt") ? this.removedAt ? "remove" : "create" : "update";
+    const saveListeners = [
+      ...this.constructor.postSaveListenerSet,
+      ...saveType === "create" ? [...this.constructor.postCreateListenerSet] : saveType === "update" ? [...this.constructor.postUpdateListenerSet] : [...this.constructor.postRemoveListenerSet]
+    ];
+    await Promise.all(
+      saveListeners.map(async (listener) => {
+        try {
+          await listener(this, saveType);
+        } catch (e) {
+          import_common.Logger.error(
+            `Post Save Listener Error ${this.constructor.modelName}: ${e instanceof Error ? e.message : typeof e === "string" ? e : "unknown error"}`
+          );
+        }
+      })
+    );
+  });
   const onSchema = Object.getOwnPropertyDescriptor(middleware.prototype, "onSchema")?.value;
   onSchema?.(schema);
   schema.index({ removedAt: -1 });

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

@@ -47,10 +47,12 @@ import dgram from "dgram";
 import events from "events";
 import { graphqlUploadExpress } from "graphql-upload";
 import { MeiliSearch } from "meilisearch";
+import mongoose from "mongoose";
 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");
@@ -100,9 +102,10 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
           provide: "MEILI_CLIENT",
           useFactory: () => new MeiliSearch({ host: meiliUri, apiKey: generateMeiliKey(env) })
         },
-        { provide: "GLOBAL_ENV", useValue: env }
+        { provide: "GLOBAL_ENV", useValue: env },
+        { provide: "MONGO_CLIENT", useValue: mongoose.connection }
       ],
-      exports: ["REDIS_CLIENT", "MEILI_CLIENT", "GLOBAL_ENV"]
+      exports: ["REDIS_CLIENT", "MEILI_CLIENT", "GLOBAL_ENV", "MONGO_CLIENT"]
     })
   ], GlobalProvideModule);
   let AppModule = class {
@@ -136,7 +139,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/schema.js

@@ -8,7 +8,7 @@ import {
   Int,
   JSON
 } from "@akanjs/base";
-import { isDayjs } from "@akanjs/common";
+import { isDayjs, Logger } from "@akanjs/common";
 import { getClassMeta, getFieldMetas, getFullModelRef, getInputModelRef } from "@akanjs/constant";
 import { getDefaultSchemaOptions, ObjectId } from "@akanjs/document";
 import { makeDefault } from "@akanjs/signal";
@@ -191,13 +191,42 @@ const schemaOf = (modelRef, docRef, middleware) => {
     schema.methods[name] = Object.getOwnPropertyDescriptor(docRef.prototype, name)?.value;
   });
   schema.pre("save", async function(next) {
-    const model = this.constructor;
-    if (this.isNew)
-      model.addSummary(["total", this.status]);
-    else if (!!this.removedAt && this.isModified("removedAt"))
-      model.subSummary(["total", this.status]);
+    const saveType = this.isNew ? "create" : this.isModified("removedAt") ? this.removedAt ? "remove" : "create" : "update";
+    const saveListeners = [
+      ...this.constructor.preSaveListenerSet,
+      ...saveType === "create" ? [...this.constructor.preCreateListenerSet] : saveType === "update" ? [...this.constructor.preUpdateListenerSet] : [...this.constructor.preRemoveListenerSet]
+    ];
+    await Promise.all(
+      saveListeners.map(async (listener) => {
+        try {
+          await listener(this, saveType);
+        } catch (e) {
+          Logger.error(
+            `Pre Save Listener Error ${this.constructor.modelName}: ${e instanceof Error ? e.message : typeof e === "string" ? e : "unknown error"}`
+          );
+        }
+      })
+    );
     next();
   });
+  schema.post("save", async function() {
+    const saveType = this.isNew ? "create" : this.isModified("removedAt") ? this.removedAt ? "remove" : "create" : "update";
+    const saveListeners = [
+      ...this.constructor.postSaveListenerSet,
+      ...saveType === "create" ? [...this.constructor.postCreateListenerSet] : saveType === "update" ? [...this.constructor.postUpdateListenerSet] : [...this.constructor.postRemoveListenerSet]
+    ];
+    await Promise.all(
+      saveListeners.map(async (listener) => {
+        try {
+          await listener(this, saveType);
+        } catch (e) {
+          Logger.error(
+            `Post Save Listener Error ${this.constructor.modelName}: ${e instanceof Error ? e.message : typeof e === "string" ? e : "unknown error"}`
+          );
+        }
+      })
+    );
+  });
   const onSchema = Object.getOwnPropertyDescriptor(middleware.prototype, "onSchema")?.value;
   onSchema?.(schema);
   schema.index({ removedAt: -1 });

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.44",
   "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/module.d.ts

@@ -4,7 +4,7 @@ import { Database } from "@akanjs/document";
 import { DynamicModule } from "@nestjs/common";
 interface DatabaseModuleCreateOptions {
     constant: ConstantModel<string, any, any, any, any, any>;
-    database: Database<string, any, any, any, any, any, any, any, any>;
+    database: Database<string, any, any, any, any, any, any, any>;
     signal: Type;
     service: Type;
 }

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 (): {};
+};

package/src/searchDaemon.d.ts

@@ -1,5 +1,30 @@
 import type { Type } from "@akanjs/base";
 import { type TextDoc } from "@akanjs/constant";
+import type { Types } from "mongoose";
+export interface ChangedData {
+    _id: {
+        _data: string;
+    };
+    operationType: "update" | "insert" | "delete";
+    clusterTime: {
+        t: number;
+        i: number;
+    };
+    wallTime: Date;
+    ns: {
+        db: string;
+        coll: string;
+    };
+    documentKey: {
+        _id: Types.ObjectId;
+    };
+    updateDescription?: {
+        updatedFields: Record<string, any>;
+        removedFields: string[];
+        truncatedArrays: any[];
+    };
+    fullDocument?: Record<string, any>;
+}
 export declare const makeTextFilter: (modelRef: Type) => (data: Record<string, any>, assignObj?: {
     [key: string]: string;
 }) => TextDoc;