@akanjs/service 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/service",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -10,5 +10,54 @@
     "url": "https://github.com/akan-team/akanjs.git",
     "directory": "pkgs/@akanjs/service"
   },
+  "dependencies": {
+    "@apollo/server": "^4.11.2",
+    "@inquirer/prompts": "^7.2.1",
+    "@nestjs/apollo": "^12.2.2",
+    "@nestjs/common": "^10.4.15",
+    "@nestjs/core": "^10.4.15",
+    "@nestjs/graphql": "^12.2.2",
+    "@nestjs/mongoose": "^10.1.0",
+    "@nestjs/passport": "^10.0.3",
+    "@nestjs/platform-express": "^10.4.15",
+    "@nestjs/platform-socket.io": "^10.4.15",
+    "@nestjs/schedule": "^4.1.2",
+    "@nestjs/websockets": "^10.4.15",
+    "@socket.io/redis-adapter": "^8.3.0",
+    "@urql/core": "^5.1.0",
+    "apple-signin": "^1.0.9",
+    "bull": "^4.16.5",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "dataloader": "^2.2.3",
+    "dayjs": "^1.11.13",
+    "express": "^4.21.2",
+    "graphql": "^16.10.0",
+    "iap": "^1.1.1",
+    "immer": "^10.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "lodash": "^4.17.21",
+    "meilisearch": "^0.47.0",
+    "mongoose": "^8.9.3",
+    "next": "^15.3.0",
+    "passport": "^0.7.0",
+    "passport-apple": "^2.0.2",
+    "passport-facebook": "^3.0.0",
+    "passport-github": "^1.1.0",
+    "passport-google-oauth20": "^2.0.0",
+    "passport-kakao": "^1.0.1",
+    "passport-naver": "^1.0.6",
+    "picocolors": "^1.1.1",
+    "pluralize": "^8.0.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "redis": "^4.7.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "socket.io": "^4.8.1",
+    "socket.io-client": "^4.8.1",
+    "tunnel-ssh": "^5.2.0",
+    "ua-parser-js": "^1.0.40"
+  },
   "main": "./index.js"
 }

package/src/index.d.ts

@@ -1 +1 @@
-export declare const a = 1;
+export * from "./serviceDecorators";

package/src/index.js

@@ -2,10 +2,6 @@ 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))
@@ -14,14 +10,12 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 = {};
-__export(src_exports, {
-  a: () => a
-});
 module.exports = __toCommonJS(src_exports);
-const a = 1;
+__reExport(src_exports, require("./serviceDecorators"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  a
+  ...require("./serviceDecorators")
 });

package/src/serviceDecorators.d.ts

