@akanjs/server 0.9.41 → 0.9.43

package/esm/src/schedule.js

@@ -0,0 +1,210 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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 __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+import { lowerlize } from "@akanjs/common";
+import { getAllServiceRefs, getServiceMeta } from "@akanjs/service";
+import { getAllSignalRefs, getGqlMetas } from "@akanjs/signal";
+import { Global, Inject, Injectable, Logger, Module } from "@nestjs/common";
+import { CronJob } from "cron";
+const makeScheduleModule = (serverMode, backendEnv) => {
+  var _cronMap, _timeoutMap, _intervalMap, _lockMap;
+  const srvRefs = getAllServiceRefs();
+  const sigRefs = getAllSignalRefs();
+  const initMetas = [];
+  const cronMetas = [];
+  const intervalMetas = [];
+  const timeoutMetas = [];
+  const destroyMetas = [];
+  sigRefs.forEach((sigRef) => {
+    const gqlMetas = getGqlMetas(sigRef);
+    gqlMetas.forEach((gqlMeta) => {
+      const { enabled, operationMode, serverMode: targetServerMode, scheduleType } = gqlMeta.signalOption;
+      if (gqlMeta.type !== "Schedule")
+        return;
+      else if (!enabled)
+        return;
+      else if (operationMode && !operationMode.includes(backendEnv.operationMode))
+        return;
+      else if (targetServerMode && targetServerMode !== "all" && serverMode !== "all" && targetServerMode !== serverMode)
+        return;
+      switch (scheduleType) {
+        case "init":
+          initMetas.push(gqlMeta);
+          break;
+        case "cron":
+          cronMetas.push(gqlMeta);
+          break;
+        case "interval":
+          intervalMetas.push(gqlMeta);
+          break;
+        case "timeout":
+          timeoutMetas.push(gqlMeta);
+          break;
+        case "destroy":
+          destroyMetas.push(gqlMeta);
+          break;
+        default:
+          break;
+      }
+    });
+  });
+  let Schedule = class {
+    constructor() {
+      __publicField(this, "logger", new Logger("Schedule"));
+      __privateAdd(this, _cronMap, /* @__PURE__ */ new Map());
+      __privateAdd(this, _timeoutMap, /* @__PURE__ */ new Map());
+      __privateAdd(this, _intervalMap, /* @__PURE__ */ new Map());
+      __privateAdd(this, _lockMap, /* @__PURE__ */ new Map());
+    }
+    async onModuleInit() {
+      await Promise.all(
+        initMetas.map(async (gqlMeta) => {
+          const fn = gqlMeta.descriptor.value;
+          const before = Date.now();
+          this.logger.debug(`Init Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Init After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+        })
+      );
+      timeoutMetas.forEach((gqlMeta) => {
+        const fn = gqlMeta.descriptor.value;
+        const timeout = gqlMeta.signalOption.scheduleTime;
+        const timer = setTimeout(async () => {
+          const before = Date.now();
+          this.logger.debug(`Timemout Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Timemout After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+          __privateGet(this, _timeoutMap).delete(fn);
+        }, timeout);
+        __privateGet(this, _timeoutMap).set(fn, timer);
+      });
+      intervalMetas.forEach((gqlMeta) => {
+        const lock = gqlMeta.signalOption.lock;
+        const fn = gqlMeta.descriptor.value;
+        const interval = gqlMeta.signalOption.scheduleTime;
+        const timer = setInterval(async () => {
+          if (lock) {
+            if (__privateGet(this, _lockMap).get(fn)) {
+              this.logger.warn(`${gqlMeta.key} is locked, skipping...`);
+              return;
+            }
+            __privateGet(this, _lockMap).set(fn, true);
+          }
+          const before = Date.now();
+          this.logger.debug(`Interval Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Interval After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+          if (lock)
+            __privateGet(this, _lockMap).set(fn, false);
+        }, interval);
+        __privateGet(this, _intervalMap).set(fn, timer);
+      });
+      cronMetas.forEach((gqlMeta) => {
+        const lock = gqlMeta.signalOption.lock;
+        const fn = gqlMeta.descriptor.value;
+        const cronTime = gqlMeta.signalOption.scheduleCron;
+        if (!cronTime)
+          throw new Error(`Cron time is not found for ${gqlMeta.key}`);
+        const cronJob = CronJob.from({
+          cronTime,
+          onTick: async () => {
+            if (lock) {
+              if (__privateGet(this, _lockMap).get(fn)) {
+                this.logger.warn(`${gqlMeta.key} is locked, skipping...`);
+                return;
+              }
+              __privateGet(this, _lockMap).set(fn, true);
+            }
+            const before = Date.now();
+            this.logger.debug(`Cron Before ${gqlMeta.key} / ${before}`);
+            await fn.apply(this);
+            const after = Date.now();
+            this.logger.debug(`Cron After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+            if (lock)
+              __privateGet(this, _lockMap).set(fn, false);
+          },
+          start: true
+        });
+        __privateGet(this, _cronMap).set(fn, cronJob);
+      });
+    }
+    async onModuleDestroy() {
+      __privateGet(this, _timeoutMap).forEach((timer, fn) => {
+        clearTimeout(timer);
+        __privateGet(this, _timeoutMap).delete(fn);
+      });
+      __privateGet(this, _intervalMap).forEach((timer, fn) => {
+        clearInterval(timer);
+        __privateGet(this, _intervalMap).delete(fn);
+      });
+      await Promise.all(
+        [...__privateGet(this, _cronMap).entries()].map(async ([fn, cronJob]) => {
+          await cronJob.stop();
+          __privateGet(this, _cronMap).delete(fn);
+        })
+      );
+      await Promise.all(
+        destroyMetas.map(async (gqlMeta) => {
+          const fn = gqlMeta.descriptor.value;
+          const before = Date.now();
+          this.logger.debug(`Destroy Before ${gqlMeta.key} / ${before}`);
+          await fn.apply(this);
+          const after = Date.now();
+          this.logger.debug(`Destroy After ${gqlMeta.key} / ${after} (${after - before}ms)`);
+        })
+      );
+    }
+  };
+  _cronMap = new WeakMap();
+  _timeoutMap = new WeakMap();
+  _intervalMap = new WeakMap();
+  _lockMap = new WeakMap();
+  Schedule = __decorateClass([
+    Injectable()
+  ], Schedule);
+  srvRefs.forEach((srvRef) => {
+    const serviceMeta = getServiceMeta(srvRef);
+    if (!serviceMeta)
+      throw new Error(`Service ${srvRef.name} is not found`);
+    Inject(srvRef)(Schedule.prototype, lowerlize(serviceMeta.name));
+  });
+  let ScheduleModule = class {
+  };
+  ScheduleModule = __decorateClass([
+    Global(),
+    Module({ providers: [Schedule] })
+  ], ScheduleModule);
+  return ScheduleModule;
+};
+export {
+  makeScheduleModule
+};

