@akanjs/server 0.9.41 → 0.9.43

package/cjs/src/base.module.js

@@ -27,8 +27,7 @@ const registerBaseModule = (option) => {
   return (0, import_module.serviceModuleOf)(
     {
       signal: import_signal.BaseSignal,
-      service: import_service.BaseService,
-      uses: { onCleanup: option.onCleanup }
+      service: import_service.BaseService
     },
     import_service.allSrvs
   );

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");
@@ -98,9 +99,9 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
     (0, import_common2.Injectable)()
   ], AuthMiddleWare);
   const redisClient = await (0, import_redis.createClient)({ url: redisUri }).connect();
-  let SubDatabaseModule = class {
+  let GlobalProvideModule = class {
   };
-  SubDatabaseModule = __decorateClass([
+  GlobalProvideModule = __decorateClass([
     (0, import_common2.Global)(),
     (0, import_common2.Module)({
       providers: [
@@ -108,11 +109,12 @@ 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 }
       ],
-      exports: ["REDIS_CLIENT", "MEILI_CLIENT"]
+      exports: ["REDIS_CLIENT", "MEILI_CLIENT", "GLOBAL_ENV"]
     })
-  ], SubDatabaseModule);
+  ], GlobalProvideModule);
   let AppModule = class {
     configure(consumer) {
       consumer.apply(AuthMiddleWare).forRoutes({ path: "*", method: import_common2.RequestMethod.ALL });
@@ -139,12 +141,13 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
         import_mongoose.MongooseModule.forRootAsync({
           useFactory: () => ({ uri: mongoUri, autoIndex: import_base.baseEnv.environment !== "main" })
         }),
-        SubDatabaseModule,
+        GlobalProvideModule,
         (0, import_module.useGlobals)({
           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/controller.js

@@ -43,10 +43,11 @@ const controllerOf = (sigRef, allSrvs) => {
   const gqlMetas = (0, import_signal.getGqlMetas)(sigRef);
   const prefix = (0, import_signal.getControllerPrefix)(sigMeta);
   const Ctrl = (0, import_signal.copySignal)(sigRef);
-  Object.keys(allSrvs).forEach((srv) => {
-    if (!(0, import_service.isServiceEnabled)(allSrvs[srv]))
+  Object.keys(allSrvs).forEach((srvName) => {
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srvName]))
       return;
-    (0, import_common2.Inject)(allSrvs[srv])(Ctrl.prototype, (0, import_common.lowerlize)(srv));
+    const srvRef = (0, import_service.getServiceRefs)(srvName)[0];
+    (0, import_common2.Inject)(srvRef)(Ctrl.prototype, (0, import_common.lowerlize)(srvName));
   });
   for (const gqlMeta of gqlMetas) {
     if (gqlMeta.guards.some((guard) => guard === "None") || gqlMeta.signalOption.onlyFor === "graphql" || !["Query", "Mutation"].includes(gqlMeta.type))

package/cjs/src/module.js

@@ -26,9 +26,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var module_exports = {};
 __export(module_exports, {
-  batchModuleOf: () => batchModuleOf,
   databaseModuleOf: () => databaseModuleOf,
-  scalarModuleOf: () => scalarModuleOf,
   scalarModulesOf: () => scalarModulesOf,
   serviceModuleOf: () => serviceModuleOf,
   useGlobals: () => useGlobals
@@ -50,20 +48,12 @@ var import_websocket = require("./websocket");
 const hasWebsocket = (signal) => (0, import_signal.getGqlMetas)(signal).some((gqlMeta) => ["Message", "Pubsub"].includes(gqlMeta.type));
 const hasProcessor = (signal) => (0, import_signal.getGqlMetas)(signal).some((gqlMeta) => gqlMeta.type === "Process");
 const filterSrvs = (srvs) => Object.fromEntries(Object.entries(srvs).filter(([_, srv]) => !!srv));
-const databaseModuleOf = ({
-  constant,
-  database,
-  signal,
-  service,
-  uses = {},
-  useAsyncs = {},
-  providers = [],
-  extended
-}, allSrvs) => {
+const databaseModuleOf = ({ constant, database, signal, service }, allSrvs) => {
   if (!(0, import_service.isServiceEnabled)(service))
     return null;
   const [modelName, className] = [(0, import_common.lowerlize)(constant.refName), (0, import_common.capitalize)(constant.refName)];
   const mongoToken = (0, import_mongoose.getModelToken)(className);
+  const srvRef = (0, import_service.serviceOf)(service);
   let DatabaseModule = class {
   };
   DatabaseModule = __decorateClass([
@@ -73,7 +63,7 @@ const databaseModuleOf = ({
         import_mongoose.MongooseModule.forFeature([
           {
             name: className,
-            schema: extended ? (0, import_schema.addSchema)(database.Model, database.Doc, database.Input, database.Middleware) : (0, import_schema.schemaOf)(database.Model, database.Doc, database.Middleware)
+            schema: (0, import_schema.hasSchema)(constant.Full) ? (0, import_schema.addSchema)(database.Model, database.Doc, database.Input, database.Middleware) : (0, import_schema.schemaOf)(database.Model, database.Doc, database.Middleware)
           }
         ]),
         ...hasProcessor(signal) ? [
@@ -84,15 +74,11 @@ const databaseModuleOf = ({
         ] : []
       ],
       providers: [
-        (0, import_service.serviceOf)(service),
+        ...service === srvRef ? [srvRef] : [],
         (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs)),
-        ...hasProcessor(signal) ? [
-          (0, import_processor.processorOf)(signal, filterSrvs(allSrvs)),
-          { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [(0, import_bull.getQueueToken)(modelName)] }
-        ] : [],
-        ...hasWebsocket(signal) ? [(0, import_websocket.websocketOf)(signal, filterSrvs(allSrvs)), { provide: "Websocket", useClass: (0, import_websocket.websocketServerOf)(signal) }] : [],
-        ...Object.entries(uses).map(([key, useValue]) => ({ provide: (0, import_common.capitalize)(key), useValue })),
-        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: (0, import_common.capitalize)(key), useFactory })),
+        ...hasWebsocket(signal) ? [(0, import_websocket.websocketOf)(signal, filterSrvs(allSrvs))] : [],
+        ...hasProcessor(signal) ? [(0, import_processor.processorOf)(signal, filterSrvs(allSrvs))] : [],
+        { provide: `${className}Signal`, useClass: makeSigForSrv(signal) },
         {
           provide: `${modelName}Model`,
           useFactory: (model, redis, meili) => {
@@ -100,74 +86,52 @@ const databaseModuleOf = ({
           },
           inject: [mongoToken, "REDIS_CLIENT", "MEILI_CLIENT"]
         },
-        ...providers
+        ...(0, import_service.makeProvidersForSrv)(srvRef)
       ],
       controllers: [(0, import_controller.controllerOf)(signal, filterSrvs(allSrvs))],
-      exports: [service]
+      exports: service === srvRef ? [srvRef] : []
     })
   ], DatabaseModule);
   return DatabaseModule;
 };
-const serviceModuleOf = ({ signal, service, uses = {}, useAsyncs = {}, providers = [] }, allSrvs) => {
+const serviceModuleOf = ({ signal, service }, allSrvs) => {
   if (!(0, import_service.isServiceEnabled)(service))
     return null;
-  const sigMeta = (0, import_signal.getSigMeta)(signal);
-  const [modelName, className] = [(0, import_common.lowerlize)(sigMeta.refName), (0, import_common.capitalize)(sigMeta.refName)];
+  const serviceMeta = (0, import_service.getServiceMeta)(service);
+  if (!serviceMeta)
+    throw new Error(`Service ${service} is not a valid service`);
+  const refName = serviceMeta.name.replace("Service", "");
+  const [modelName, className] = [(0, import_common.lowerlize)(refName), (0, import_common.capitalize)(refName)];
+  const srvRef = (0, import_service.serviceOf)(service);
   let ServiceModule = class {
   };
   ServiceModule = __decorateClass([
     (0, import_common2.Global)(),
     (0, import_common2.Module)({
-      imports: [
+      imports: signal ? [
         ...hasProcessor(signal) ? [
           import_bull.BullModule.registerQueue({
             name: modelName,
             defaultJobOptions: { removeOnComplete: true, removeOnFail: true }
           })
         ] : []
-      ],
+      ] : [],
       providers: [
-        (0, import_service.serviceOf)(service),
-        (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs)),
-        ...hasWebsocket(signal) ? [(0, import_websocket.websocketOf)(signal, filterSrvs(allSrvs)), { provide: "Websocket", useClass: (0, import_websocket.websocketServerOf)(signal) }] : [],
-        ...hasProcessor(signal) ? [
-          (0, import_processor.processorOf)(signal, filterSrvs(allSrvs)),
-          { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [(0, import_bull.getQueueToken)(modelName)] }
+        ...service === srvRef ? [srvRef] : [],
+        ...signal ? [
+          (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs)),
+          ...hasWebsocket(signal) ? [(0, import_websocket.websocketOf)(signal, filterSrvs(allSrvs))] : [],
+          ...hasProcessor(signal) ? [(0, import_processor.processorOf)(signal, filterSrvs(allSrvs))] : [],
+          { provide: `${className}Signal`, useClass: makeSigForSrv(signal) }
         ] : [],
-        ...Object.entries(uses).map(([key, useValue]) => ({ provide: (0, import_common.capitalize)(key), useValue })),
-        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: (0, import_common.capitalize)(key), useFactory })),
-        ...providers
+        ...(0, import_service.makeProvidersForSrv)(srvRef)
       ],
-      controllers: [(0, import_controller.controllerOf)(signal, filterSrvs(allSrvs))],
-      exports: [service]
+      controllers: signal ? [(0, import_controller.controllerOf)(signal, filterSrvs(allSrvs))] : [],
+      exports: service === srvRef ? [srvRef] : []
     })
   ], ServiceModule);
   return ServiceModule;
 };
-const scalarModuleOf = ({ signals, uses = {}, useAsyncs = {}, providers = [], enabled = true }, allSrvs) => {
-  if (!enabled)
-    return null;
-  let ScalarModule = class {
-  };
-  ScalarModule = __decorateClass([
-    (0, import_common2.Global)(),
-    (0, import_common2.Module)({
-      imports: [],
-      providers: [
-        ...signals.map((signal) => (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs))),
-        ...signals.filter(hasWebsocket).map((signal) => [
-          (0, import_websocket.websocketOf)(signal, filterSrvs(allSrvs)),
-          { provide: "Websocket", useClass: (0, import_websocket.websocketServerOf)(signal) }
-        ]).flat(),
-        ...Object.entries(uses).map(([key, useValue]) => ({ provide: (0, import_common.capitalize)(key), useValue })),
-        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: (0, import_common.capitalize)(key), useFactory })),
-        ...providers
-      ],
-      controllers: signals.map((signal) => (0, import_controller.controllerOf)(signal, filterSrvs(allSrvs)))
-    })
-  ], ScalarModule);
-  return ScalarModule;
-};
 const scalarModulesOf = ({ constants }, allSrvs) => {
   const signals = constants.filter((modelRef) => {
     const childRefs = (0, import_constant.getChildClassRefs)(modelRef);
@@ -194,32 +158,7 @@ const scalarModulesOf = ({ constants }, allSrvs) => {
   ], ScalarModule);
   return ScalarModule;
 };
-const batchModuleOf = ({
-  service,
-  uses = {},
-  useAsyncs = {},
-  providers = []
-}) => {
-  if (!(0, import_service.isServiceEnabled)(service))
-    return null;
-  let BatchModule = class {
-  };
-  BatchModule = __decorateClass([
-    (0, import_common2.Global)(),
-    (0, import_common2.Module)({
-      imports: [],
-      providers: [
-        (0, import_service.serviceOf)(service),
-        ...Object.entries(uses).map(([key, useValue]) => ({ provide: (0, import_common.capitalize)(key), useValue })),
-        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: (0, import_common.capitalize)(key), useFactory })),
-        ...providers
-      ],
-      exports: [service]
-    })
-  ], BatchModule);
-  return BatchModule;
-};
-const useGlobals = ({ uses, useAsyncs, injects }) => {
+const useGlobals = ({ uses, useAsyncs, providers = [], injects }) => {
   let GlobalsModule = class {
   };
   GlobalsModule = __decorateClass([
@@ -232,7 +171,8 @@ const useGlobals = ({ uses, useAsyncs, injects }) => {
           useValue
         })),
         ...Object.entries(useAsyncs ?? {}).map(([key, useFactory]) => ({ provide: (0, import_common.capitalize)(key), useFactory })),
-        ...Object.entries(injects ?? {}).map(([key, inject]) => ({ provide: (0, import_common.capitalize)(key), useClass: inject }))
+        ...Object.entries(injects ?? {}).map(([key, inject]) => ({ provide: (0, import_common.capitalize)(key), useClass: inject })),
+        ...providers
       ],
       exports: [
         ...Object.keys(uses ?? {}).map((key) => (0, import_common.capitalize)(key)),
@@ -243,11 +183,21 @@ const useGlobals = ({ uses, useAsyncs, injects }) => {
   ], GlobalsModule);
   return GlobalsModule;
 };
