@akanjs/server 0.0.45 → 0.0.47

package/src/module.js

@@ -0,0 +1,246 @@
+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--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+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,
+  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 = __decorateClass([
+    (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: (queue) => queue, inject: [(0, import_bull.getQueueToken)(modelName)] }
+        ] : [],
+        ...hasWebsocket(signal) ? [(0, import_websocket.websocketOf)(signal, filterSrvs(allSrvs)), { provide: "Websocket", useClass: (0, import_websocket.websocketServerOf)(signal) }] : [],
+        ...Object.entries(uses).map(([key, useValue]) => ({ provide: (0, import_common.capitalize)(key), useValue })),
+        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: (0, import_common.capitalize)(key), useFactory })),
+        {
+          provide: `${modelName}Model`,
+          useFactory: (model, redis, meili) => {
+            return (0, import_document.databaseModelOf)(database, model, redis, meili);
+          },
+          inject: [mongoToken, "REDIS_CLIENT", "MEILI_CLIENT"]
+        },
+        ...providers
+      ],
+      controllers: [(0, import_controller.controllerOf)(signal, filterSrvs(allSrvs))],
+      exports: [service]
+    })
+  ], DatabaseModule);
+  return DatabaseModule;
+};
+const serviceModuleOf = ({ 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 = __decorateClass([
+    (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: (queue) => queue, 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;
+};
+const scalarModuleOf = ({ signals, uses = {}, useAsyncs = {}, providers = [], enabled = true }, allSrvs) => {
+  if (!enabled)
+    return null;
+  let ScalarModule = class {
+  };
+  ScalarModule = __decorateClass([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      imports: [],
+      providers: [
+        ...signals.map((signal) => (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs))),
+        ...signals.filter(hasWebsocket).map((signal) => [
+          (0, import_websocket.websocketOf)(signal, filterSrvs(allSrvs)),
+          { provide: "Websocket", useClass: (0, import_websocket.websocketServerOf)(signal) }
+        ]).flat(),
+        ...Object.entries(uses).map(([key, useValue]) => ({ provide: (0, import_common.capitalize)(key), useValue })),
+        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: (0, import_common.capitalize)(key), useFactory })),
+        ...providers
+      ],
+      controllers: signals.map((signal) => (0, import_controller.controllerOf)(signal, filterSrvs(allSrvs)))
+    })
+  ], ScalarModule);
+  return ScalarModule;
+};
+const scalarModulesOf = ({ constants }, allSrvs) => {
+  const signals = constants.filter((modelRef) => {
+    const childRefs = (0, import_constant.getChildClassRefs)(modelRef);
+    return childRefs.some((childRef) => {
+      const classMeta = (0, import_constant.getClassMeta)(childRef);
+      return ["full", "light"].includes(classMeta.type);
+    });
+  }).map((modelRef) => {
+    let ScalarSignal = class extends (0, import_signal.LogSignal)({}) {
+    };
+    ScalarSignal = __decorateClass([
+      (0, import_signal.Signal)(() => modelRef)
+    ], ScalarSignal);
+    return ScalarSignal;
+  });
+  let ScalarModule = class {
+  };
+  ScalarModule = __decorateClass([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      imports: [],
+      providers: [...signals.map((signal) => (0, import_resolver.resolverOf)(signal, filterSrvs(allSrvs)))]
+      // controllers: signals.map((signal) => controllerOf(signal, filterSrvs(allSrvs))),
+    })
+  ], ScalarModule);
+  return ScalarModule;
+};
+const batchModuleOf = ({
+  service,
+  uses = {},
+  useAsyncs = {},
+  providers = []
+}) => {
+  if (!(0, import_service.isServiceEnabled)(service))
+    return null;
+  let BatchModule = class {
+  };
+  BatchModule = __decorateClass([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      imports: [],
+      providers: [
+        (0, import_service.serviceOf)(service),
+        ...Object.entries(uses).map(([key, useValue]) => ({ provide: (0, import_common.capitalize)(key), useValue })),
+        ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: (0, import_common.capitalize)(key), useFactory })),
+        ...providers
+      ],
+      exports: [service]
+    })
+  ], BatchModule);
+  return BatchModule;
+};
+const useGlobals = ({ uses, useAsyncs, injects }) => {
+  let GlobalsModule = class {
+  };
+  GlobalsModule = __decorateClass([
+    (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;
+};

package/src/processor.js

@@ -0,0 +1,87 @@
+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] = (0, import_signal.deserializeArg)(argMeta, job.data[argMeta.idx]);
+      else
+        throw new Error(`Invalid ArgMeta Type ${argMeta.type}`);
+    });
+    internalArgMetas.forEach((internalArgMeta) => {
+      if (internalArgMeta.type === "Job")
+        args[internalArgMeta.idx] = job;
+      else
+        throw new Error(`Invalid InternalArgMeta Type ${internalArgMeta.type}`);
+    });
+    this.logger?.log(`Process-${gqlMeta.key} started`);
+    const result = await fn.apply(this, args);
+    this.logger?.log(`Process-${gqlMeta.key} finished`);
+    done(null, result);
+  };
+};
+const processorOf = (sigRef, allSrvs) => {
+  const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+  const serverMode = process.env.SERVER_MODE ?? "federation";
+  const gqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Process").filter(
+    (gqlMeta) => gqlMeta.signalOption.serverType === "all" || serverMode === "all" || gqlMeta.signalOption.serverType === serverMode
+  );
+  class QueueProcessor {
+  }
+  Object.keys(allSrvs).forEach((srv) => {
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srv]))
+      return;
+    (0, import_common2.Inject)(allSrvs[srv])(QueueProcessor.prototype, (0, import_common.lowerlize)(srv));
+  });
+  for (const gqlMeta of gqlMetas) {
+    const [argMetas, internalArgMetas] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
+    const descriptor = { ...Object.getOwnPropertyDescriptor(sigRef.prototype, gqlMeta.key) ?? {} };
+    descriptor.value = convertProcessFunction(
+      gqlMeta,
+      argMetas,
+      internalArgMetas,
+      descriptor.value
+    );
+    Object.defineProperty(QueueProcessor.prototype, gqlMeta.key, descriptor);
+    (0, import_bull.Process)(gqlMeta.key)(QueueProcessor.prototype, gqlMeta.key, descriptor);
+  }
+  (0, import_bull.Processor)(sigMeta.refName)(QueueProcessor);
+  return QueueProcessor;
+};
+const queueOf = (sigRef, queue) => {
+  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}`);
+    queue[gqlMeta.key] = (...args) => queue.add(gqlMeta.key, args);
+  }
+  return queue;
+};

package/src/resolver.js

@@ -0,0 +1,141 @@
+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 __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 resolver_exports = {};
+__export(resolver_exports, {
+  resolverOf: () => resolverOf
+});
+module.exports = __toCommonJS(resolver_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_nest = require("@akanjs/nest");
+var import_service = require("@akanjs/service");
+var import_signal = require("@akanjs/signal");
+var import_common2 = require("@nestjs/common");
+var Nest = __toESM(require("@nestjs/graphql"));
+var import_graphql_type_json = __toESM(require("graphql-type-json"));
+var import_graphql_upload = require("graphql-upload");
+var import_gql = require("./gql");
+const scalarNestReturnMap = /* @__PURE__ */ new Map([
+  [import_base.Upload, import_graphql_upload.GraphQLUpload],
+  [import_base.ID, Nest.ID],
+  [import_base.Int, Nest.Int],
+  [import_base.Float, Nest.Float],
+  [import_base.JSON, import_graphql_type_json.default],
+  [Boolean, Boolean],
+  [Date, Date],
+  [String, String],
+  [Map, import_graphql_type_json.default]
+]);
+const getNestReturn = (returns, type = "object") => {
+  const [model, arrDepth] = (0, import_base.getNonArrayModel)(returns());
+  const modelRef = scalarNestReturnMap.get(model) ?? (type === "object" ? (0, import_gql.generateGql)(model) : (0, import_gql.generateGqlInput)(model));
+  return () => (0, import_base.arraiedModel)(modelRef, arrDepth);
+};
+const internalArgMap = {
+  Parent: Nest.Parent,
+  Account: import_nest.Account,
+  UserIp: import_nest.UserIp,
+  Access: import_nest.Access,
+  Self: import_nest.Self,
+  Me: import_nest.Me,
+  Req: import_nest.Req,
+  Res: import_nest.Res
+};
+const resolverOf = (sigRef, allSrvs) => {
+  const Rsv = (0, import_signal.copySignal)(sigRef);
+  const sigMeta = (0, import_signal.getSigMeta)(Rsv);
+  const gqlMetas = (0, import_signal.getGqlMetas)(Rsv);
+  Object.keys(allSrvs).forEach((srv) => {
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srv]))
+      return;
+    (0, import_common2.Inject)(allSrvs[srv])(Rsv.prototype, (0, import_common.lowerlize)(srv));
+  });
+  for (const gqlMeta of gqlMetas) {
+    if (gqlMeta.guards.some((guard) => guard === "None") || gqlMeta.signalOption.onlyFor === "restapi" || !["Query", "Mutation"].includes(gqlMeta.type))
+      continue;
+    else if (gqlMeta.signalOption.sso)
+      continue;
+    const [argMetas, internalArgMetas] = (0, import_signal.getArgMetas)(Rsv, gqlMeta.key);
+    const descriptor = Object.getOwnPropertyDescriptor(Rsv.prototype, gqlMeta.key) ?? {};
+    for (const argMeta of argMetas) {
+      Nest.Args({
+        name: argMeta.name,
+        type: getNestReturn(argMeta.returns, "input"),
+        ...argMeta.argsOption
+      })(Rsv.prototype, gqlMeta.key, argMeta.idx);
+    }
+    for (const internalArgMeta of internalArgMetas) {
+      const decorate = internalArgMap[internalArgMeta.type];
+      decorate(internalArgMeta.option ?? {})(Rsv.prototype, gqlMeta.key, internalArgMeta.idx);
+    }
+    (0, import_common2.UseGuards)(...gqlMeta.guards.map((guard) => import_nest.guards[guard]))(Rsv.prototype, gqlMeta.key, descriptor);
+    if (gqlMeta.type === "Query")
+      Nest.Query(getNestReturn(gqlMeta.returns), gqlMeta.signalOption)(Rsv.prototype, gqlMeta.key, descriptor);
+    else if (gqlMeta.type === "Mutation")
+      Nest.Mutation(getNestReturn(gqlMeta.returns), gqlMeta.signalOption)(Rsv.prototype, gqlMeta.key, descriptor);
+  }
+  const resolveFieldMetas = (0, import_signal.getResolveFieldMetas)(Rsv);
+  if (sigMeta.returns) {
+    const modelRef = sigMeta.returns();
+    const fieldMetas = (0, import_constant.getFieldMetas)(modelRef);
+    fieldMetas.filter((fieldMeta) => fieldMeta.isClass && !fieldMeta.isScalar).forEach((fieldMeta) => {
+      const classMeta = (0, import_constant.getClassMeta)(fieldMeta.modelRef);
+      const modelName = (0, import_common.lowerlize)(classMeta.type === "light" ? classMeta.refName.slice(5) : classMeta.refName);
+      const className = (0, import_common.capitalize)(modelName);
+      const serviceName = `${modelName}Service`;
+      Rsv.prototype[fieldMeta.key] = async function(parent) {
+        const service = this[serviceName];
+        return fieldMeta.arrDepth ? await service[`load${className}Many`](parent[fieldMeta.key]) : await service[`load${className}`](parent[fieldMeta.key]);
+      };
+      Nest.Parent()(Rsv.prototype, fieldMeta.key, 0);
+      Nest.ResolveField(getNestReturn(() => (0, import_base.arraiedModel)(fieldMeta.modelRef, fieldMeta.arrDepth)))(
+        Rsv.prototype,
+        fieldMeta.key,
+        Object.getOwnPropertyDescriptor(Rsv.prototype, fieldMeta.key) ?? {}
+      );
+    });
+  }
+  for (const resolveFieldMeta of resolveFieldMetas) {
+    const [, internalArgMetas] = (0, import_signal.getArgMetas)(Rsv, resolveFieldMeta.key);
+    for (const internalArgMeta of internalArgMetas) {
+      const decorate = internalArgMap[internalArgMeta.type];
+      decorate(internalArgMeta.option ?? {})(Rsv.prototype, resolveFieldMeta.key, internalArgMeta.idx);
+    }
+    Nest.ResolveField(getNestReturn(resolveFieldMeta.returns))(
+      Rsv.prototype,
+      resolveFieldMeta.key,
+      Object.getOwnPropertyDescriptor(Rsv.prototype, resolveFieldMeta.key) ?? {}
+    );
+  }
+  if (sigMeta.returns)
+    Nest.Resolver(getNestReturn(sigMeta.returns))(Rsv);
+  else
+    Nest.Resolver()(Rsv);
+  return Rsv;
+};