@akanjs/server 0.0.54 → 0.0.56

package/index.mjs

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/server",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "type": "commonjs",
   "scripts": {
     "postinstall": "pnpm install @nestjs/mongoose@^10.1.0"
@@ -41,5 +41,11 @@
     "mongoose": "^8.9.3",
     "redis": "^4.7.0",
     "rxjs": "^7.8.1"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
   }
 }

package/src/boot.mjs

@@ -0,0 +1,191 @@
+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 { baseEnv, logo } from "@akanjs/base";
+import { Logger } from "@akanjs/common";
+import {
+  AllExceptionsFilter,
+  CacheClient,
+  CacheInterceptor,
+  DatabaseClient,
+  generateJwtSecret,
+  generateMeiliKey,
+  generateMeiliUri,
+  generateMongoUri,
+  generateRedisUri,
+  initMongoDB,
+  LoggingInterceptor,
+  RedisIoAdapter,
+  SearchClient,
+  TimeoutInterceptor,
+  verifyToken
+} from "@akanjs/nest";
+import { client } from "@akanjs/signal";
+import { ApolloDriver } from "@nestjs/apollo";
+import { BullModule } from "@nestjs/bull";
+import {
+  Global,
+  Injectable,
+  Module,
+  RequestMethod
+} from "@nestjs/common";
+import { NestFactory } from "@nestjs/core";
+import { GraphQLModule } from "@nestjs/graphql";
+import { MongooseModule } from "@nestjs/mongoose";
+import { ScheduleModule } from "@nestjs/schedule";
+import { json, urlencoded } from "body-parser";
+import cookieParser from "cookie-parser";
+import dgram from "dgram";
+import events from "events";
+import { graphqlUploadExpress } from "graphql-upload";
+import { MeiliSearch } from "meilisearch";
+import { join } from "path";
+import { createClient } from "redis";
+import { DateScalar } from "./gql";
+import { useGlobals } from "./module";
+import { SearchDaemonModule } from "./searchDaemon";
+const createNestApp = async ({ registerModules, serverMode = "federation", env, log = true }) => {
+  const backendLogger = new Logger("Backend");
+  if (log)
+    backendLogger.rawLog(logo);
+  const jwtSecret = generateJwtSecret(env.appName, env.environment);
+  const [redisUri, mongoUri, meiliUri] = await Promise.all([
+    env.redisUri ?? generateRedisUri({ ...env, ...env.redis?.sshOptions ? { sshOptions: env.redis.sshOptions } : {} }),
+    env.mongoUri ?? generateMongoUri({
+      ...env,
+      ...env.mongo.username ? { username: env.mongo.username } : {},
+      password: env.mongo.password,
+      ...env.mongo.sshOptions ? { sshOptions: env.mongo.sshOptions } : {}
+    }),
+    env.meiliUri ?? generateMeiliUri(env)
+  ]);
+  if (env.operationMode === "local") {
+    backendLogger.verbose(`connect to redis: ${redisUri}`);
+    backendLogger.verbose(`connect to mongo: ${mongoUri}`);
+    backendLogger.verbose(`connect to meili: ${meiliUri}`);
+  }
+  initMongoDB({ logging: baseEnv.environment !== "main", sendReport: false });
+  events.EventEmitter.defaultMaxListeners = 1e3;
+  let AuthMiddleWare = class {
+    use(req, res, next) {
+      const requestHeader = req;
+      requestHeader.account = verifyToken(
+        jwtSecret,
+        requestHeader.headers.authorization ?? (requestHeader.cookies?.jwt ? `Bearer ${requestHeader.cookies.jwt}` : void 0)
+      );
+      requestHeader.userAgent = requestHeader["user-agent"];
+      next();
+    }
+  };
+  AuthMiddleWare = __decorateClass([
+    Injectable()
+  ], AuthMiddleWare);
+  const redisClient = await createClient({ url: redisUri }).connect();
+  let SubDatabaseModule = class {
+  };
+  SubDatabaseModule = __decorateClass([
+    Global(),
+    Module({
+      providers: [
+        { provide: "REDIS_CLIENT", useValue: redisClient },
+        {
+          provide: "MEILI_CLIENT",
+          useFactory: () => new MeiliSearch({ host: meiliUri, apiKey: generateMeiliKey(env) })
+        }
+      ],
+      exports: ["REDIS_CLIENT", "MEILI_CLIENT"]
+    })
+  ], SubDatabaseModule);
+  let AppModule = class {
+    configure(consumer) {
+      consumer.apply(AuthMiddleWare).forRoutes({ path: "*", method: RequestMethod.ALL });
+    }
+  };
+  AppModule = __decorateClass([
+    Module({
+      imports: [
+        BullModule.forRoot({ redis: redisUri }),
+        ScheduleModule.forRoot(),
+        GraphQLModule.forRootAsync({
+          imports: [],
+          useFactory: () => ({
+            useGlobalPrefix: true,
+            autoSchemaFile: join(process.cwd(), "src/schema.gql"),
+            sortSchema: true,
+            playground: baseEnv.environment !== "main",
+            introspection: baseEnv.environment !== "main",
+            uploads: false,
+            debug: false
+          }),
+          driver: ApolloDriver
+        }),
+        MongooseModule.forRootAsync({
+          useFactory: () => ({ uri: mongoUri, autoIndex: baseEnv.environment !== "main" })
+        }),
+        SubDatabaseModule,
+        useGlobals({
+          injects: { SearchClient, DatabaseClient, CacheClient }
+        }),
+        ...["batch", "all"].includes(serverMode) && baseEnv.operationMode !== "edge" ? [SearchDaemonModule] : [],
+        ...registerModules(env).filter((m) => !!m)
+      ],
+      providers: [DateScalar]
+    })
+  ], AppModule);
+  const app = await NestFactory.create(AppModule, { logger: backendLogger });
+  const redisIoAdapter = new RedisIoAdapter(app, { jwtSecret });
+  await redisIoAdapter.connectToRedis(redisUri);
+  app.enableShutdownHooks();
+  const udp = dgram.createSocket("udp4");
+  client.setUdp(udp);
+  if (["federation", "all"].includes(serverMode)) {
+    app.setGlobalPrefix(process.env.GLOBAL_PREFIX ?? "/backend");
+    app.enableCors({
+      origin: "*",
+      methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
+      preflightContinue: false,
+      optionsSuccessStatus: 204,
+      allowedHeaders: "DNT,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,apollo-require-preflight"
+    });
+    if (env.operationMode !== "local" && process.env.USE_REDIS_IO_ADAPTER !== "false")
+      app.useWebSocketAdapter(redisIoAdapter);
+    app.use(json({ limit: "100mb" }));
+    app.use(urlencoded({ limit: "100mb", extended: true }));
+    app.use("/backend/graphql", graphqlUploadExpress());
+    app.use(cookieParser());
+    app.useGlobalInterceptors(new LoggingInterceptor());
+    app.useGlobalInterceptors(new TimeoutInterceptor());
+    app.useGlobalInterceptors(new CacheInterceptor(redisClient));
+    app.useGlobalFilters(new AllExceptionsFilter());
+    await app.listen(process.env.PORT ?? env.port ?? 8080);
+    backendLogger.log(`\u{1F680} Server is running on: ${await app.getUrl()}`);
+  } else {
+    await app.init();
+    backendLogger.log(`\u{1F680} Batch Server is running`);
+  }
+  if (module.hot) {
+    module.hot.accept();
+    module.hot.dispose(() => {
+      void app.close();
+    });
+  }
+  return {
+    nestApp: app,
+    close: async () => {
+      await app.close();
+      await redisIoAdapter.destroy();
+      await redisClient.quit();
+    }
+  };
+};
+export {
+  createNestApp
+};