+const makeSigForSrv = (sigRef) => {
+  let Sig = class {
+  };
+  Sig = __decorateClass([
+    (0, import_common2.Injectable)()
+  ], Sig);
+  if (hasWebsocket(sigRef))
+    (0, import_websocket.applyWebsocketSignal)(Sig, sigRef);
+  if (hasProcessor(sigRef))
+    (0, import_processor.applyQueueSignal)(Sig, sigRef);
+  return Sig;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  batchModuleOf,
   databaseModuleOf,
-  scalarModuleOf,
   scalarModulesOf,
   serviceModuleOf,
   useGlobals

package/cjs/src/processor.js

@@ -17,8 +17,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var processor_exports = {};
 __export(processor_exports, {
-  processorOf: () => processorOf,
-  queueOf: () => queueOf
+  applyQueueSignal: () => applyQueueSignal,
+  processorOf: () => processorOf
 });
 module.exports = __toCommonJS(processor_exports);
 var import_common = require("@akanjs/common");
@@ -51,14 +51,15 @@ 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 {
   }
-  Object.keys(allSrvs).forEach((srv) => {
-    if (!(0, import_service.isServiceEnabled)(allSrvs[srv]))
+  Object.keys(allSrvs).forEach((srvName) => {
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srvName]))
       return;
-    (0, import_common2.Inject)(allSrvs[srv])(QueueProcessor.prototype, (0, import_common.lowerlize)(srv));
+    const srvRef = (0, import_service.getServiceRefs)(srvName)[0];
+    (0, import_common2.Inject)(srvRef)(QueueProcessor.prototype, (0, import_common.lowerlize)(srvName));
   });
   for (const gqlMeta of gqlMetas) {
     const [argMetas, internalArgMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
@@ -75,18 +76,21 @@ const processorOf = (sigRef, allSrvs) => {
   (0, import_bull.Processor)(sigMeta.refName)(QueueProcessor);
   return QueueProcessor;
 };
-const queueOf = (sigRef, queue) => {
+const applyQueueSignal = (targetRef, sigRef) => {
   const sigMeta = (0, import_signal.getSigMeta)(sigRef);
   const gqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Process");
+  (0, import_common2.Inject)((0, import_bull.getQueueToken)(sigMeta.refName))(targetRef.prototype, "queue");
   for (const gqlMeta of gqlMetas) {
-    if (queue[gqlMeta.key])
+    if (targetRef.prototype[gqlMeta.key])
       throw new Error(`Queue already has ${gqlMeta.key} in ${sigMeta.refName}`);
-    queue[gqlMeta.key] = (...args) => queue.add(gqlMeta.key, args);
+    targetRef.prototype[gqlMeta.key] = function(...args) {
+      return this.queue.add(gqlMeta.key, args);
+    };
   }
-  return queue;
+  return targetRef;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  processorOf,
-  queueOf
+  applyQueueSignal,
+  processorOf
 });

package/cjs/src/resolver.js

@@ -71,10 +71,11 @@ const resolverOf = (sigRef, allSrvs) => {
   const Rsv = (0, import_signal.copySignal)(sigRef);
   const sigMeta = (0, import_signal.getSigMeta)(Rsv);
   const gqlMetas = (0, import_signal.getGqlMetas)(Rsv);
-  Object.keys(allSrvs).forEach((srv) => {
-    if (!(0, import_service.isServiceEnabled)(allSrvs[srv]))
+  Object.keys(allSrvs).forEach((srvName) => {
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srvName]))
       return;
-    (0, import_common2.Inject)(allSrvs[srv])(Rsv.prototype, (0, import_common.lowerlize)(srv));
+    const srvRef = (0, import_service.getServiceRefs)(srvName)[0];
+    (0, import_common2.Inject)(srvRef)(Rsv.prototype, (0, import_common.lowerlize)(srvName));
   });
   for (const gqlMeta of gqlMetas) {
     if (gqlMeta.guards.some((guard) => guard === "None") || gqlMeta.signalOption.onlyFor === "restapi" || !["Query", "Mutation"].includes(gqlMeta.type))

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