@akanjs/server 0.0.39 → 0.0.40

package/src/gql.js

@@ -0,0 +1,172 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gql_exports = {};
+__export(gql_exports, {
+  DateScalar: () => DateScalar,
+  applyNestField: () => applyNestField,
+  generateGql: () => generateGql,
+  generateGqlInput: () => generateGqlInput
+});
+module.exports = __toCommonJS(gql_exports);
+var import_base = require("@akanjs/base");
+var import_constant = require("@akanjs/constant");
+var Nest = __toESM(require("@nestjs/graphql"));
+var import_graphql = require("@nestjs/graphql");
+var import_dayjs = require("dayjs");
+var import_graphql2 = require("graphql");
+var import_graphql_type_json = __toESM(require("graphql-type-json"));
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+class DateScalar {
+  static {
+    __name(this, "DateScalar");
+  }
+  description = "Date custom scalar type";
+  parseValue(value) {
+    return (0, import_base.dayjs)(value);
+  }
+  serialize(value) {
+    if ((0, import_dayjs.isDayjs)(value)) return value.toDate();
+    else return new Date(value);
+  }
+  parseLiteral(ast) {
+    if (ast.kind === import_graphql2.Kind.INT) return (0, import_base.dayjs)(ast.value);
+    else if (ast.kind === import_graphql2.Kind.STRING) return (0, import_base.dayjs)(ast.value);
+    else return null;
+  }
+}
+DateScalar = _ts_decorate([
+  Nest.Scalar("Date", () => Date)
+], DateScalar);
+let ObjectGqlStorage = class ObjectGqlStorage2 {
+  static {
+    __name(this, "ObjectGqlStorage");
+  }
+};
+let InputGqlStorage = class InputGqlStorage2 {
+  static {
+    __name(this, "InputGqlStorage");
+  }
+};
+const getPredefinedInqutGql = /* @__PURE__ */ __name((refName) => {
+  const inputGql = Reflect.getMetadata(refName, InputGqlStorage.prototype);
+  return inputGql;
+}, "getPredefinedInqutGql");
+const setPredefinedInqutGql = /* @__PURE__ */ __name((refName, inputGql) => {
+  Reflect.defineMetadata(refName, inputGql, InputGqlStorage.prototype);
+}, "setPredefinedInqutGql");
+const getPredefinedObjectGql = /* @__PURE__ */ __name((refName) => {
+  const objectGql = Reflect.getMetadata(refName, ObjectGqlStorage.prototype);
+  return objectGql;
+}, "getPredefinedObjectGql");
+const setPredefinedObjectGql = /* @__PURE__ */ __name((refName, objectGql) => {
+  Reflect.defineMetadata(refName, objectGql, ObjectGqlStorage.prototype);
+}, "setPredefinedObjectGql");
+const gqlNestFieldMap = /* @__PURE__ */ new Map([
+  [
+    import_base.ID,
+    Nest.ID
+  ],
+  [
+    import_base.Int,
+    Nest.Int
+  ],
+  [
+    import_base.Float,
+    Nest.Float
+  ],
+  [
+    import_base.JSON,
+    import_graphql_type_json.default
+  ],
+  [
+    Map,
+    import_graphql_type_json.default
+  ]
+]);
+const applyNestField = /* @__PURE__ */ __name((model, fieldMeta, type = "object") => {
+  if (fieldMeta.fieldType === "hidden" && type === "object") return;
+  const modelRef = fieldMeta.isClass ? type === "object" ? generateGql(fieldMeta.modelRef) : fieldMeta.isScalar ? generateGqlInput(fieldMeta.modelRef) : Nest.ID : gqlNestFieldMap.get(fieldMeta.modelRef) ?? fieldMeta.modelRef;
+  (0, import_graphql.Field)(() => (0, import_base.arraiedModel)(modelRef, fieldMeta.arrDepth), {
+    nullable: fieldMeta.nullable
+  })(model.prototype, fieldMeta.key);
+}, "applyNestField");
+const generateGqlInput = /* @__PURE__ */ __name((inputRef) => {
+  const classMeta = (0, import_constant.getClassMeta)(inputRef);
+  const predefinedInputGql = getPredefinedInqutGql(classMeta.refName);
+  if (predefinedInputGql) return predefinedInputGql;
+  const fieldMetas = (0, import_constant.getFieldMetas)(inputRef);
+  let InputGql = class InputGql {
+    static {
+      __name(this, "InputGql");
+    }
+  };
+  const inputGql = classMeta.type === "scalar" ? InputGql : (0, import_constant.getInputModelRef)(classMeta.refName);
+  fieldMetas.forEach((fieldMeta) => {
+    applyNestField(inputGql, fieldMeta, "input");
+  });
+  (0, import_graphql.InputType)(classMeta.refName + (classMeta.type === "scalar" ? "Input" : ""))(inputGql);
+  setPredefinedInqutGql(classMeta.refName, inputGql);
+  return inputGql;
+}, "generateGqlInput");
+const generateGql = /* @__PURE__ */ __name((objectRef) => {
+  const classMeta = (0, import_constant.getClassMeta)(objectRef);
+  if (classMeta.type === "light") {
+    const fullModelRefName = classMeta.refName.slice(5);
+    const fullModelRef = (0, import_constant.getFullModelRef)(fullModelRefName);
+    return generateGql(fullModelRef);
+  }
+  const predefinedObjectGql = getPredefinedObjectGql(classMeta.refName);
+  if (predefinedObjectGql) return predefinedObjectGql;
+  const fieldMetas = (0, import_constant.getFieldMetas)(objectRef);
+  let ObjectGql = class ObjectGql {
+    static {
+      __name(this, "ObjectGql");
+    }
+  };
+  const objectGql = classMeta.type === "scalar" ? ObjectGql : (0, import_constant.getFullModelRef)(classMeta.refName);
+  fieldMetas.forEach((fieldMeta) => {
+    applyNestField(objectGql, fieldMeta);
+  });
+  (0, import_graphql.ObjectType)(classMeta.refName)(objectGql);
+  setPredefinedObjectGql(classMeta.refName, objectGql);
+  return objectGql;
+}, "generateGql");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DateScalar,
+  applyNestField,
+  generateGql,
+  generateGqlInput
+});