package/src/controller.mjs

@@ -0,0 +1,109 @@
+import { getNonArrayModel, Upload } from "@akanjs/base";
+import { lowerlize } from "@akanjs/common";
+import {
+  Access,
+  Account,
+  getBodyPipes,
+  getQueryPipes,
+  guards,
+  Me,
+  MulterToUploadPipe,
+  Req,
+  Res,
+  Self,
+  UserIp
+} from "@akanjs/nest";
+import { isServiceEnabled } from "@akanjs/service";
+import {
+  copySignal,
+  getArgMetas,
+  getControllerPath,
+  getControllerPrefix,
+  getGqlMetas,
+  getSigMeta
+} from "@akanjs/signal";
+import {
+  Body,
+  Controller,
+  Get,
+  Inject,
+  Param,
+  Post,
+  Query,
+  UploadedFiles,
+  UseGuards,
+  UseInterceptors
+} from "@nestjs/common";
+import { AuthGuard } from "@nestjs/passport";
+import { FilesInterceptor } from "@nestjs/platform-express";
+const internalArgMap = {
+  // Parent: Nest.Parent,
+  Account,
+  UserIp,
+  Access,
+  Self,
+  Me,
+  Req,
+  Res
+};
+const controllerOf = (sigRef, allSrvs) => {
+  const sigMeta = getSigMeta(sigRef);
+  const gqlMetas = getGqlMetas(sigRef);
+  const prefix = getControllerPrefix(sigMeta);
+  const Ctrl = copySignal(sigRef);
+  Object.keys(allSrvs).forEach((srv) => {
+    if (!isServiceEnabled(allSrvs[srv]))
+      return;
+    Inject(allSrvs[srv])(Ctrl.prototype, lowerlize(srv));
+  });
+  for (const gqlMeta of gqlMetas) {
+    if (gqlMeta.guards.some((guard) => guard === "None") || gqlMeta.signalOption.onlyFor === "graphql" || !["Query", "Mutation"].includes(gqlMeta.type))
+      continue;
+    const [argMetas, internalArgMetas] = getArgMetas(Ctrl, gqlMeta.key);
+    internalArgMetas.forEach((internalArgMeta) => {
+      const internalDecorator = internalArgMap[internalArgMeta.type];
+      internalDecorator(internalArgMeta.option ?? {})(Ctrl.prototype, gqlMeta.key, internalArgMeta.idx);
+    });
+    const uploadArgMeta = argMetas.find((argMeta) => argMeta.type === "Upload");
+    if (uploadArgMeta && gqlMeta.signalOption.onlyFor === "restapi") {
+      const [modelRef, arrDepth] = getNonArrayModel(uploadArgMeta.returns());
+      if (modelRef.prototype !== Upload.prototype)
+        throw new Error("Upload must be Upload");
+      else if (!arrDepth)
+        throw new Error(`Only Array of Upload is allowed - ${sigMeta.refName}/${gqlMeta.key}`);
+      UseInterceptors(FilesInterceptor(uploadArgMeta.name))(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+      UploadedFiles(MulterToUploadPipe)(Ctrl.prototype, gqlMeta.key, uploadArgMeta.idx);
+    }
+    const queryArgMetas = argMetas.filter((argMeta) => argMeta.type === "Query");
+    queryArgMetas.forEach((argMeta) => {
+      const [modelRef, arrDepth] = getNonArrayModel(argMeta.returns());
+      Query(argMeta.name, ...getQueryPipes(modelRef, arrDepth))(Ctrl.prototype, gqlMeta.key, argMeta.idx);
+    });
+    const paramArgMetas = argMetas.filter((argMeta) => argMeta.type === "Param");
+    paramArgMetas.forEach((argMeta) => {
+      Param(argMeta.name)(Ctrl.prototype, gqlMeta.key, argMeta.idx);
+    });
+    const path = getControllerPath(gqlMeta, paramArgMetas);
+    const bodyArgMetas = argMetas.filter((argMeta) => argMeta.type === "Body");
+    if (bodyArgMetas.length)
+      bodyArgMetas.forEach((argMeta) => {
+        Body(argMeta.name, ...getBodyPipes(argMeta))(Ctrl.prototype, gqlMeta.key, argMeta.idx);
+      });
+    UseGuards(
+      ...gqlMeta.guards.map((guard) => guards[guard]),
+      ...gqlMeta.signalOption.sso ? [AuthGuard(gqlMeta.signalOption.sso)] : []
+    )(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+    if (gqlMeta.type === "Query")
+      Get(path)(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+    else if (gqlMeta.type === "Mutation")
+      Post(path)(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+  }
+  if (prefix)
+    Controller(prefix)(Ctrl);
+  else
+    Controller()(Ctrl);
+  return Ctrl;
+};
+export {
+  controllerOf
+};

package/src/gql.mjs

@@ -0,0 +1,123 @@
+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 { arraiedModel, dayjs, Float, ID, Int, JSON } from "@akanjs/base";
+import {
+  getClassMeta,
+  getFieldMetas,
+  getFullModelRef,
+  getInputModelRef
+} from "@akanjs/constant";
+import * as Nest from "@nestjs/graphql";
+import { Field, InputType, ObjectType } from "@nestjs/graphql";
+import { isDayjs } from "dayjs";
+import { Kind } from "graphql";
+import { default as GraphQLJSON } from "graphql-type-json";
+let DateScalar = class {
+  description = "Date custom scalar type";
+  parseValue(value) {
+    return dayjs(value);
+  }
+  serialize(value) {
+    if (isDayjs(value))
+      return value.toDate();
+    else
+      return new Date(value);
+  }
+  parseLiteral(ast) {
+    if (ast.kind === Kind.INT)
+      return dayjs(ast.value);
+    else if (ast.kind === Kind.STRING)
+      return dayjs(ast.value);
+    else
+      return null;
+  }
+};
+DateScalar = __decorateClass([
+  Nest.Scalar("Date", () => Date)
+], DateScalar);
+class ObjectGqlStorage {
+}
+class InputGqlStorage {
+}
+const getPredefinedInqutGql = (refName) => {
+  const inputGql = Reflect.getMetadata(refName, InputGqlStorage.prototype);
+  return inputGql;
+};
+const setPredefinedInqutGql = (refName, inputGql) => {
+  Reflect.defineMetadata(refName, inputGql, InputGqlStorage.prototype);
+};
+const getPredefinedObjectGql = (refName) => {
+  const objectGql = Reflect.getMetadata(refName, ObjectGqlStorage.prototype);
+  return objectGql;
+};
+const setPredefinedObjectGql = (refName, objectGql) => {
+  Reflect.defineMetadata(refName, objectGql, ObjectGqlStorage.prototype);
+};
+const gqlNestFieldMap = /* @__PURE__ */ new Map([
+  [ID, Nest.ID],
+  [Int, Nest.Int],
+  [Float, Nest.Float],
+  [JSON, GraphQLJSON],
+  [Map, GraphQLJSON]
+]);
+const applyNestField = (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;
+  Field(() => arraiedModel(modelRef, fieldMeta.arrDepth), { nullable: fieldMeta.nullable })(
+    model.prototype,
+    fieldMeta.key
+  );
+};
+const generateGqlInput = (inputRef) => {
+  const classMeta = getClassMeta(inputRef);
+  const predefinedInputGql = getPredefinedInqutGql(classMeta.refName);
+  if (predefinedInputGql)
+    return predefinedInputGql;
+  const fieldMetas = getFieldMetas(inputRef);
+  class InputGql {
+  }
+  const inputGql = classMeta.type === "scalar" ? InputGql : getInputModelRef(classMeta.refName);
+  fieldMetas.forEach((fieldMeta) => {
+    applyNestField(inputGql, fieldMeta, "input");
+  });
+  InputType(classMeta.refName + (classMeta.type === "scalar" ? "Input" : ""))(inputGql);
+  setPredefinedInqutGql(classMeta.refName, inputGql);
+  return inputGql;
+};
+const generateGql = (objectRef) => {
+  const classMeta = getClassMeta(objectRef);
+  if (classMeta.type === "light") {
+    const fullModelRefName = classMeta.refName.slice(5);
+    const fullModelRef = getFullModelRef(fullModelRefName);
+    return generateGql(fullModelRef);
+  }
+  const predefinedObjectGql = getPredefinedObjectGql(classMeta.refName);
+  if (predefinedObjectGql)
+    return predefinedObjectGql;
+  const fieldMetas = getFieldMetas(objectRef);
+  class ObjectGql {
+  }
+  const objectGql = classMeta.type === "scalar" ? ObjectGql : getFullModelRef(classMeta.refName);
+  fieldMetas.forEach((fieldMeta) => {
+    applyNestField(objectGql, fieldMeta);
+  });
+  ObjectType(classMeta.refName)(objectGql);
+  setPredefinedObjectGql(classMeta.refName, objectGql);
+  return objectGql;
+};
+export {
+  DateScalar,
+  applyNestField,
+  generateGql,
+  generateGqlInput
+};

package/src/index.mjs

@@ -0,0 +1,10 @@
+export * from "./gql";
+export * from "./resolver";
+export * from "./controller";
+export * from "./processor";
+export * from "./module";
+export * from "./types";
+export * from "./websocket";
+export * from "./boot";
+export * from "./searchDaemon";
+export * from "./schema";

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