@akanjs/server 0.9.41 → 0.9.43

package/cjs/src/schema.js

@@ -18,6 +18,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var schema_exports = {};
 __export(schema_exports, {
   addSchema: () => addSchema,
+  hasSchema: () => hasSchema,
   schemaOf: () => schemaOf
 });
 module.exports = __toCommonJS(schema_exports);
@@ -32,6 +33,24 @@ class ScalarSchemaStorage {
 }
 class SchemaStorage {
 }
+const getSchemaMetaByName = (refName) => {
+  const schemaMeta = Reflect.getMetadata(refName, SchemaStorage.prototype);
+  return schemaMeta;
+};
+const setSchemaMetaByName = (refName, schema) => {
+  Reflect.defineMetadata(refName, schema, SchemaStorage.prototype);
+};
+const hasSchema = (modelRef) => {
+  const classMeta = (0, import_constant.getClassMeta)(modelRef);
+  return !!getSchemaMetaByName(classMeta.refName);
+};
+const getScalarSchemaMetaByName = (refName) => {
+  const schemaMeta = Reflect.getMetadata(refName, ScalarSchemaStorage.prototype);
+  return schemaMeta;
+};
+const setScalarSchemaMetaByName = (refName, schema) => {
+  Reflect.defineMetadata(refName, schema, ScalarSchemaStorage.prototype);
+};
 const scalarMongoTypeMap = /* @__PURE__ */ new Map([
   [import_base.ID, import_document.ObjectId],
   [import_base.Int, Number],
@@ -71,12 +90,12 @@ const applyMongoProp = (schemaProps, fieldMeta) => {
     }
     prop = { type: (0, import_base.arraiedModel)(prop, fieldMeta.optArrDepth), default: [], required: true };
     if (fieldMeta.modelRef.prototype === Date.prototype) {
-      prop.get = (dates) => dates.map((date) => (0, import_base.dayjs)(date));
-      prop.set = (days) => days.map((day) => day.toDate());
+      prop.get = (dates) => (0, import_base.applyFnToArrayObjects)(dates, (date) => (0, import_base.dayjs)(date));
+      prop.set = (days) => (0, import_base.applyFnToArrayObjects)(days, (day) => day.toDate());
     }
     if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === import_base.ID.prototype) {
-      prop.get = (ids) => ids.map((id) => id.toString());
-      prop.set = (ids) => ids.map((id) => new import_mongoose.Types.ObjectId(id));
+      prop.get = (ids) => (0, import_base.applyFnToArrayObjects)(ids, (id) => id.toString());
+      prop.set = (ids) => (0, import_base.applyFnToArrayObjects)(ids, (id) => new import_mongoose.Types.ObjectId(id));
     }
   } else {
     prop.type = (0, import_base.arraiedModel)(type, fieldMeta.arrDepth);
@@ -118,12 +137,17 @@ const applyMongoProp = (schemaProps, fieldMeta) => {
       prop.set = (v) => v === null ? void 0 : v;
     }
     if (fieldMeta.modelRef.prototype === Date.prototype) {
-      prop.get = (date) => date ? (0, import_base.dayjs)(date) : void 0;
-      prop.set = (day) => day ? (0, import_base.dayjs)(day).toDate() : void 0;
+      prop.get = (date) => (0, import_base.applyFnToArrayObjects)(date, (date2) => date2 ? (0, import_base.dayjs)(date2) : void 0);
+      prop.set = (day) => (0, import_base.applyFnToArrayObjects)(day, (day2) => day2 ? (0, import_base.dayjs)(day2).toDate() : void 0);
     }
     if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === import_base.ID.prototype) {
-      prop.get = (id) => id ? id.toString() : void 0;
-      prop.set = (id) => id ? new import_mongoose.Types.ObjectId(id) : void 0;
+      if (fieldMeta.arrDepth === 0) {
+        prop.get = (id) => id ? id.toString() : void 0;
+        prop.set = (id) => id ? new import_mongoose.Types.ObjectId(id) : void 0;
+      } else {
+        prop.get = (val) => (0, import_base.applyFnToArrayObjects)(val, (id) => id ? id.toString() : void 0);
+        prop.set = (val) => (0, import_base.applyFnToArrayObjects)(val, (id) => id ? new import_mongoose.Types.ObjectId(id) : void 0);
+      }
     }
     if (fieldMeta.isClass && fieldMeta.isScalar && fieldMeta.default === null && !fieldMeta.nullable) {
       prop.default = (0, import_signal.makeDefault)(fieldMeta.modelRef);
@@ -138,7 +162,7 @@ const applyMongoProp = (schemaProps, fieldMeta) => {
 };
 const createSchema = (modelRef) => {
   const classMeta = (0, import_constant.getClassMeta)(modelRef);
-  const schemaMeta = Reflect.getMetadata(classMeta.refName, ScalarSchemaStorage.prototype);
+  const schemaMeta = getScalarSchemaMetaByName(classMeta.refName);
   if (schemaMeta)
     return schemaMeta;
   const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
@@ -147,12 +171,12 @@ const createSchema = (modelRef) => {
     applyMongoProp(schemaProps, fieldMeta);
   });
   const schema = new import_mongoose.Schema(schemaProps);
-  Reflect.defineMetadata(classMeta.refName, schema, ScalarSchemaStorage.prototype);
+  setScalarSchemaMetaByName(classMeta.refName, schema);
   return schema;
 };
 const schemaOf = (modelRef, docRef, middleware) => {
   const classMeta = (0, import_constant.getClassMeta)(docRef);
-  const schemaMeta = Reflect.getMetadata(classMeta.refName, SchemaStorage.prototype);
+  const schemaMeta = getSchemaMetaByName(classMeta.refName);
   if (schemaMeta)
     return schemaMeta;
   const fieldMetas = (0, import_constant.getFieldMetas)(docRef);
@@ -192,7 +216,7 @@ const schemaOf = (modelRef, docRef, middleware) => {
   const onSchema = Object.getOwnPropertyDescriptor(middleware.prototype, "onSchema")?.value;
   onSchema?.(schema);
   schema.index({ removedAt: -1 });
-  Reflect.defineMetadata(classMeta.refName, schema, SchemaStorage.prototype);
+  setSchemaMetaByName(classMeta.refName, schema);
   return schema;
 };
 const addSchema = (modelRef, docRef, inputRef, middleware) => {
@@ -239,5 +263,6 @@ const addSchema = (modelRef, docRef, inputRef, middleware) => {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   addSchema,
+  hasSchema,
   schemaOf
 });

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/cjs/src/websocket.js

@@ -26,8 +26,8 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 var websocket_exports = {};
 __export(websocket_exports, {
-  websocketOf: () => websocketOf,
-  websocketServerOf: () => websocketServerOf
+  applyWebsocketSignal: () => applyWebsocketSignal,
+  websocketOf: () => websocketOf
 });
 module.exports = __toCommonJS(websocket_exports);
 var import_common = require("@akanjs/common");
@@ -73,10 +73,11 @@ const websocketOf = (sigRef, allSrvs) => {
   class WsGateway {
     __sigRef__ = 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])(WsGateway.prototype, (0, import_common.lowerlize)(srv));
+    const srvRef = (0, import_service.getServiceRefs)(srvName)[0];
+    (0, import_common2.Inject)(srvRef)(WsGateway.prototype, (0, import_common.lowerlize)(srvName));
   });
   const messageGqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Message");
   for (const gqlMeta of messageGqlMetas) {
@@ -115,32 +116,24 @@ const websocketOf = (sigRef, allSrvs) => {
   (0, import_websockets.WebSocketGateway)({ cors: { origin: "*" }, transports: ["websocket"] })(WsGateway);
   return WsGateway;
 };
-const websocketServerOf = (sigRef) => {
+const applyWebsocketSignal = (targetRef, sigRef) => {
   const pubsubGqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Pubsub");
-  let Websocket = class {
-    server;
-  };
-  __decorateClass([
-    (0, import_websockets.WebSocketServer)()
-  ], Websocket.prototype, "server", 2);
-  Websocket = __decorateClass([
-    (0, import_common2.Injectable)(),
-    (0, import_websockets.WebSocketGateway)({ cors: { origin: "*" }, transports: ["websocket"] })
-  ], Websocket);
+  (0, import_websockets.WebSocketGateway)({ cors: { origin: "*" }, transports: ["websocket"] })(targetRef);
+  (0, import_websockets.WebSocketServer)()(targetRef.prototype, "websocket");
   for (const gqlMeta of pubsubGqlMetas) {
     const [argMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
-    Websocket.prototype[gqlMeta.key] = function(...args) {
+    targetRef.prototype[gqlMeta.key] = function(...args) {
       const roomId = makeRoomId(
         gqlMeta.key,
         argMetas.map((argMeta) => args[argMeta.idx])
       );
-      this.server.to(roomId).emit(roomId, args.at(-1));
+      this.websocket.to(roomId).emit(roomId, args.at(-1));
     };
   }
-  return Websocket;
+  return targetRef;
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  websocketOf,
-  websocketServerOf
+  applyWebsocketSignal,
+  websocketOf
 });

package/esm/src/base.module.js

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

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");
@@ -89,9 +90,9 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
     Injectable()
   ], AuthMiddleWare);
   const redisClient = await createClient({ url: redisUri }).connect();
-  let SubDatabaseModule = class {
+  let GlobalProvideModule = class {
   };
-  SubDatabaseModule = __decorateClass([
+  GlobalProvideModule = __decorateClass([
     Global(),
     Module({
       providers: [
@@ -99,11 +100,12 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
         {
           provide: "MEILI_CLIENT",
           useFactory: () => new MeiliSearch({ host: meiliUri, apiKey: 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: RequestMethod.ALL });
@@ -130,12 +132,13 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
         MongooseModule.forRootAsync({
           useFactory: () => ({ uri: mongoUri, autoIndex: baseEnv.environment !== "main" })
         }),
-        SubDatabaseModule,
+        GlobalProvideModule,
         useGlobals({
           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/controller.js

@@ -13,7 +13,7 @@ import {
   Self,
   UserIp
 } from "@akanjs/nest";
-import { isServiceEnabled } from "@akanjs/service";
+import { getServiceRefs, isServiceEnabled } from "@akanjs/service";
 import {
   copySignal,
   getArgMetas,
@@ -51,10 +51,11 @@ const controllerOf = (sigRef, allSrvs) => {
   const gqlMetas = getGqlMetas(sigRef);
   const prefix = getControllerPrefix(sigMeta);
   const Ctrl = copySignal(sigRef);
-  Object.keys(allSrvs).forEach((srv) => {
-    if (!isServiceEnabled(allSrvs[srv]))
+  Object.keys(allSrvs).forEach((srvName) => {
+    if (!isServiceEnabled(allSrvs[srvName]))
       return;
-    Inject(allSrvs[srv])(Ctrl.prototype, lowerlize(srv));
+    const srvRef = getServiceRefs(srvName)[0];
+    Inject(srvRef)(Ctrl.prototype, lowerlize(srvName));
   });
   for (const gqlMeta of gqlMetas) {
     if (gqlMeta.guards.some((guard) => guard === "None") || gqlMeta.signalOption.onlyFor === "graphql" || !["Query", "Mutation"].includes(gqlMeta.type))

package/esm/src/module.js

@@ -12,33 +12,25 @@ var __decorateClass = (decorators, target, key, kind) => {
 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 { getServiceMeta, isServiceEnabled, makeProvidersForSrv, serviceOf } from "@akanjs/service";
+import { getGqlMetas, LogSignal, Signal } from "@akanjs/signal";
+import { BullModule } from "@nestjs/bull";
+import { Global, Injectable, Module } from "@nestjs/common";
 import { getModelToken, MongooseModule } from "@nestjs/mongoose";
 import { controllerOf } from "./controller";
-import { processorOf } from "./processor";
+import { applyQueueSignal, processorOf } from "./processor";
 import { resolverOf } from "./resolver";
-import { addSchema, schemaOf } from "./schema";
-import { websocketOf, websocketServerOf } from "./websocket";
+import { addSchema, hasSchema, schemaOf } from "./schema";
+import { applyWebsocketSignal, websocketOf } 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) => {
+const databaseModuleOf = ({ constant, database, signal, service }, allSrvs) => {
   if (!isServiceEnabled(service))
     return null;
   const [modelName, className] = [lowerlize(constant.refName), capitalize(constant.refName)];
   const mongoToken = getModelToken(className);
+  const srvRef = serviceOf(service);
   let DatabaseModule = class {
   };
   DatabaseModule = __decorateClass([
@@ -48,7 +40,7 @@ const databaseModuleOf = ({
         MongooseModule.forFeature([
           {
             name: className,
-            schema: extended ? addSchema(database.Model, database.Doc, database.Input, database.Middleware) : schemaOf(database.Model, database.Doc, database.Middleware)
+            schema: hasSchema(constant.Full) ? addSchema(database.Model, database.Doc, database.Input, database.Middleware) : schemaOf(database.Model, database.Doc, database.Middleware)
           }
         ]),
         ...hasProcessor(signal) ? [
@@ -59,15 +51,11 @@ const databaseModuleOf = ({
         ] : []
       ],
       providers: [
-        serviceOf(service),
+        ...service === srvRef ? [srvRef] : [],
         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 })),
+        ...hasWebsocket(signal) ? [websocketOf(signal, filterSrvs(allSrvs))] : [],
+        ...hasProcessor(signal) ? [processorOf(signal, filterSrvs(allSrvs))] : [],
+        { provide: `${className}Signal`, useClass: makeSigForSrv(signal) },
         {
           provide: `${modelName}Model`,
           useFactory: (model, redis, meili) => {
@@ -75,74 +63,52 @@ const databaseModuleOf = ({
           },
           inject: [mongoToken, "REDIS_CLIENT", "MEILI_CLIENT"]
         },
-        ...providers
+        ...makeProvidersForSrv(srvRef)
       ],
       controllers: [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 (!isServiceEnabled(service))
     return null;
-  const sigMeta = getSigMeta(signal);
-  const [modelName, className] = [lowerlize(sigMeta.refName), capitalize(sigMeta.refName)];
+  const serviceMeta = getServiceMeta(service);
+  if (!serviceMeta)
+    throw new Error(`Service ${service} is not a valid service`);
+  const refName = serviceMeta.name.replace("Service", "");
+  const [modelName, className] = [lowerlize(refName), capitalize(refName)];
+  const srvRef = serviceOf(service);
   let ServiceModule = class {
   };
   ServiceModule = __decorateClass([
     Global(),
     Module({
-      imports: [
+      imports: signal ? [
         ...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)] }
+        ...service === srvRef ? [srvRef] : [],
+        ...signal ? [
+          resolverOf(signal, filterSrvs(allSrvs)),
+          ...hasWebsocket(signal) ? [websocketOf(signal, filterSrvs(allSrvs))] : [],
+          ...hasProcessor(signal) ? [processorOf(signal, filterSrvs(allSrvs))] : [],
+          { provide: `${className}Signal`, useClass: makeSigForSrv(signal) }
         ] : [],
-        ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
-        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
-        ...providers
+        ...makeProvidersForSrv(srvRef)
       ],
-      controllers: [controllerOf(signal, filterSrvs(allSrvs))],
-      exports: [service]
+      controllers: signal ? [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([
-    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);
@@ -169,32 +135,7 @@ const scalarModulesOf = ({ constants }, 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 }) => {
+const useGlobals = ({ uses, useAsyncs, providers = [], injects }) => {
   let GlobalsModule = class {
   };
   GlobalsModule = __decorateClass([
@@ -207,7 +148,8 @@ const useGlobals = ({ uses, useAsyncs, injects }) => {
           useValue
         })),
         ...Object.entries(useAsyncs ?? {}).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
-        ...Object.entries(injects ?? {}).map(([key, inject]) => ({ provide: capitalize(key), useClass: inject }))
+        ...Object.entries(injects ?? {}).map(([key, inject]) => ({ provide: capitalize(key), useClass: inject })),
+        ...providers
       ],
       exports: [
         ...Object.keys(uses ?? {}).map((key) => capitalize(key)),
@@ -218,10 +160,20 @@ const useGlobals = ({ uses, useAsyncs, injects }) => {
   ], GlobalsModule);
   return GlobalsModule;
 };
+const makeSigForSrv = (sigRef) => {
+  let Sig = class {
+  };
+  Sig = __decorateClass([
+    Injectable()
+  ], Sig);
+  if (hasWebsocket(sigRef))
+    applyWebsocketSignal(Sig, sigRef);
+  if (hasProcessor(sigRef))
+    applyQueueSignal(Sig, sigRef);
+  return Sig;
+};
 export {
-  batchModuleOf,
   databaseModuleOf,
-  scalarModuleOf,
   scalarModulesOf,
   serviceModuleOf,
   useGlobals

package/esm/src/processor.js

@@ -1,12 +1,12 @@
 import { lowerlize } from "@akanjs/common";
-import { isServiceEnabled } from "@akanjs/service";
+import { getServiceRefs, isServiceEnabled } from "@akanjs/service";
 import {
   deserializeArg,
   getArgMetas,
   getGqlMetas,
   getSigMeta
 } from "@akanjs/signal";
-import { Process, Processor } from "@nestjs/bull";
+import { getQueueToken, Process, Processor } from "@nestjs/bull";
 import { Inject } from "@nestjs/common";
 const convertProcessFunction = (gqlMeta, argMetas, internalArgMetas, fn) => {
   return async function(job, done) {
@@ -33,14 +33,15 @@ 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 {
   }
-  Object.keys(allSrvs).forEach((srv) => {
-    if (!isServiceEnabled(allSrvs[srv]))
+  Object.keys(allSrvs).forEach((srvName) => {
+    if (!isServiceEnabled(allSrvs[srvName]))
       return;
-    Inject(allSrvs[srv])(QueueProcessor.prototype, lowerlize(srv));
+    const srvRef = getServiceRefs(srvName)[0];
+    Inject(srvRef)(QueueProcessor.prototype, lowerlize(srvName));
   });
   for (const gqlMeta of gqlMetas) {
     const [argMetas, internalArgMetas] = getArgMetas(sigRef, gqlMeta.key);
@@ -57,17 +58,20 @@ const processorOf = (sigRef, allSrvs) => {
   Processor(sigMeta.refName)(QueueProcessor);
   return QueueProcessor;
 };
-const queueOf = (sigRef, queue) => {
+const applyQueueSignal = (targetRef, sigRef) => {
   const sigMeta = getSigMeta(sigRef);
   const gqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Process");
+  Inject(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;
 };
 export {
-  processorOf,
-  queueOf
+  applyQueueSignal,
+  processorOf
 };

package/esm/src/resolver.js

@@ -2,7 +2,7 @@ import { arraiedModel, Float, getNonArrayModel, ID, Int, JSON, Upload } from "@a
 import { capitalize, lowerlize } from "@akanjs/common";
 import { getClassMeta, getFieldMetas } from "@akanjs/constant";
 import { Access, Account, guards, Me, Req, Res, Self, UserIp } from "@akanjs/nest";
-import { isServiceEnabled } from "@akanjs/service";
+import { getServiceRefs, isServiceEnabled } from "@akanjs/service";
 import {
   copySignal,
   getArgMetas,
@@ -45,10 +45,11 @@ const resolverOf = (sigRef, allSrvs) => {
   const Rsv = copySignal(sigRef);
   const sigMeta = getSigMeta(Rsv);
   const gqlMetas = getGqlMetas(Rsv);
-  Object.keys(allSrvs).forEach((srv) => {
-    if (!isServiceEnabled(allSrvs[srv]))
+  Object.keys(allSrvs).forEach((srvName) => {
+    if (!isServiceEnabled(allSrvs[srvName]))
       return;
-    Inject(allSrvs[srv])(Rsv.prototype, lowerlize(srv));
+    const srvRef = getServiceRefs(srvName)[0];
+    Inject(srvRef)(Rsv.prototype, lowerlize(srvName));
   });
   for (const gqlMeta of gqlMetas) {
     if (gqlMeta.guards.some((guard) => guard === "None") || gqlMeta.signalOption.onlyFor === "restapi" || !["Query", "Mutation"].includes(gqlMeta.type))