@akanjs/service 0.0.53 → 0.0.55

package/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/service",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -18,5 +18,11 @@
     "@nestjs/common": "^10.4.15",
     "@nestjs/mongoose": "^10.1.0",
     "reflect-metadata": "^0.2.2"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
   }
 }

package/src/index.mjs

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

package/src/serviceDecorators.mjs

@@ -0,0 +1,329 @@
+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 "reflect-metadata";
+import { applyMixins, capitalize, Logger } from "@akanjs/common";
+import {
+  getFilterKeyMetaMapOnPrototype,
+  getFilterQuery
+} from "@akanjs/constant";
+import { Inject, Injectable } from "@nestjs/common";
+import { InjectConnection, InjectModel } from "@nestjs/mongoose";
+class ServiceStorage {
+}
+const getServiceRefs = (refName) => {
+  return Reflect.getMetadata(refName, ServiceStorage.prototype) ?? [];
+};
+const setServiceRefs = (refName, services) => {
+  Reflect.defineMetadata(refName, services, ServiceStorage.prototype);
+};
+const isServiceDefined = (srvRef) => {
+  return Reflect.getMetadata("service", srvRef.prototype) ?? false;
+};
+const setServiceDefined = (srvRef) => {
+  Reflect.defineMetadata("service", true, srvRef.prototype);
+};
+const setServiceMeta = (srvRef, meta) => {
+  Reflect.defineMetadata("serviceMeta", meta, srvRef.prototype);
+};
+const getServiceMeta = (srvRef) => {
+  return Reflect.getMetadata("serviceMeta", srvRef.prototype);
+};
+const isServiceEnabled = (srvRef) => {
+  const meta = getServiceMeta(srvRef);
+  return meta?.enabled ?? false;
+};
+const getServiceInjectMetaMapOnPrototype = (prototype) => {
+  return Reflect.getMetadata("inject", prototype) ?? /* @__PURE__ */ new Map();
+};
+const setServiceInjectMetaMapOnPrototype = (prototype, injectMetaMap) => {
+  Reflect.defineMetadata("inject", injectMetaMap, prototype);
+};
+function Service(name, { enabled = true, serverMode } = {}) {
+  return function(target) {
+    const services = getServiceRefs(name);
+    const isEnabled = enabled && (!serverMode || process.env.SERVER_MODE === serverMode || process.env.SERVER_MODE === "all");
+    setServiceMeta(target, { name, enabled: isEnabled });
+    if (!isEnabled)
+      return target;
+    setServiceRefs(name, [...services, target]);
+    return target;
+  };
+}
+function Srv(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Srv", key, name: name ?? capitalize(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Use(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Use", key, name: name ?? capitalize(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Queue(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Queue", key, name: name ?? capitalize(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Websocket(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Websocket", key, name: name ?? capitalize(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Db(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Db", key, name });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+const serviceOf = (srvRef) => {
+  if (isServiceDefined(srvRef))
+    return srvRef;
+  const injectMetaMap = getServiceInjectMetaMapOnPrototype(srvRef.prototype);
+  for (const injectMeta of [...injectMetaMap.values()]) {
+    if (injectMeta.type === "Db")
+      InjectModel(injectMeta.name)(srvRef.prototype, injectMeta.key);
+    else if (injectMeta.type === "Use")
+      Inject(injectMeta.name)(srvRef.prototype, injectMeta.key);
+    else if (injectMeta.type === "Srv") {
+      const services = getServiceRefs(injectMeta.name);
+      if (!services.length)
+        throw new Error(`Service ${injectMeta.name} not found`);
+      Inject(services.at(-1))(srvRef.prototype, injectMeta.key);
+    } else if (injectMeta.type === "Queue")
+      Inject(injectMeta.name)(srvRef.prototype, injectMeta.key);
+    else
+      Inject(injectMeta.name)(srvRef.prototype, injectMeta.key);
+  }
+  InjectConnection()(srvRef.prototype, "connection");
+  Injectable()(srvRef);
+  setServiceDefined(srvRef);
+  return srvRef;
+};
+const AVOID_MIX_SRV_KEY_SET = /* @__PURE__ */ new Set(["onModuleInit", "onModuleDestroy"]);
+function MixSrvs(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) {
+  class Mix extends t1 {
+  }
+  const injectMetadataMap = new Map(
+    [t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20].filter((t) => !!t).reduce((acc, srvRef) => {
+      const injectMetadataMap2 = getServiceInjectMetaMapOnPrototype(srvRef);
+      applyMixins(Mix, [srvRef], AVOID_MIX_SRV_KEY_SET);
+      return [...acc, ...injectMetadataMap2];
+    }, [])
+  );
+  Reflect.defineMetadata("service", false, Mix.prototype);
+  Reflect.defineMetadata("inject", injectMetadataMap, Mix.prototype);
+  return Mix;
+}
+const LogService = (name) => {
+  class LogService2 {
+    logger = new Logger(name);
+  }
+  return LogService2;
+};
+const DbService = (database, sigRef) => {
+  const [modelName, className] = [database.refName, capitalize(database.refName)];
+  class DbService2 {
+    logger = new Logger(`${modelName}Service`);
+    __databaseModel;
+    async __list(query, queryOption) {
+      return await this.__databaseModel.__list(query, queryOption);
+    }
+    async __listIds(query, queryOption) {
+      return await this.__databaseModel.__listIds(query, queryOption);
+    }
+    async __find(query, queryOption) {
+      return await this.__databaseModel.__find(query, queryOption);
+    }
+    async __findId(query, queryOption) {
+      return await this.__databaseModel.__findId(query, queryOption);
+    }
+    async __pick(query, queryOption) {
+      return await this.__databaseModel.__pick(query, queryOption);
+    }
+    async __pickId(query, queryOption) {
+      return await this.__databaseModel.__pickId(query, queryOption);
+    }
+    async __exists(query) {
+      return await this.__databaseModel.__exists(query);
+    }
+    async __count(query) {
+      return await this.__databaseModel.__count(query);
+    }
+    async __insight(query) {
+      return await this.__databaseModel.__insight(query);
+    }
+    async __search(searchText, queryOption) {
+      return await this.__databaseModel[`search${className}`](searchText, queryOption);
+    }
+    async __searchDocs(searchText, queryOption) {
+      return await this.__databaseModel[`searchDocs${className}`](searchText, queryOption);
+    }
+    async __searchCount(searchText) {
+      return await this.__databaseModel[`searchCount${className}`](searchText);
+    }
+    async _preCreate(data) {
+      return data;
+    }
+    async _postCreate(doc) {
+      return doc;
+    }
+    async _preUpdate(id, data) {
+      return data;
+    }
+    async _postUpdate(doc) {
+      return doc;
+    }
+    async _preRemove(id) {
+      return;
+    }
+    async _postRemove(doc) {
+      return doc;
+    }
+    async [`get${className}`](id) {
+      return await this.__databaseModel[`get${className}`](id);
+    }
+    async [`load${className}`](id) {
+      return await this.__databaseModel[`load${className}`](id);
+    }
+    async [`load${className}Many`](ids) {
+      return await this.__databaseModel[`load${className}Many`](ids);
+    }
+    async [`create${className}`](data) {
+      const input = await this._preCreate(data);
+      const doc = await this.__databaseModel[`create${className}`](input);
+      return await this._postCreate(doc);
+    }
+    async [`update${className}`](id, data) {
+      const input = await this._preUpdate(id, data);
+      const doc = await this.__databaseModel[`update${className}`](id, input);
+      return await this._postUpdate(doc);
+    }
+    async [`remove${className}`](id) {
+      await this._preRemove(id);
+      const doc = await this.__databaseModel[`remove${className}`](id);
+      return await this._postRemove(doc);
+    }
+    async [`search${className}`](query, queryOption) {
+      return await this.__databaseModel[`search${className}`](query, queryOption);
+    }
+    async [`searchDocs${className}`](query, queryOption) {
+      return await this.__databaseModel[`searchDocs${className}`](query, queryOption);
+    }
+    async [`searchCount${className}`](query) {
+      return await this.__databaseModel[`searchCount${className}`](query);
+    }
+  }
+  __decorateClass([
+    Use(`${modelName}Model`)
+  ], DbService2.prototype, "__databaseModel", 2);
+  const getQueryDataFromKey = (queryKey, args) => {
+    const lastArg = args.at(-1);
+    const hasQueryOption = lastArg && typeof lastArg === "object" && (typeof lastArg.select === "object" || typeof lastArg.skip === "number" || typeof lastArg.limit === "number" || typeof lastArg.sort === "string");
+    const queryFn = getFilterQuery(database.Filter, queryKey);
+    const query = queryFn(...hasQueryOption ? args.slice(0, -1) : args);
+    const queryOption = hasQueryOption ? lastArg : {};
+    return { query, queryOption };
+  };
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(database.Filter.prototype);
+  const queryKeys = [...filterKeyMetaMap.keys()];
+  queryKeys.forEach((queryKey) => {
+    const queryFn = getFilterQuery(database.Filter, queryKey);
+    DbService2.prototype[`list${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__list(query, queryOption);
+    };
+    DbService2.prototype[`listIds${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__listIds(query, queryOption);
+    };
+    DbService2.prototype[`find${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__find(query, queryOption);
+    };
+    DbService2.prototype[`findId${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__findId(query, queryOption);
+    };
+    DbService2.prototype[`pick${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__pick(query, queryOption);
+    };
+    DbService2.prototype[`pickId${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__pickId(query, queryOption);
+    };
+    DbService2.prototype[`exists${capitalize(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__exists(query);
+    };
+    DbService2.prototype[`count${capitalize(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__count(query);
+    };
+    DbService2.prototype[`insight${capitalize(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__insight(query);
+    };
+  });
+  Use(`${modelName}Model`)(DbService2.prototype, `${modelName}Model`);
+  return DbService2;
+};
+const ExtendedUserService = (database, srvRef, sigRef) => {
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(database.Filter.prototype);
+  const queryKeys = [...filterKeyMetaMap.keys()];
+  queryKeys.forEach((queryKey) => {
+    const queryFn = getFilterQuery(database.Filter, queryKey);
+    srvRef.prototype[`list${capitalize(queryKey)}`] = async function(...args) {
+      const queryOption = args.at(-1);
+      const hasQueryOption = typeof queryOption === "object" && (typeof queryOption.select === "object" || typeof queryOption.skip === "number" || typeof queryOption.limit === "number" || typeof queryOption.sort === "string");
+      const query = queryFn(...hasQueryOption ? args.slice(0, -1) : args);
+      return this.__list(query, queryOption);
+    };
+    srvRef.prototype[`insight${capitalize(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__insight(query);
+    };
+  });
+  return srvRef;
+};
+const ExtendedSummaryService = (database, srvRef, sigRef) => {
+  return srvRef;
+};
+const ExtendedSettingService = (database, srvRef, sigRef) => {
+  return srvRef;
+};
+export {
+  Db,
+  DbService,
+  ExtendedSettingService,
+  ExtendedSummaryService,
+  ExtendedUserService,
+  LogService,
+  MixSrvs,
+  Queue,
+  Service,
+  ServiceStorage,
+  Srv,
+  Use,
+  Websocket,
+  isServiceEnabled,
+  serviceOf
+};