package/esm/src/schema.js

@@ -1,4 +1,13 @@
-import { arraiedModel, dayjs, Enum, Float, ID, Int, JSON } from "@akanjs/base";
+import {
+  applyFnToArrayObjects,
+  arraiedModel,
+  dayjs,
+  Enum,
+  Float,
+  ID,
+  Int,
+  JSON
+} from "@akanjs/base";
 import { isDayjs } from "@akanjs/common";
 import { getClassMeta, getFieldMetas, getFullModelRef, getInputModelRef } from "@akanjs/constant";
 import { getDefaultSchemaOptions, ObjectId } from "@akanjs/document";
@@ -9,6 +18,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 = 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([
   [ID, ObjectId],
   [Int, Number],
@@ -48,12 +75,12 @@ const applyMongoProp = (schemaProps, fieldMeta) => {
     }
     prop = { type: arraiedModel(prop, fieldMeta.optArrDepth), default: [], required: true };
     if (fieldMeta.modelRef.prototype === Date.prototype) {
-      prop.get = (dates) => dates.map((date) => dayjs(date));
-      prop.set = (days) => days.map((day) => day.toDate());
+      prop.get = (dates) => applyFnToArrayObjects(dates, (date) => dayjs(date));
+      prop.set = (days) => applyFnToArrayObjects(days, (day) => day.toDate());
     }
     if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === ID.prototype) {
-      prop.get = (ids) => ids.map((id) => id.toString());
-      prop.set = (ids) => ids.map((id) => new Types.ObjectId(id));
+      prop.get = (ids) => applyFnToArrayObjects(ids, (id) => id.toString());
+      prop.set = (ids) => applyFnToArrayObjects(ids, (id) => new Types.ObjectId(id));
     }
   } else {
     prop.type = arraiedModel(type, fieldMeta.arrDepth);
@@ -95,12 +122,17 @@ const applyMongoProp = (schemaProps, fieldMeta) => {
       prop.set = (v) => v === null ? void 0 : v;
     }
     if (fieldMeta.modelRef.prototype === Date.prototype) {
-      prop.get = (date) => date ? dayjs(date) : void 0;
-      prop.set = (day) => day ? dayjs(day).toDate() : void 0;
+      prop.get = (date) => applyFnToArrayObjects(date, (date2) => date2 ? dayjs(date2) : void 0);
+      prop.set = (day) => applyFnToArrayObjects(day, (day2) => day2 ? dayjs(day2).toDate() : void 0);
     }
     if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === ID.prototype) {
-      prop.get = (id) => id ? id.toString() : void 0;
-      prop.set = (id) => id ? new Types.ObjectId(id) : void 0;
+      if (fieldMeta.arrDepth === 0) {
+        prop.get = (id) => id ? id.toString() : void 0;
+        prop.set = (id) => id ? new Types.ObjectId(id) : void 0;
+      } else {
+        prop.get = (val) => applyFnToArrayObjects(val, (id) => id ? id.toString() : void 0);
+        prop.set = (val) => applyFnToArrayObjects(val, (id) => id ? new Types.ObjectId(id) : void 0);
+      }
     }
     if (fieldMeta.isClass && fieldMeta.isScalar && fieldMeta.default === null && !fieldMeta.nullable) {
       prop.default = makeDefault(fieldMeta.modelRef);
@@ -115,7 +147,7 @@ const applyMongoProp = (schemaProps, fieldMeta) => {
 };
 const createSchema = (modelRef) => {
   const classMeta = getClassMeta(modelRef);
-  const schemaMeta = Reflect.getMetadata(classMeta.refName, ScalarSchemaStorage.prototype);
+  const schemaMeta = getScalarSchemaMetaByName(classMeta.refName);
   if (schemaMeta)
     return schemaMeta;
   const fieldMetas = getFieldMetas(modelRef);
@@ -124,12 +156,12 @@ const createSchema = (modelRef) => {
     applyMongoProp(schemaProps, fieldMeta);
   });
   const schema = new Schema(schemaProps);
-  Reflect.defineMetadata(classMeta.refName, schema, ScalarSchemaStorage.prototype);
+  setScalarSchemaMetaByName(classMeta.refName, schema);
   return schema;
 };
 const schemaOf = (modelRef, docRef, middleware) => {
   const classMeta = getClassMeta(docRef);
-  const schemaMeta = Reflect.getMetadata(classMeta.refName, SchemaStorage.prototype);
+  const schemaMeta = getSchemaMetaByName(classMeta.refName);
   if (schemaMeta)
     return schemaMeta;
   const fieldMetas = getFieldMetas(docRef);
@@ -169,7 +201,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) => {
@@ -215,5 +247,6 @@ const addSchema = (modelRef, docRef, inputRef, middleware) => {
 };
 export {
   addSchema,
+  hasSchema,
   schemaOf
 };

package/esm/src/searchDaemon.js

@@ -202,9 +202,7 @@ let SearchDaemonModule = class {
 };
 SearchDaemonModule = __decorateClass([
   Global(),
-  Module({
-    providers: [SearchDaemon]
-  })
+  Module({ providers: [SearchDaemon] })
 ], SearchDaemonModule);
 export {
   SearchDaemonModule,

package/esm/src/websocket.js

@@ -11,7 +11,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 import { lowerlize } from "@akanjs/common";
 import { Access, Account, getBodyPipes, Me, Self, UserIp, Ws } from "@akanjs/nest";
-import { isServiceEnabled } from "@akanjs/service";
+import { getServiceRefs, isServiceEnabled } from "@akanjs/service";
 import { getArgMetas, getGqlMetas, getSigMeta } from "@akanjs/signal";
 import { Inject, Injectable, UseInterceptors } from "@nestjs/common";
 import { MessageBody, SubscribeMessage, WebSocketGateway, WebSocketServer } from "@nestjs/websockets";
@@ -52,10 +52,11 @@ const websocketOf = (sigRef, allSrvs) => {
   class WsGateway {
     __sigRef__ = sigRef;
   }
-  Object.keys(allSrvs).forEach((srv) => {
-    if (!isServiceEnabled(allSrvs[srv]))
+  Object.keys(allSrvs).forEach((srvName) => {
+    if (!isServiceEnabled(allSrvs[srvName]))
       return;
-    Inject(allSrvs[srv])(WsGateway.prototype, lowerlize(srv));
+    const srvRef = getServiceRefs(srvName)[0];
+    Inject(srvRef)(WsGateway.prototype, lowerlize(srvName));
   });
   const messageGqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Message");
   for (const gqlMeta of messageGqlMetas) {
@@ -94,31 +95,23 @@ const websocketOf = (sigRef, allSrvs) => {
   WebSocketGateway({ cors: { origin: "*" }, transports: ["websocket"] })(WsGateway);
   return WsGateway;
 };
-const websocketServerOf = (sigRef) => {
+const applyWebsocketSignal = (targetRef, sigRef) => {
   const pubsubGqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Pubsub");
-  let Websocket = class {
-    server;
-  };
-  __decorateClass([
-    WebSocketServer()
-  ], Websocket.prototype, "server", 2);
-  Websocket = __decorateClass([
-    Injectable(),
-    WebSocketGateway({ cors: { origin: "*" }, transports: ["websocket"] })
-  ], Websocket);
+  WebSocketGateway({ cors: { origin: "*" }, transports: ["websocket"] })(targetRef);
+  WebSocketServer()(targetRef.prototype, "websocket");
   for (const gqlMeta of pubsubGqlMetas) {
     const [argMetas] = 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;
 };
 export {
-  websocketOf,
-  websocketServerOf
+  applyWebsocketSignal,
+  websocketOf
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/server",
-  "version": "0.9.41",
+  "version": "0.9.43",
   "sourceType": "module",
   "publishConfig": {
     "access": "public"
@@ -30,6 +30,7 @@
     "@nestjs/websockets": "^10.4.15",
     "body-parser": "^1.20.3",
     "cookie-parser": "^1.4.7",
+    "cron": "^4.3.3",
     "dayjs": "^1.11.13",
     "graphql": "^16.10.0",
     "graphql-type-json": "^0.3.2",

package/src/module.d.ts

@@ -7,44 +7,15 @@ interface DatabaseModuleCreateOptions {
     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;
 }
-export declare const databaseModuleOf: ({ constant, database, signal, service, uses, useAsyncs, providers, extended, }: DatabaseModuleCreateOptions, allSrvs: {
+export declare const databaseModuleOf: ({ constant, database, signal, service }: DatabaseModuleCreateOptions, allSrvs: {
     [key: string]: Type | undefined;
 }) => DynamicModule | null;
 interface ServiceModuleCreateOptions {
-    signal: Type;
+    signal?: Type;
     service: Type;
-    uses?: {
-        [key: string]: any;
-    };
-    useAsyncs?: {
-        [key: string]: () => Promise<any>;
-    };
-    providers?: Type[];
 }
-export 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;
-}
-export declare const scalarModuleOf: ({ signals, uses, useAsyncs, providers, enabled }: ScalarModuleCreateOptions, allSrvs: {
+export declare const serviceModuleOf: ({ signal, service }: ServiceModuleCreateOptions, allSrvs: {
     [key: string]: Type | undefined;
 }) => DynamicModule | null;
 interface ScalarModulesCreateOptions {
@@ -53,17 +24,6 @@ interface ScalarModulesCreateOptions {
 export 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[];
-}
-export declare const batchModuleOf: ({ service, uses, useAsyncs, providers, }: BatchModuleCreateOptions) => DynamicModule | null;
 interface UseGlobalsCreateOptions {
     uses?: {
         [key: string]: any;
@@ -71,9 +31,10 @@ interface UseGlobalsCreateOptions {
     useAsyncs?: {
         [key: string]: () => Promise<any>;
     };
+    providers?: Type[];
     injects?: {
         [key: string]: Type;
     };
 }
-export declare const useGlobals: ({ uses, useAsyncs, injects }: UseGlobalsCreateOptions) => DynamicModule;
+export declare const useGlobals: ({ uses, useAsyncs, providers, injects }: UseGlobalsCreateOptions) => DynamicModule;
 export {};

package/src/processor.d.ts

@@ -1,8 +1,7 @@
 import { Type } from "@akanjs/base";
-import type { Queue } from "bull";
 export declare const processorOf: (sigRef: Type, allSrvs: {
     [key: string]: Type;
 }) => {
     new (): {};
 };
-export declare const queueOf: (sigRef: Type, queue: Queue) => Queue<any>;
+export declare const applyQueueSignal: (targetRef: Type, sigRef: Type) => Type;

package/src/schedule.d.ts

@@ -0,0 +1,4 @@
+import type { BackendEnv } from "@akanjs/base";
+export declare const makeScheduleModule: (serverMode: "federation" | "batch" | "all" | "none", backendEnv: BackendEnv) => {
+    new (): {};
+};

package/src/schema.d.ts

@@ -1,5 +1,6 @@
 import { Type } from "@akanjs/base";
 import { BaseMiddleware } from "@akanjs/document";
 import { Schema } from "mongoose";
+export declare const hasSchema: (modelRef: Type) => boolean;
 export declare const schemaOf: <Mdl, Doc, Middleware extends BaseMiddleware>(modelRef: Type<Mdl>, docRef: Type<Doc>, middleware: Type<Middleware>) => Schema<null, Mdl, Doc, undefined, null, Mdl>;
 export declare const addSchema: <Mdl, Doc, Input, Middleware extends BaseMiddleware>(modelRef: Type<Mdl>, docRef: Type<Doc>, inputRef: Type<Input>, middleware: Type<Middleware>) => Schema<null, Mdl, Doc, undefined, null, Mdl>;

package/src/websocket.d.ts

@@ -10,8 +10,6 @@ export declare const websocketOf: (sigRef: Type, allSrvs: {
         __sigRef__: Type;
     };
 };
-export declare const websocketServerOf: (sigRef: Type) => {
-    new (): {
-        server: Server;
-    };
-};
+export declare const applyWebsocketSignal: (targetRef: Type, sigRef: Type) => Type<{
+    websocket: Server;
+}>;