@akanjs/server 0.0.99 → 0.0.100

package/src/module.js

@@ -1,5 +1,20 @@
 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 __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--)
@@ -9,21 +24,31 @@ var __decorateClass = (decorators, target, key, kind) => {
     __defProp(target, key, result);
   return result;
 };
-import { capitalize, lowerlize } from "@akanjs/common";
-import { getChildClassRefs, getClassMeta } from "@akanjs/constant";
-import { databaseModelOf } from "@akanjs/document";
-import { isServiceEnabled, serviceOf } from "@akanjs/service";
-import { getGqlMetas, getSigMeta, LogSignal, Signal } from "@akanjs/signal";
-import { BullModule, getQueueToken } from "@nestjs/bull";
-import { Global, Module } from "@nestjs/common";
-import { getModelToken, MongooseModule } from "@nestjs/mongoose";
-import { controllerOf } from "./controller";
-import { processorOf } from "./processor";
-import { resolverOf } from "./resolver";
-import { addSchema, schemaOf } from "./schema";
-import { websocketOf, websocketServerOf } from "./websocket";
-const hasWebsocket = (signal) => getGqlMetas(signal).some((gqlMeta) => ["Message", "Pubsub"].includes(gqlMeta.type));
-const hasProcessor = (signal) => getGqlMetas(signal).some((gqlMeta) => gqlMeta.type === "Process");
+var module_exports = {};
+__export(module_exports, {
+  batchModuleOf: () => batchModuleOf,
+  databaseModuleOf: () => databaseModuleOf,
+  scalarModuleOf: () => scalarModuleOf,
+  scalarModulesOf: () => scalarModulesOf,
+  serviceModuleOf: () => serviceModuleOf,
+  useGlobals: () => useGlobals
+});
+module.exports = __toCommonJS(module_exports);
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_document = require("@akanjs/document");
+var import_service = require("@akanjs/service");
+var import_signal = require("@akanjs/signal");
+var import_bull = require("@nestjs/bull");
+var import_common2 = require("@nestjs/common");
+var import_mongoose = require("@nestjs/mongoose");
+var import_controller = require("./controller");
+var import_processor = require("./processor");
+var import_resolver = require("./resolver");
+var import_schema = require("./schema");
+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,
@@ -35,85 +60,85 @@ const databaseModuleOf = ({
   providers = [],
   extended
 }, allSrvs) => {
-  if (!isServiceEnabled(service))
+  if (!(0, import_service.isServiceEnabled)(service))
     return null;
-  const [modelName, className] = [lowerlize(constant.refName), capitalize(constant.refName)];
-  const mongoToken = getModelToken(className);
+  const [modelName, className] = [(0, import_common.lowerlize)(constant.refName), (0, import_common.capitalize)(constant.refName)];
+  const mongoToken = (0, import_mongoose.getModelToken)(className);
   let DatabaseModule = class {
   };
   DatabaseModule = __decorateClass([
-    Global(),
-    Module({
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
       imports: [
-        MongooseModule.forFeature([
+        import_mongoose.MongooseModule.forFeature([
           {
             name: className,
-            schema: extended ? addSchema(database.Model, database.Doc, database.Input, database.Middleware) : schemaOf(database.Model, database.Doc, database.Middleware)
+            schema: extended ? (0, import_schema.addSchema)(database.Model, database.Doc, database.Input, database.Middleware) : (0, import_schema.schemaOf)(database.Model, database.Doc, database.Middleware)
           }
         ]),
         ...hasProcessor(signal) ? [
-          BullModule.registerQueue({
+          import_bull.BullModule.registerQueue({
             name: modelName,
             defaultJobOptions: { removeOnComplete: true, removeOnFail: true }
           })
         ] : []
       ],
       providers: [
-        serviceOf(service),
-        resolverOf(signal, filterSrvs(allSrvs)),
+        (0, import_service.serviceOf)(service),
+        (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs)),
         ...hasProcessor(signal) ? [
-          processorOf(signal, filterSrvs(allSrvs)),
-          { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [getQueueToken(modelName)] }
+          (0, import_processor.processorOf)(signal, filterSrvs(allSrvs)),
+          { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [(0, import_bull.getQueueToken)(modelName)] }
         ] : [],
-        ...hasWebsocket(signal) ? [websocketOf(signal, filterSrvs(allSrvs)), { provide: "Websocket", useClass: websocketServerOf(signal) }] : [],
-        ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
-        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+        ...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 })),
         {
           provide: `${modelName}Model`,
           useFactory: (model, redis, meili) => {
-            return databaseModelOf(database, model, redis, meili);
+            return (0, import_document.databaseModelOf)(database, model, redis, meili);
           },
           inject: [mongoToken, "REDIS_CLIENT", "MEILI_CLIENT"]
         },
         ...providers
       ],
-      controllers: [controllerOf(signal, filterSrvs(allSrvs))],
+      controllers: [(0, import_controller.controllerOf)(signal, filterSrvs(allSrvs))],
       exports: [service]
     })
   ], DatabaseModule);
   return DatabaseModule;
 };
 const serviceModuleOf = ({ signal, service, uses = {}, useAsyncs = {}, providers = [] }, allSrvs) => {
-  if (!isServiceEnabled(service))
+  if (!(0, import_service.isServiceEnabled)(service))
     return null;
-  const sigMeta = getSigMeta(signal);
-  const [modelName, className] = [lowerlize(sigMeta.refName), capitalize(sigMeta.refName)];
+  const sigMeta = (0, import_signal.getSigMeta)(signal);
+  const [modelName, className] = [(0, import_common.lowerlize)(sigMeta.refName), (0, import_common.capitalize)(sigMeta.refName)];
   let ServiceModule = class {
   };
   ServiceModule = __decorateClass([
-    Global(),
-    Module({
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
       imports: [
         ...hasProcessor(signal) ? [
-          BullModule.registerQueue({
+          import_bull.BullModule.registerQueue({
             name: modelName,
             defaultJobOptions: { removeOnComplete: true, removeOnFail: true }
           })
         ] : []
       ],
       providers: [
-        serviceOf(service),
-        resolverOf(signal, filterSrvs(allSrvs)),
-        ...hasWebsocket(signal) ? [websocketOf(signal, filterSrvs(allSrvs)), { provide: "Websocket", useClass: websocketServerOf(signal) }] : [],
+        (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) ? [
-          processorOf(signal, filterSrvs(allSrvs)),
-          { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [getQueueToken(modelName)] }
+          (0, import_processor.processorOf)(signal, filterSrvs(allSrvs)),
+          { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [(0, import_bull.getQueueToken)(modelName)] }
         ] : [],
-        ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
-        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+        ...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: [controllerOf(signal, filterSrvs(allSrvs))],
+      controllers: [(0, import_controller.controllerOf)(signal, filterSrvs(allSrvs))],
       exports: [service]
     })
   ], ServiceModule);
@@ -125,46 +150,46 @@ const scalarModuleOf = ({ signals, uses = {}, useAsyncs = {}, providers = [], en
   let ScalarModule = class {
   };
   ScalarModule = __decorateClass([
-    Global(),
-    Module({
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
       imports: [],
       providers: [
-        ...signals.map((signal) => resolverOf(signal, filterSrvs(allSrvs))),
+        ...signals.map((signal) => (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs))),
         ...signals.filter(hasWebsocket).map((signal) => [
-          websocketOf(signal, filterSrvs(allSrvs)),
-          { provide: "Websocket", useClass: websocketServerOf(signal) }
+          (0, import_websocket.websocketOf)(signal, filterSrvs(allSrvs)),
+          { provide: "Websocket", useClass: (0, import_websocket.websocketServerOf)(signal) }
         ]).flat(),
-        ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
-        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+        ...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) => controllerOf(signal, filterSrvs(allSrvs)))
+      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 = getChildClassRefs(modelRef);
+    const childRefs = (0, import_constant.getChildClassRefs)(modelRef);
     return childRefs.some((childRef) => {
-      const classMeta = getClassMeta(childRef);
+      const classMeta = (0, import_constant.getClassMeta)(childRef);
       return ["full", "light"].includes(classMeta.type);
     });
   }).map((modelRef) => {
-    let ScalarSignal = class extends LogSignal({}) {
+    let ScalarSignal = class extends (0, import_signal.LogSignal)({}) {
     };
     ScalarSignal = __decorateClass([
-      Signal(() => modelRef)
+      (0, import_signal.Signal)(() => modelRef)
     ], ScalarSignal);
     return ScalarSignal;
   });
   let ScalarModule = class {
   };
   ScalarModule = __decorateClass([
-    Global(),
-    Module({
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
       imports: [],
-      providers: [...signals.map((signal) => resolverOf(signal, filterSrvs(allSrvs)))]
+      providers: [...signals.map((signal) => (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs)))]
       // controllers: signals.map((signal) => controllerOf(signal, filterSrvs(allSrvs))),
     })
   ], ScalarModule);
@@ -176,18 +201,18 @@ const batchModuleOf = ({
   useAsyncs = {},
   providers = []
 }) => {
-  if (!isServiceEnabled(service))
+  if (!(0, import_service.isServiceEnabled)(service))
     return null;
   let BatchModule = class {
   };
   BatchModule = __decorateClass([
-    Global(),
-    Module({
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
       imports: [],
       providers: [
-        serviceOf(service),
-        ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
-        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+        (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]
@@ -199,31 +224,32 @@ const useGlobals = ({ uses, useAsyncs, injects }) => {
   let GlobalsModule = class {
   };
   GlobalsModule = __decorateClass([
-    Global(),
-    Module({
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
       imports: [],
       providers: [
         ...Object.entries(uses ?? {}).map(([key, useValue]) => ({
-          provide: capitalize(key),
+          provide: (0, import_common.capitalize)(key),
           useValue
         })),
-        ...Object.entries(useAsyncs ?? {}).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
-        ...Object.entries(injects ?? {}).map(([key, inject]) => ({ provide: capitalize(key), useClass: inject }))
+        ...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 }))
       ],
       exports: [
-        ...Object.keys(uses ?? {}).map((key) => capitalize(key)),
-        ...Object.keys(useAsyncs ?? {}).map((key) => capitalize(key)),
-        ...Object.keys(injects ?? {}).map((key) => capitalize(key))
+        ...Object.keys(uses ?? {}).map((key) => (0, import_common.capitalize)(key)),
+        ...Object.keys(useAsyncs ?? {}).map((key) => (0, import_common.capitalize)(key)),
+        ...Object.keys(injects ?? {}).map((key) => (0, import_common.capitalize)(key))
       ]
     })
   ], GlobalsModule);
   return GlobalsModule;
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   batchModuleOf,
   databaseModuleOf,
   scalarModuleOf,
   scalarModulesOf,
   serviceModuleOf,
   useGlobals
-};
+});

package/src/module.mjs

@@ -0,0 +1,229 @@
+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, lowerlize } from "@akanjs/common";
+import { getChildClassRefs, getClassMeta } from "@akanjs/constant";
+import { databaseModelOf } from "@akanjs/document";
+import { isServiceEnabled, serviceOf } from "@akanjs/service";
+import { getGqlMetas, getSigMeta, LogSignal, Signal } from "@akanjs/signal";
+import { BullModule, getQueueToken } from "@nestjs/bull";
+import { Global, Module } from "@nestjs/common";
+import { getModelToken, MongooseModule } from "@nestjs/mongoose";
+import { controllerOf } from "./controller";
+import { processorOf } from "./processor";
+import { resolverOf } from "./resolver";
+import { addSchema, schemaOf } from "./schema";
+import { websocketOf, websocketServerOf } from "./websocket";
+const hasWebsocket = (signal) => getGqlMetas(signal).some((gqlMeta) => ["Message", "Pubsub"].includes(gqlMeta.type));
+const hasProcessor = (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) => {
+  if (!isServiceEnabled(service))
+    return null;
+  const [modelName, className] = [lowerlize(constant.refName), capitalize(constant.refName)];
+  const mongoToken = getModelToken(className);
+  let DatabaseModule = class {
+  };
+  DatabaseModule = __decorateClass([
+    Global(),
+    Module({
+      imports: [
+        MongooseModule.forFeature([
+          {
+            name: className,
+            schema: extended ? addSchema(database.Model, database.Doc, database.Input, database.Middleware) : schemaOf(database.Model, database.Doc, database.Middleware)
+          }
+        ]),
+        ...hasProcessor(signal) ? [
+          BullModule.registerQueue({
+            name: modelName,
+            defaultJobOptions: { removeOnComplete: true, removeOnFail: true }
+          })
+        ] : []
+      ],
+      providers: [
+        serviceOf(service),
+        resolverOf(signal, filterSrvs(allSrvs)),
+        ...hasProcessor(signal) ? [
+          processorOf(signal, filterSrvs(allSrvs)),
+          { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [getQueueToken(modelName)] }
+        ] : [],
+        ...hasWebsocket(signal) ? [websocketOf(signal, filterSrvs(allSrvs)), { provide: "Websocket", useClass: websocketServerOf(signal) }] : [],
+        ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
+        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+        {
+          provide: `${modelName}Model`,
+          useFactory: (model, redis, meili) => {
+            return databaseModelOf(database, model, redis, meili);
+          },
+          inject: [mongoToken, "REDIS_CLIENT", "MEILI_CLIENT"]
+        },
+        ...providers
+      ],
+      controllers: [controllerOf(signal, filterSrvs(allSrvs))],
+      exports: [service]
+    })
+  ], DatabaseModule);
+  return DatabaseModule;
+};
+const serviceModuleOf = ({ signal, service, uses = {}, useAsyncs = {}, providers = [] }, allSrvs) => {
+  if (!isServiceEnabled(service))
+    return null;
+  const sigMeta = getSigMeta(signal);
+  const [modelName, className] = [lowerlize(sigMeta.refName), capitalize(sigMeta.refName)];
+  let ServiceModule = class {
+  };
+  ServiceModule = __decorateClass([
+    Global(),
+    Module({
+      imports: [
+        ...hasProcessor(signal) ? [
+          BullModule.registerQueue({
+            name: modelName,
+            defaultJobOptions: { removeOnComplete: true, removeOnFail: true }
+          })
+        ] : []
+      ],
+      providers: [
+        serviceOf(service),
+        resolverOf(signal, filterSrvs(allSrvs)),
+        ...hasWebsocket(signal) ? [websocketOf(signal, filterSrvs(allSrvs)), { provide: "Websocket", useClass: websocketServerOf(signal) }] : [],
+        ...hasProcessor(signal) ? [
+          processorOf(signal, filterSrvs(allSrvs)),
+          { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [getQueueToken(modelName)] }
+        ] : [],
+        ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
+        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+        ...providers
+      ],
+      controllers: [controllerOf(signal, filterSrvs(allSrvs))],
+      exports: [service]
+    })
+  ], ServiceModule);
+  return ServiceModule;
+};
+const scalarModuleOf = ({ signals, uses = {}, useAsyncs = {}, providers = [], enabled = true }, allSrvs) => {
+  if (!enabled)
+    return null;
+  let ScalarModule = class {
+  };
+  ScalarModule = __decorateClass([
+    Global(),
+    Module({
+      imports: [],
+      providers: [
+        ...signals.map((signal) => resolverOf(signal, filterSrvs(allSrvs))),
+        ...signals.filter(hasWebsocket).map((signal) => [
+          websocketOf(signal, filterSrvs(allSrvs)),
+          { provide: "Websocket", useClass: websocketServerOf(signal) }
+        ]).flat(),
+        ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
+        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+        ...providers
+      ],
+      controllers: signals.map((signal) => controllerOf(signal, filterSrvs(allSrvs)))
+    })
+  ], ScalarModule);
+  return ScalarModule;
+};
+const scalarModulesOf = ({ constants }, allSrvs) => {
+  const signals = constants.filter((modelRef) => {
+    const childRefs = getChildClassRefs(modelRef);
+    return childRefs.some((childRef) => {
+      const classMeta = getClassMeta(childRef);
+      return ["full", "light"].includes(classMeta.type);
+    });
+  }).map((modelRef) => {
+    let ScalarSignal = class extends LogSignal({}) {
+    };
+    ScalarSignal = __decorateClass([
+      Signal(() => modelRef)
+    ], ScalarSignal);
+    return ScalarSignal;
+  });
+  let ScalarModule = class {
+  };
+  ScalarModule = __decorateClass([
+    Global(),
+    Module({
+      imports: [],
+      providers: [...signals.map((signal) => resolverOf(signal, filterSrvs(allSrvs)))]
+      // controllers: signals.map((signal) => controllerOf(signal, filterSrvs(allSrvs))),
+    })
+  ], ScalarModule);
+  return ScalarModule;
+};
+const batchModuleOf = ({
+  service,
+  uses = {},
+  useAsyncs = {},
+  providers = []
+}) => {
+  if (!isServiceEnabled(service))
+    return null;
+  let BatchModule = class {
+  };
+  BatchModule = __decorateClass([
+    Global(),
+    Module({
+      imports: [],
+      providers: [
+        serviceOf(service),
+        ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
+        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+        ...providers
+      ],
+      exports: [service]
+    })
+  ], BatchModule);
+  return BatchModule;
+};
+const useGlobals = ({ uses, useAsyncs, injects }) => {
+  let GlobalsModule = class {
+  };
+  GlobalsModule = __decorateClass([
+    Global(),
+    Module({
+      imports: [],
+      providers: [
+        ...Object.entries(uses ?? {}).map(([key, useValue]) => ({
+          provide: capitalize(key),
+          useValue
+        })),
+        ...Object.entries(useAsyncs ?? {}).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+        ...Object.entries(injects ?? {}).map(([key, inject]) => ({ provide: capitalize(key), useClass: inject }))
+      ],
+      exports: [
+        ...Object.keys(uses ?? {}).map((key) => capitalize(key)),
+        ...Object.keys(useAsyncs ?? {}).map((key) => capitalize(key)),
+        ...Object.keys(injects ?? {}).map((key) => capitalize(key))
+      ]
+    })
+  ], GlobalsModule);
+  return GlobalsModule;
+};
+export {
+  batchModuleOf,
+  databaseModuleOf,
+  scalarModuleOf,
+  scalarModulesOf,
+  serviceModuleOf,
+  useGlobals
+};

package/src/processor.js

@@ -1,19 +1,37 @@
-import { lowerlize } from "@akanjs/common";
-import { isServiceEnabled } from "@akanjs/service";
-import {
-  deserializeArg,
-  getArgMetas,
-  getGqlMetas,
-  getSigMeta
-} from "@akanjs/signal";
-import { Process, Processor } from "@nestjs/bull";
-import { Inject } from "@nestjs/common";
+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 processor_exports = {};
+__export(processor_exports, {
+  processorOf: () => processorOf,
+  queueOf: () => queueOf
+});
+module.exports = __toCommonJS(processor_exports);
+var import_common = require("@akanjs/common");
+var import_service = require("@akanjs/service");
+var import_signal = require("@akanjs/signal");
+var import_bull = require("@nestjs/bull");
+var import_common2 = require("@nestjs/common");
 const convertProcessFunction = (gqlMeta, argMetas, internalArgMetas, fn) => {
   return async function(job, done) {
     const args = [];
     argMetas.forEach((argMeta) => {
       if (argMeta.type === "Msg")
-        args[argMeta.idx] = deserializeArg(argMeta, job.data[argMeta.idx]);
+        args[argMeta.idx] = (0, import_signal.deserializeArg)(argMeta, job.data[argMeta.idx]);
       else
         throw new Error(`Invalid ArgMeta Type ${argMeta.type}`);
     });
@@ -30,20 +48,20 @@ const convertProcessFunction = (gqlMeta, argMetas, internalArgMetas, fn) => {
   };
 };
 const processorOf = (sigRef, allSrvs) => {
-  const sigMeta = getSigMeta(sigRef);
+  const sigMeta = (0, import_signal.getSigMeta)(sigRef);
   const serverMode = process.env.SERVER_MODE ?? "federation";
-  const gqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Process").filter(
+  const gqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Process").filter(
     (gqlMeta) => gqlMeta.signalOption.serverType === "all" || serverMode === "all" || gqlMeta.signalOption.serverType === serverMode
   );
   class QueueProcessor {
   }
   Object.keys(allSrvs).forEach((srv) => {
-    if (!isServiceEnabled(allSrvs[srv]))
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srv]))
       return;
-    Inject(allSrvs[srv])(QueueProcessor.prototype, lowerlize(srv));
+    (0, import_common2.Inject)(allSrvs[srv])(QueueProcessor.prototype, (0, import_common.lowerlize)(srv));
   });
   for (const gqlMeta of gqlMetas) {
-    const [argMetas, internalArgMetas] = getArgMetas(sigRef, gqlMeta.key);
+    const [argMetas, internalArgMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
     const descriptor = { ...Object.getOwnPropertyDescriptor(sigRef.prototype, gqlMeta.key) ?? {} };
     descriptor.value = convertProcessFunction(
       gqlMeta,
@@ -52,14 +70,14 @@ const processorOf = (sigRef, allSrvs) => {
       descriptor.value
     );
     Object.defineProperty(QueueProcessor.prototype, gqlMeta.key, descriptor);
-    Process(gqlMeta.key)(QueueProcessor.prototype, gqlMeta.key, descriptor);
+    (0, import_bull.Process)(gqlMeta.key)(QueueProcessor.prototype, gqlMeta.key, descriptor);
   }
-  Processor(sigMeta.refName)(QueueProcessor);
+  (0, import_bull.Processor)(sigMeta.refName)(QueueProcessor);
   return QueueProcessor;
 };
 const queueOf = (sigRef, queue) => {
-  const sigMeta = getSigMeta(sigRef);
-  const gqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Process");
+  const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+  const gqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Process");
   for (const gqlMeta of gqlMetas) {
     if (queue[gqlMeta.key])
       throw new Error(`Queue already has ${gqlMeta.key} in ${sigMeta.refName}`);
@@ -67,7 +85,8 @@ const queueOf = (sigRef, queue) => {
   }
   return queue;
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   processorOf,
   queueOf
-};
+});