@@ -0,0 +1,167 @@
+import "reflect-metadata";
+import { BaseObject, Dayjs, Type } from "@akanjs/base";
+import { Logger } from "@akanjs/common";
+import { type DocumentModel, type FilterType, FindQueryOption, type GetActionObject, ListQueryOption, QueryOf, type SortOf } from "@akanjs/constant";
+import type { BaseMiddleware, Database, DatabaseModel, DataInputOf } from "@akanjs/document";
+import { FilterOutInternalArgs } from "@akanjs/signal";
+import type { Job, Queue as BullQueue } from "bull";
+import type { HydratedDocument } from "mongoose";
+import type { Server } from "socket.io";
+export type GetServices<AllSrvs extends {
+    [key: string]: Type | undefined;
+}> = {
+    [key in keyof AllSrvs]: AllSrvs[key] extends Type<infer Srv> | undefined ? Srv : AllSrvs[key] extends Type<infer Srv> ? Srv : never;
+};
+export declare class ServiceStorage {
+}
+export interface ServiceInjectMeta {
+    type: "Db" | "Srv" | "Use" | "Queue" | "Websocket";
+    name: string;
+    key: string;
+}
+export declare function Service(name: string): (target: Type) => Type;
+export declare function Srv(name?: string): PropertyDecorator;
+export declare function Use(name?: string): PropertyDecorator;
+export declare function Queue(name?: string): PropertyDecorator;
+export type Queue<Signal> = {
+    [K in keyof Signal as K extends string ? Signal[K] extends (...args: any) => Promise<{
+        __Returns__: "Done";
+    }> ? K : never : never]: Signal[K] extends (...args: infer Args) => Promise<infer R> ? (...args: FilterOutInternalArgs<Args>) => Promise<Job> : never;
+} & BullQueue;
+export declare function Websocket(name?: string): PropertyDecorator;
+export type Websocket<Signal> = {
+    [K in keyof Signal as K extends string ? Signal[K] extends (...args: any) => Promise<{
+        __Returns__: "Subscribe";
+    }> ? K : Signal[K] extends (...args: any) => {
+        __Returns__: "Subscribe";
+    } ? K : never : never]: Signal[K] extends (...args: infer Args) => Promise<{
+        __Returns__: "Subscribe";
+    } & infer R> ? (...args: [...FilterOutInternalArgs<Args>, data: DocumentModel<R>]) => Promise<void> : Signal[K] extends (...args: infer Args) => {
+        __Returns__: "Subscribe";
+    } & infer R ? (...args: [...FilterOutInternalArgs<Args>, data: DocumentModel<R>]) => void : never;
+} & {
+    server: Server;
+};
+export declare function Db(name: string): PropertyDecorator;
+export declare const serviceOf: (srvRef: Type) => Type;
+export declare function MixSrvs<T1 = unknown, T2 = unknown, T3 = unknown, T4 = unknown, T5 = unknown, T6 = unknown, T7 = unknown, T8 = unknown, T9 = unknown, T10 = unknown, T11 = unknown, T12 = unknown, T13 = unknown, T14 = unknown, T15 = unknown, T16 = unknown, T17 = unknown, T18 = unknown, T19 = unknown, T20 = unknown>(t1: Type<T1>, t2?: Type<T2>, t3?: Type<T3>, t4?: Type<T4>, t5?: Type<T5>, t6?: Type<T6>, t7?: Type<T7>, t8?: Type<T8>, t9?: Type<T9>, t10?: Type<T10>, t11?: Type<T11>, t12?: Type<T12>, t13?: Type<T13>, t14?: Type<T14>, t15?: Type<T15>, t16?: Type<T16>, t17?: Type<T17>, t18?: Type<T18>, t19?: Type<T19>, t20?: Type<T20>): Type<T1 & T2 & T3 & T4 & T5 & T6 & T7 & T8 & T9 & T10 & T11 & T12 & T13 & T14 & T15 & T16 & T17 & T18 & T19 & T20>;
+export declare const LogService: <T extends string>(name: T) => {
+    new (): {
+        logger: Logger;
+    };
+};
+type QueueService<Signal> = {
+    [K in keyof Signal as K extends string ? Signal[K] extends (...args: any) => Promise<{
+        __Returns__: "Done";
+    }> ? K : never : never]: Signal[K] extends (...args: infer Args) => Promise<infer R> ? (...args: FilterOutInternalArgs<Args>) => Promise<Job> : never;
+};
+type DatabaseService<T extends string, Input, Doc, Obj, Model, Insight, Filter, Summary> = DatabaseServiceWithQuerySort<T, Input, Doc, Obj, Model, Insight, GetActionObject<Filter>, SortOf<Filter>>;
+type DatabaseServiceWithQuerySort<T extends string, Input, Doc, Obj, Model, Insight, Query, Sort> = {
+    logger: Logger;
+    __databaseModel: Model;
+    __list(query?: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<Doc[]>;
+    __listIds(query?: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<string[]>;
+    __find(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<Doc | null>;
+    __findId(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<string | null>;
+    __pick(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<Doc>;
+    __pickId(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<string>;
+    __exists(query?: QueryOf<Doc>): Promise<string | null>;
+    __count(query?: QueryOf<Doc>): Promise<number>;
+    __insight(query?: QueryOf<Doc>): Promise<Insight>;
+    __search(query: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<{
+        docs: Doc[];
+        count: number;
+    }>;
+    __searchDocs(query: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<Doc[]>;
+    __searchCount(query: QueryOf<Doc>): Promise<number>;
+    _preCreate(data: DataInputOf<Input, Doc>): Promise<DataInputOf<Input, Doc>> | DataInputOf<Input, Doc>;
+    _postCreate(doc: Doc): Promise<Doc> | Doc;
+    _preUpdate(id: string, data: Partial<Doc>): Promise<Partial<Doc>> | Partial<Doc>;
+    _postUpdate(doc: Doc): Promise<Doc> | Doc;
+    _preRemove(id: string): Promise<void> | void;
+    _postRemove(doc: Doc): Promise<Doc> | Doc;
+} & {
+    [key in `${T}Model`]: Model;
+} & {
+    [K in `get${Capitalize<T>}`]: (id: string) => Promise<Doc>;
+} & {
+    [K in `load${Capitalize<T>}`]: (id?: string) => Promise<Doc | null>;
+} & {
+    [K in `load${Capitalize<T>}Many`]: (ids: string[]) => Promise<Doc[]>;
+} & {
+    [K in `create${Capitalize<T>}`]: (data: DataInputOf<Input, Doc>) => Promise<Doc>;
+} & {
+    [K in `update${Capitalize<T>}`]: (id: string, data: Partial<Doc>) => Promise<Doc>;
+} & {
+    [K in `remove${Capitalize<T>}`]: (id: string) => Promise<Doc>;
+} & {
+    [K in `search${Capitalize<T>}`]: (searchText: string, queryOption?: ListQueryOption<Sort, Obj>) => Promise<{
+        docs: Doc[];
+        count: number;
+    }>;
+} & {
+    [K in `searchDocs${Capitalize<T>}`]: (searchText: string, queryOption?: ListQueryOption<Sort, Obj>) => Promise<Doc[]>;
+} & {
+    [K in `searchCount${Capitalize<T>}`]: (searchText: string) => Promise<number>;
+} & {
+    [K in keyof Query as K extends string ? `list${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: ListQueryOption<Sort, Obj>]) => Promise<Doc[]> : never;
+} & {
+    [K in keyof Query as K extends string ? `listIds${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: ListQueryOption<Sort, Obj>]) => Promise<string[]> : never;
+} & {
+    [K in keyof Query as K extends string ? `find${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<Doc | null> : never;
+} & {
+    [K in keyof Query as K extends string ? `findId${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<string | null> : never;
+} & {
+    [K in keyof Query as K extends string ? `pick${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<Doc> : never;
+} & {
+    [K in keyof Query as K extends string ? `pickId${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<string> : never;
+} & {
+    [K in keyof Query as K extends string ? `exists${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args]) => Promise<string | null> : never;
+} & {
+    [K in keyof Query as K extends string ? `count${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args]) => Promise<number> : never;
+} & {
+    [K in keyof Query as K extends string ? `insight${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args]) => Promise<Insight> : never;
+};
+export declare const DbService: <T extends string, Input, Doc extends HydratedDocument<any>, Model extends DatabaseModel<T, Input, Doc, Obj, Insight, Filter, Summary>, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary, Signal = unknown>(database: Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter, Summary>, sigRef?: Type<Signal>) => Type<DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, Summary>>;
+export declare const ExtendedUserService: <T extends string, Input, Doc extends HydratedDocument<any>, Model extends DatabaseModel<T, Input, Doc, Obj, Insight, Filter, Summary>, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary, Srv, Signal = unknown>(database: Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter, Summary>, srvRef: Type<Srv>, sigRef?: Type<Signal>) => Type<DatabaseService<T, Input, Doc, BaseObject & {
+    nickname: string;
+}, Model, Insight, Filter, Summary> & {
+    queue: QueueService<Signal>;
+} & { [K in keyof Srv]: Srv[K] extends (...args: infer Args) => Promise<BaseObject & {
+    nickname: string;
+}> ? (...args: Args) => Promise<Doc> : Srv[K] extends (...args: infer Args) => Promise<(BaseObject & {
+    nickname: string;
+})[]> ? (...args: Args) => Promise<Doc[]> : Srv[K] extends BaseObject & {
+    nickname: string;
+} ? Doc : Srv[K] extends (BaseObject & {
+    nickname: string;
+})[] ? Doc[] : Srv[K]; }>;
+export declare const ExtendedSummaryService: <T extends string, Input, Doc extends HydratedDocument<any>, Model, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary, Srv, Signal = unknown>(database: Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter, Summary>, srvRef: Type<Srv>, sigRef?: Type<Signal>) => Type<Omit<DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, Summary> & {
+    queue: QueueService<Signal>;
+} & { [K in keyof Srv]: Srv[K] extends (...args: infer Args) => Promise<BaseObject & {
+    type: string;
+    at: Dayjs;
+}> ? (...args: Args) => Promise<Doc> : Srv[K] extends (...args: infer Args) => Promise<(BaseObject & {
+    type: string;
+    at: Dayjs;
+})[]> ? (...args: Args) => Promise<Doc[]> : Srv[K] extends BaseObject & {
+    type: string;
+    at: Dayjs;
+} ? Doc : Srv[K] extends (BaseObject & {
+    type: string;
+    at: Dayjs;
+})[] ? Doc[] : Srv[K]; }, "userService">>;
+export declare const ExtendedSettingService: <T extends string, Input, Doc extends HydratedDocument<any>, Model extends DatabaseModel<T, Input, Doc, Obj, Insight, Filter, Summary>, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary, Srv, Signal = unknown>(database: Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter, Summary>, srvRef: Type<Srv>, sigRef?: Type<Signal>) => Type<DatabaseService<T, Input, Doc, BaseObject & {
+    resignupDays: number;
+}, Model, Insight, Filter, Summary> & {
+    queue: QueueService<Signal>;
+} & { [K in keyof Srv]: Srv[K] extends (...args: infer Args) => Promise<BaseObject & {
+    resignupDays: number;
+}> ? (...args: Args) => Promise<Doc> : Srv[K] extends (...args: infer Args) => Promise<(BaseObject & {
+    resignupDays: number;
+})[]> ? (...args: Args) => Promise<Doc[]> : Srv[K] extends BaseObject & {
+    resignupDays: number;
+} ? Doc : Srv[K] extends (BaseObject & {
+    resignupDays: number;
+})[] ? Doc[] : Srv[K]; }>;
+export {};

package/src/serviceDecorators.js

@@ -0,0 +1,345 @@
+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 serviceDecorators_exports = {};
+__export(serviceDecorators_exports, {
+  Db: () => Db,
+  DbService: () => DbService,
+  ExtendedSettingService: () => ExtendedSettingService,
+  ExtendedSummaryService: () => ExtendedSummaryService,
+  ExtendedUserService: () => ExtendedUserService,
+  LogService: () => LogService,
+  MixSrvs: () => MixSrvs,
+  Queue: () => Queue,
+  Service: () => Service,
+  ServiceStorage: () => ServiceStorage,
+  Srv: () => Srv,
+  Use: () => Use,
+  Websocket: () => Websocket,
+  serviceOf: () => serviceOf
+});
+module.exports = __toCommonJS(serviceDecorators_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_common2 = require("@nestjs/common");
+var import_mongoose = require("@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 getServiceInjectMetaMapOnPrototype = (prototype) => {
+  return Reflect.getMetadata("inject", prototype) ?? /* @__PURE__ */ new Map();
+};
+const setServiceInjectMetaMapOnPrototype = (prototype, injectMetaMap) => {
+  Reflect.defineMetadata("inject", injectMetaMap, prototype);
+};
+function Service(name) {
+  return function(target) {
+    const services = getServiceRefs(name);
+    setServiceRefs(name, [...services, target]);
+    Reflect.defineMetadata(name, [...services, target], ServiceStorage.prototype);
+    return target;
+  };
+}
+function Srv(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Srv", key, name: name ?? (0, import_common.capitalize)(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Use(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Use", key, name: name ?? (0, import_common.capitalize)(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Queue(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Queue", key, name: name ?? (0, import_common.capitalize)(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Websocket(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Websocket", key, name: name ?? (0, import_common.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")
+      (0, import_mongoose.InjectModel)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+    else if (injectMeta.type === "Use")
+      (0, import_common2.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`);
+      (0, import_common2.Inject)(services.at(-1))(srvRef.prototype, injectMeta.key);
+    } else if (injectMeta.type === "Queue")
+      (0, import_common2.Inject)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+    else
+      (0, import_common2.Inject)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+  }
+  (0, import_mongoose.InjectConnection)()(srvRef.prototype, "connection");
+  (0, import_common2.Injectable)()(srvRef);
+  setServiceDefined(srvRef);
+  return srvRef;
+};
+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);
+      (0, import_common.applyMixins)(Mix, [srvRef]);
+      return [...acc, ...injectMetadataMap2];
+    }, [])
+  );
+  Reflect.defineMetadata("service", false, Mix.prototype);
+  Reflect.defineMetadata("inject", injectMetadataMap, Mix.prototype);
+  return Mix;
+}
+const LogService = (name) => {
+  class LogService2 {
+    logger = new import_common.Logger(name);
+  }
+  return LogService2;
+};
+const DbService = (database, sigRef) => {
+  const [modelName, className] = [database.refName, (0, import_common.capitalize)(database.refName)];
+  class DbService2 {
+    logger = new import_common.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 = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
+    const query = queryFn(...hasQueryOption ? args.slice(0, -1) : args);
+    const queryOption = hasQueryOption ? lastArg : {};
+    return { query, queryOption };
+  };
+  const filterKeyMetaMap = (0, import_constant.getFilterKeyMetaMapOnPrototype)(database.Filter.prototype);
+  const queryKeys = [...filterKeyMetaMap.keys()];
+  queryKeys.forEach((queryKey) => {
+    const queryFn = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
+    DbService2.prototype[`list${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__list(query, queryOption);
+    };
+    DbService2.prototype[`listIds${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__listIds(query, queryOption);
+    };
+    DbService2.prototype[`find${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__find(query, queryOption);
+    };
+    DbService2.prototype[`findId${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__findId(query, queryOption);
+    };
+    DbService2.prototype[`pick${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__pick(query, queryOption);
+    };
+    DbService2.prototype[`pickId${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__pickId(query, queryOption);
+    };
+    DbService2.prototype[`exists${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__exists(query);
+    };
+    DbService2.prototype[`count${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__count(query);
+    };
+    DbService2.prototype[`insight${(0, import_common.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 = (0, import_constant.getFilterKeyMetaMapOnPrototype)(database.Filter.prototype);
+  const queryKeys = [...filterKeyMetaMap.keys()];
+  queryKeys.forEach((queryKey) => {
+    const queryFn = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
+    srvRef.prototype[`list${(0, import_common.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${(0, import_common.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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Db,
+  DbService,
+  ExtendedSettingService,
+  ExtendedSummaryService,
+  ExtendedUserService,
+  LogService,
+  MixSrvs,
+  Queue,
+  Service,
+  ServiceStorage,
+  Srv,
+  Use,
+  Websocket,
+  serviceOf
+});