package/src/index.d.ts

@@ -0,0 +1,23 @@
+export { DateScalar, applyNestField, generateGql, generateGqlInput } from './gql.js';
+export { resolverOf } from './resolver.js';
+export { controllerOf } from './controller.js';
+export { processorOf, queueOf } from './processor.js';
+export { batchModuleOf, databaseModuleOf, scalarModuleOf, scalarModulesOf, serviceModuleOf, useGlobals } from './module.js';
+export { FileStream, LocalFile } from './types.js';
+export { Response, websocketOf, websocketServerOf } from './websocket.js';
+export { BackendApp, createNestApp } from './boot.js';
+export { SearchDaemonModule, makeTextFilter } from './searchDaemon.js';
+export { addSchema, schemaOf } from './schema.js';
+export { DynamicModule as Module } from '@nestjs/common';
+import '../types-CUkhtrLV.js';
+import 'dayjs';
+import 'fs';
+import 'stream';
+import '../types-H2HI4YUe.js';
+import 'mongoose';
+import '../dbDecorators-z3rJpvxp.js';
+import '@nestjs/graphql';
+import 'graphql';
+import 'bull';
+import 'socket.io';
+import 'tunnel-ssh';

package/src/index.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./gql"), module.exports);
+__reExport(src_exports, require("./resolver"), module.exports);
+__reExport(src_exports, require("./controller"), module.exports);
+__reExport(src_exports, require("./processor"), module.exports);
+__reExport(src_exports, require("./module"), module.exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./websocket"), module.exports);
+__reExport(src_exports, require("./boot"), module.exports);
+__reExport(src_exports, require("./searchDaemon"), module.exports);
+__reExport(src_exports, require("./schema"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./gql"),
+  ...require("./resolver"),
+  ...require("./controller"),
+  ...require("./processor"),
+  ...require("./module"),
+  ...require("./types"),
+  ...require("./websocket"),
+  ...require("./boot"),
+  ...require("./searchDaemon"),
+  ...require("./schema")
+});

package/src/module.d.ts

@@ -0,0 +1,95 @@
+import { T as Type } from '../types-H2HI4YUe.js';
+import { F as FilterType } from '../types-CUkhtrLV.js';
+import { D as Database } from '../dbDecorators-z3rJpvxp.js';
+import { DynamicModule } from '@nestjs/common';
+import 'dayjs';
+import 'fs';
+import 'stream';
+import 'mongoose';
+
+interface ConstantModel<T extends string, Input, Full, Light, Insight, Filter extends FilterType, Summary = any> {
+    refName: T;
+    Input: Type<Input>;
+    Full: Type<Full>;
+    Light: Type<Light>;
+    Insight: Type<Insight>;
+    Filter: Type<Filter>;
+    Summary?: Type<Summary>;
+}
+
+interface DatabaseModuleCreateOptions {
+    constant: ConstantModel<string, any, any, any, any, any>;
+    database: Database<string, any, any, any, any, any, any, any, any>;
+    signal: Type;
+    service: Type;
+    uses?: {
+        [key: string]: any;
+    };
+    useAsyncs?: {
+        [key: string]: () => Promise<any>;
+    };
+    providers?: Type[];
+    extended?: boolean;
+}
+declare const databaseModuleOf: ({ constant, database, signal, service, uses, useAsyncs, providers, extended, }: DatabaseModuleCreateOptions, allSrvs: {
+    [key: string]: Type | undefined;
+}) => DynamicModule | null;
+interface ServiceModuleCreateOptions {
+    signal: Type;
+    service: Type;
+    uses?: {
+        [key: string]: any;
+    };
+    useAsyncs?: {
+        [key: string]: () => Promise<any>;
+    };
+    providers?: Type[];
+}
+declare const serviceModuleOf: ({ signal, service, uses, useAsyncs, providers }: ServiceModuleCreateOptions, allSrvs: {
+    [key: string]: Type | undefined;
+}) => DynamicModule | null;
+interface ScalarModuleCreateOptions {
+    signals: Type[];
+    uses?: {
+        [key: string]: any;
+    };
+    useAsyncs?: {
+        [key: string]: () => Promise<any>;
+    };
+    providers?: Type[];
+    enabled?: boolean;
+}
+declare const scalarModuleOf: ({ signals, uses, useAsyncs, providers, enabled }: ScalarModuleCreateOptions, allSrvs: {
+    [key: string]: Type | undefined;
+}) => DynamicModule | null;
+interface ScalarModulesCreateOptions {
+    constants: Type[];
+}
+declare const scalarModulesOf: ({ constants }: ScalarModulesCreateOptions, allSrvs: {
+    [key: string]: Type | undefined;
+}) => DynamicModule | null;
+interface BatchModuleCreateOptions {
+    service: Type;
+    uses?: {
+        [key: string]: any;
+    };
+    useAsyncs?: {
+        [key: string]: () => Promise<any>;
+    };
+    providers?: Type[];
+}
+declare const batchModuleOf: ({ service, uses, useAsyncs, providers, }: BatchModuleCreateOptions) => DynamicModule | null;
+interface UseGlobalsCreateOptions {
+    uses?: {
+        [key: string]: any;
+    };
+    useAsyncs?: {
+        [key: string]: () => Promise<any>;
+    };
+    injects?: {
+        [key: string]: Type;
+    };
+}
+declare const useGlobals: ({ uses, useAsyncs, injects }: UseGlobalsCreateOptions) => DynamicModule;
+
+export { batchModuleOf, databaseModuleOf, scalarModuleOf, scalarModulesOf, serviceModuleOf, useGlobals };

package/src/module.js

@@ -0,0 +1,347 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 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");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+const hasWebsocket = /* @__PURE__ */ __name((signal) => (0, import_signal.getGqlMetas)(signal).some((gqlMeta) => [
+  "Message",
+  "Pubsub"
+].includes(gqlMeta.type)), "hasWebsocket");
+const hasProcessor = /* @__PURE__ */ __name((signal) => (0, import_signal.getGqlMetas)(signal).some((gqlMeta) => gqlMeta.type === "Process"), "hasProcessor");
+const filterSrvs = /* @__PURE__ */ __name((srvs) => Object.fromEntries(Object.entries(srvs).filter(([_, srv]) => !!srv)), "filterSrvs");
+const databaseModuleOf = /* @__PURE__ */ __name(({ constant, database, signal, service, uses = {}, useAsyncs = {}, providers = [], extended }, 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);
+  let DatabaseModule = class DatabaseModule {
+    static {
+      __name(this, "DatabaseModule");
+    }
+  };
+  DatabaseModule = _ts_decorate([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      imports: [
+        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)
+          }
+        ]),
+        ...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)),
+        ...hasProcessor(signal) ? [
+          (0, import_processor.processorOf)(signal, filterSrvs(allSrvs)),
+          {
+            provide: `${className}Queue`,
+            useFactory: /* @__PURE__ */ __name((queue) => queue, "useFactory"),
+            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
+        })),
+        {
+          provide: `${modelName}Model`,
+          useFactory: /* @__PURE__ */ __name((model, redis, meili) => {
+            return (0, import_document.databaseModelOf)(database, model, redis, meili);
+          }, "useFactory"),
+          inject: [
+            mongoToken,
+            "REDIS_CLIENT",
+            "MEILI_CLIENT"
+          ]
+        },
+        ...providers
+      ],
+      controllers: [
+        (0, import_controller.controllerOf)(signal, filterSrvs(allSrvs))
+      ],
+      exports: [
+        service
+      ]
+    })
+  ], DatabaseModule);
+  return DatabaseModule;
+}, "databaseModuleOf");
+const serviceModuleOf = /* @__PURE__ */ __name(({ signal, service, uses = {}, useAsyncs = {}, providers = [] }, 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)
+  ];
+  let ServiceModule = class ServiceModule {
+    static {
+      __name(this, "ServiceModule");
+    }
+  };
+  ServiceModule = _ts_decorate([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      imports: [
+        ...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: /* @__PURE__ */ __name((queue) => queue, "useFactory"),
+            inject: [
+              (0, import_bull.getQueueToken)(modelName)
+            ]
+          }
+        ] : [],
+        ...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: [
+        (0, import_controller.controllerOf)(signal, filterSrvs(allSrvs))
+      ],
+      exports: [
+        service
+      ]
+    })
+  ], ServiceModule);
+  return ServiceModule;
+}, "serviceModuleOf");
+const scalarModuleOf = /* @__PURE__ */ __name(({ signals, uses = {}, useAsyncs = {}, providers = [], enabled = true }, allSrvs) => {
+  if (!enabled) return null;
+  let ScalarModule = class ScalarModule {
+    static {
+      __name(this, "ScalarModule");
+    }
+  };
+  ScalarModule = _ts_decorate([
+    (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;
+}, "scalarModuleOf");
+const scalarModulesOf = /* @__PURE__ */ __name(({ constants }, allSrvs) => {
+  const signals = constants.filter((modelRef) => {
+    const childRefs = (0, import_constant.getChildClassRefs)(modelRef);
+    return childRefs.some((childRef) => {
+      const classMeta = (0, import_constant.getClassMeta)(childRef);
+      return [
+        "full",
+        "light"
+      ].includes(classMeta.type);
+    });
+  }).map((modelRef) => {
+    let ScalarSignal = class ScalarSignal extends (0, import_signal.LogSignal)({}) {
+      static {
+        __name(this, "ScalarSignal");
+      }
+    };
+    ScalarSignal = _ts_decorate([
+      (0, import_signal.Signal)(() => modelRef)
+    ], ScalarSignal);
+    return ScalarSignal;
+  });
+  let ScalarModule = class ScalarModule {
+    static {
+      __name(this, "ScalarModule");
+    }
+  };
+  ScalarModule = _ts_decorate([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      imports: [],
+      providers: [
+        ...signals.map((signal) => (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs)))
+      ]
+    })
+  ], ScalarModule);
+  return ScalarModule;
+}, "scalarModulesOf");
+const batchModuleOf = /* @__PURE__ */ __name(({ service, uses = {}, useAsyncs = {}, providers = [] }) => {
+  if (!(0, import_service.isServiceEnabled)(service)) return null;
+  let BatchModule = class BatchModule {
+    static {
+      __name(this, "BatchModule");
+    }
+  };
+  BatchModule = _ts_decorate([
+    (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;
+}, "batchModuleOf");
+const useGlobals = /* @__PURE__ */ __name(({ uses, useAsyncs, injects }) => {
+  let GlobalsModule = class GlobalsModule {
+    static {
+      __name(this, "GlobalsModule");
+    }
+  };
+  GlobalsModule = _ts_decorate([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      imports: [],
+      providers: [
+        ...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
+        })),
+        ...Object.entries(injects ?? {}).map(([key, inject]) => ({
+          provide: (0, import_common.capitalize)(key),
+          useClass: inject
+        }))
+      ],
+      exports: [
+        ...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;
+}, "useGlobals");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  batchModuleOf,
+  databaseModuleOf,
+  scalarModuleOf,
+  scalarModulesOf,
+  serviceModuleOf,
+  useGlobals
+});

package/src/processor.d.ts

@@ -0,0 +1,11 @@
+import { T as Type } from '../types-H2HI4YUe.js';
+import { Queue } from 'bull';
+
+declare const processorOf: (sigRef: Type, allSrvs: {
+    [key: string]: Type;
+}) => {
+    new (): {};
+};
+declare const queueOf: (sigRef: Type, queue: Queue) => Queue<any>;
+
+export { processorOf, queueOf };