akanjs 0.0.1 → 2.0.0-beta.1

package/service/serviceModule.ts

@@ -0,0 +1,221 @@
+import type { MergeAllKeyOfObjects, PromiseOrObject, UnCls } from "akanjs/base";
+import { capitalize, lowerlize } from "akanjs/common";
+import type { ConstantModel, QueryOf } from "akanjs/constant";
+import type {
+  CRUDEventType,
+  DatabaseModel,
+  DataInputOf,
+  Doc,
+  FindQueryOption,
+  ListQueryOption,
+  SaveEventType,
+} from "akanjs/document";
+import type { ServiceCls } from "./serve";
+import type { DatabaseService } from "./types";
+
+export class ServiceModel<
+  Srv extends ServiceCls = ServiceCls,
+  CnstModel extends ConstantModel = any,
+  DbModel extends DatabaseModel = any,
+  SrvMap extends { [key: string]: any } = { [K in `${Uncapitalize<Srv["refName"]>}Service`]: UnCls<Srv> },
+> {
+  srv: Srv;
+  cnst: CnstModel;
+  db: DbModel;
+  srvMap: SrvMap;
+  constructor(srv: Srv, cnst?: CnstModel, db?: DbModel, srvMap?: { [key: string]: ServiceCls }) {
+    this.srv = srv;
+    this.cnst = cnst ?? (null as unknown as CnstModel);
+    this.db = db ?? (null as unknown as DbModel);
+    this.srvMap = (srvMap ?? { [`${lowerlize(srv.refName)}Service`]: srv }) as unknown as SrvMap;
+  }
+  static fromModel<Srv extends ServiceCls, CnstModel extends ConstantModel, DbModel extends DatabaseModel>(
+    srv: Srv,
+    cnst: CnstModel,
+    db: DbModel,
+  ): ServiceModel<Srv, CnstModel, DbModel> {
+    return new ServiceModel<Srv, CnstModel, DbModel>(srv, cnst, db);
+  }
+  static from<Srv extends ServiceCls>(srv: Srv) {
+    return new ServiceModel<Srv, never, never>(srv);
+  }
+  with<SrvModules extends ServiceModel[]>(...srvs: SrvModules) {
+    return new ServiceModel(
+      this.srv,
+      this.cnst,
+      this.db,
+      Object.assign({}, this.srvMap, ...srvs.map((srv) => srv.srvMap)),
+    ) as unknown as ServiceModel<
+      Srv & MergeAllKeyOfObjects<SrvModules, "srv">,
+      CnstModel,
+      DbModel,
+      SrvMap & MergeAllKeyOfObjects<SrvModules, "srvMap">
+    >;
+  }
+
+  static getDefaultDbServiceMethods(className: string) {
+    const dbServiceMethods = {
+      async __get(this: DatabaseService, id: string) {
+        return await this.__databaseModel.__get(id);
+      },
+      async [`get${className}`](this: DatabaseService, id: string) {
+        return this.__get(id);
+      },
+      async __load(this: DatabaseService, id?: string) {
+        return await this.__databaseModel.__load(id);
+      },
+      async [`load${className}`](this: DatabaseService, id?: string) {
+        return this.__load(id);
+      },
+      async __loadMany(this: DatabaseService, ids: string[]) {
+        return await this.__databaseModel.__loadMany(ids);
+      },
+      async [`load${className}Many`](this: DatabaseService, ids: string[]) {
+        return this.__loadMany(ids);
+      },
+      async __list(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) {
+        return await this.__databaseModel.__list(query, queryOption);
+      },
+      async __listIds(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) {
+        return await this.__databaseModel.__listIds(query, queryOption);
+      },
+      async __find(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
+        return await this.__databaseModel.__find(query, queryOption);
+      },
+      async __findId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
+        return await this.__databaseModel.__findId(query, queryOption);
+      },
+      async __pick(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
+        return await this.__databaseModel.__pick(query, queryOption);
+      },
+      async __pickId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
+        return await this.__databaseModel.__pickId(query, queryOption);
+      },
+      async __exists(this: DatabaseService, query: QueryOf<any>) {
+        return await this.__databaseModel.__exists(query);
+      },
+      async __count(this: DatabaseService, query: QueryOf<any>) {
+        return await this.__databaseModel.__count(query);
+      },
+      async __insight(this: DatabaseService, query: QueryOf<any>) {
+        return await this.__databaseModel.__insight(query);
+      },
+      async _preCreate(this: DatabaseService, data: DataInputOf) {
+        return data;
+      },
+      async _postCreate(this: DatabaseService, doc: Doc) {
+        return doc;
+      },
+      async _preUpdate(this: DatabaseService, id: string, data: Partial<Doc>) {
+        return data;
+      },
+      async _postUpdate(this: DatabaseService, doc: Doc) {
+        return doc;
+      },
+      async _preRemove(this: DatabaseService, id: string) {
+        return;
+      },
+      async _postRemove(this: DatabaseService, doc: Doc) {
+        return doc;
+      },
+      listenPre(
+        this: DatabaseService,
+        type: SaveEventType,
+        listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>,
+      ) {
+        return this.__databaseModel.listenPre(type, listener);
+      },
+      listenPost(
+        this: DatabaseService,
+        type: SaveEventType,
+        listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>,
+      ) {
+        return this.__databaseModel.listenPost(type, listener);
+      },
+      async __create(this: DatabaseService, data: DataInputOf) {
+        const input = this.__libsPreCreate ? await this.__libsPreCreate(data) : await this._preCreate?.(data);
+        const doc = await this.__databaseModel.__create(input ?? data);
+        return (this.__libsPostCreate ? await this.__libsPostCreate(doc) : await this._postCreate?.(doc)) ?? doc;
+      },
+      async [`create${className}`](this: DatabaseService, data: DataInputOf) {
+        return this.__create(data);
+      },
+      async __update(this: DatabaseService, id: string, data: DataInputOf) {
+        const input = this.__libsPreUpdate ? await this.__libsPreUpdate(id, data) : await this._preUpdate?.(id, data);
+        const doc = await this.__databaseModel.__update(id, input);
+        return (this.__libsPostUpdate ? await this.__libsPostUpdate(doc) : await this._postUpdate?.(doc)) ?? doc;
+      },
+      async [`update${className}`](this: DatabaseService, id: string, data: DataInputOf) {
+        return this.__update(id, data);
+      },
+      async __remove(this: DatabaseService, id: string): Promise<Doc> {
+        if (this.__libsPreRemove) await this.__libsPreRemove(id);
+        else await this._preRemove?.(id);
+        const doc = await this.__databaseModel.__remove(id);
+        return (this.__libsPostRemove ? await this.__libsPostRemove(doc) : await this._postRemove?.(doc)) ?? doc;
+      },
+      async [`remove${className}`](this: DatabaseService, id: string): Promise<Doc> {
+        return this.__remove(id);
+      },
+    };
+    return dbServiceMethods;
+  }
+  static getFilterServiceMethods(queryKey: string, queryFn: (...args: any[]) => QueryOf<any>) {
+    const capitalizedQueryKey = capitalize(queryKey);
+    const getQueryDataFromKey = (queryKey: string, args: any): { query: any; queryOption: any } => {
+      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 query = queryFn(...(hasQueryOption ? args.slice(0, -1) : args));
+      const queryOption = hasQueryOption ? lastArg : {};
+      return { query, queryOption };
+    };
+    const filterServiceMethods = {
+      [`list${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__list(query, queryOption);
+      },
+      [`listIds${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__listIds(query, queryOption);
+      },
+      [`find${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__find(query, queryOption);
+      },
+      [`findId${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__findId(query, queryOption);
+      },
+      [`pick${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__pick(query, queryOption);
+      },
+      [`pickId${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__pickId(query, queryOption);
+      },
+      [`exists${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+        const { query } = getQueryDataFromKey(queryKey, args);
+        return this.__exists(query);
+      },
+      [`count${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+        const { query } = getQueryDataFromKey(queryKey, args);
+        return this.__count(query);
+      },
+      [`insight${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
+        const { query } = getQueryDataFromKey(queryKey, args);
+        return this.__insight(query);
+      },
+      [`query${capitalizedQueryKey}`]: function (this: DatabaseService, ...args: any) {
+        return queryFn(...args);
+      },
+    };
+    return filterServiceMethods;
+  }
+}

package/service/serviceRegistry.ts

@@ -0,0 +1,26 @@
+import { INJECT_META } from "akanjs/base";
+import { applyMixins } from "akanjs/common";
+import type { AdaptorCls } from "./adapt";
+import type { ServiceCls } from "./serve";
+
+export class ServiceRegistry {
+  static #database = new Map<string, ServiceCls>();
+  static #plain = new Map<string, ServiceCls>();
+  static #adaptor = new Map<string, AdaptorCls>();
+  static setDatabase(refName: string, service: ServiceCls) {
+    const existingSrv = ServiceRegistry.#database.get(refName);
+    if (existingSrv) {
+      applyMixins(existingSrv, [service]);
+      Object.assign(existingSrv[INJECT_META], service[INJECT_META]);
+    } else ServiceRegistry.#database.set(refName, service);
+  }
+  static getDatabase(refName: string) {
+    return ServiceRegistry.#database.get(refName);
+  }
+  static setPlain(refName: string, service: ServiceCls) {
+    ServiceRegistry.#plain.set(refName, service);
+  }
+  static setAdaptor(refName: string, adaptor: AdaptorCls) {
+    ServiceRegistry.#adaptor.set(refName, adaptor);
+  }
+}

package/service/types.ts

@@ -0,0 +1,113 @@
+import type { Cls, MergeAllTypes, PromiseOrObject } from "akanjs/base";
+import type { Logger } from "akanjs/common";
+import type { QueryOf } from "akanjs/constant";
+import type {
+  CRUDEventType,
+  DatabaseInstance,
+  DataInputOf,
+  Doc as DbDoc,
+  ExtractQuery,
+  ExtractSort,
+  FilterInstance,
+  FindQueryOption,
+  GetDocObject,
+  ListQueryOption,
+  QueryMethodPart,
+  SaveEventType,
+} from "akanjs/document";
+
+type ServiceMixinOmitKey =
+  | "onInit"
+  | "onDestroy"
+  | "_libsOnInit"
+  | "_libsOnDestroy"
+  | "_preCreate"
+  | "_postCreate"
+  | "_preUpdate"
+  | "_postUpdate"
+  | "_preRemove"
+  | "_postRemove"
+  | "_libsPreCreate"
+  | "_libsPostCreate"
+  | "_libsPreUpdate"
+  | "_libsPostUpdate"
+  | "_libsPreRemove"
+  | "_libsPostRemove";
+
+export type DatabaseService<
+  T extends string = string,
+  Input = any,
+  Doc = any,
+  Obj = any,
+  Model = any,
+  Insight = any,
+  Filter extends FilterInstance = FilterInstance,
+  LibSrvs extends Cls[] = [],
+  _Query extends ExtractQuery<Filter> = ExtractQuery<Filter>,
+  _Sort extends ExtractSort<Filter> = ExtractSort<Filter>,
+  _CapitalizedRefName extends Capitalize<T> = Capitalize<T>,
+  _DataInputOfDoc extends DataInputOf<Input, Doc> = DataInputOf<Input, Doc>,
+  _QueryOfDoc extends QueryOf<Doc> = QueryOf<Doc>,
+  _FindQueryOption extends FindQueryOption<_Sort, Obj> = FindQueryOption<_Sort, Obj>,
+  _ListQueryOption extends ListQueryOption<_Sort, Obj> = ListQueryOption<_Sort, Obj>,
+  _DocObjectOfDoc = GetDocObject<Doc>,
+  _MixedLibSrv = MergeAllTypes<LibSrvs, ServiceMixinOmitKey>,
+> = {
+  logger: Logger;
+  __databaseModel: Model;
+  __get: (id: string) => Promise<Doc>;
+  __load: (id?: string) => Promise<Doc | null>;
+  __loadMany: (ids: string[]) => Promise<Doc[]>;
+  __create: (data: _DataInputOfDoc) => Promise<Doc>;
+  __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
+  __remove: (id: string) => Promise<Doc>;
+  __list(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
+  __listIds(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
+  __find(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;
+  __findId(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<string | null>;
+  __pick(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc>;
+  __pickId(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<string>;
+  __exists(query?: _QueryOfDoc): Promise<string | null>;
+  __count(query?: _QueryOfDoc): Promise<number>;
+  __insight(query?: _QueryOfDoc): Promise<Insight>;
+  _preCreate?(data: _DataInputOfDoc): PromiseOrObject<_DataInputOfDoc>;
+  _postCreate?(doc: Doc): Promise<Doc> | Doc;
+  _preUpdate?(id: string, data: Partial<Doc>): PromiseOrObject<Partial<Doc>>;
+  _postUpdate?(doc: Doc): Promise<Doc> | Doc;
+  _preRemove?(id: string): Promise<void> | void;
+  _postRemove?(doc: Doc): Promise<Doc> | Doc;
+  __libsPreCreate: (data: _DataInputOfDoc) => Promise<_DataInputOfDoc>;
+  __libsPostCreate: (doc: Doc) => Promise<Doc>;
+  __libsPreUpdate: (id: string, data: Partial<Doc>) => Promise<Partial<Doc>>;
+  __libsPostUpdate: (doc: Doc) => Promise<Doc>;
+  __libsPreRemove: (id: string) => Promise<void>;
+  __libsPostRemove: (doc: Doc) => Promise<Doc>;
+  listenPre: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+  listenPost: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
+} & { [key in `${T}Model`]: Model } & {
+  [K in `get${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & {
+  [K in `load${_CapitalizedRefName}`]: (id?: string) => Promise<Doc | null>;
+} & {
+  [K in `load${_CapitalizedRefName}Many`]: (ids: string[]) => Promise<Doc[]>;
+} & {
+  [K in `create${_CapitalizedRefName}`]: (data: _DataInputOfDoc) => Promise<Doc>;
+} & {
+  [K in `update${_CapitalizedRefName}`]: (id: string, data: Partial<Doc>) => Promise<Doc>;
+} & {
+  [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & QueryMethodPart<_Query, _Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc> & {
+    [K in keyof _MixedLibSrv]: _MixedLibSrv[K] extends (...args: infer Args) => Promise<infer Value>
+      ? Value extends (infer SingleValue)[]
+        ? SingleValue extends DatabaseInstance
+          ? _DocObjectOfDoc extends GetDocObject<SingleValue>
+            ? (...args: Args) => Promise<Doc[]>
+            : _MixedLibSrv[K]
+          : _MixedLibSrv[K]
+        : Value extends DbDoc<any>
+          ? _DocObjectOfDoc extends GetDocObject<Value>
+            ? (...args: Args) => Promise<Doc>
+            : _MixedLibSrv[K]
+          : _MixedLibSrv[K]
+      : _MixedLibSrv[K];
+  };

package/signal/base.signal.ts

@@ -0,0 +1,46 @@
+import { FetchClient } from "akanjs/fetch";
+import { srv } from "akanjs/service";
+import { endpoint } from "./endpoint";
+import { internal } from "./internal";
+import { serverSignal } from "./serverSignal";
+import { SignalRegistry } from "./signalRegistry";
+
+export class BaseInternal extends internal(srv.base, ({ interval, cron }) => ({})) {}
+
+export class BaseEndpoint extends endpoint(srv.base, ({ query, mutation, message, pubsub }) => ({
+  ping: query(String, { cache: 3000 }).exec(() => "ping"),
+  pingBody: mutation(String)
+    .body("data", String)
+    .exec((data) => `pingBody: ${data}`),
+  pingParam: query(String, { cache: 10000 })
+    .param("id", String)
+    .exec((id) => `pingParam: ${id}`),
+  pingQuery: query(String, { nullable: true })
+    .search("id", String)
+    .exec((id) => `pingQuery: ${id}`),
+  cleanup: mutation(Boolean).exec(async function () {
+    if (process.env.NODE_ENV !== "test") throw new Error("cleanup is only available in test environment");
+    await this.baseService.cleanup();
+    return true;
+  }),
+  wsPing: message(String)
+    .msg("data", String, { nullable: true })
+    .exec((data) => `wsPing: ${data}`),
+  pubsubPing: pubsub(String).exec(() => {
+  }),
+})) {}
+
+export class Base extends serverSignal(BaseEndpoint, BaseInternal) {}
+export const base = SignalRegistry.registerService(BaseInternal, BaseEndpoint, Base);
+
+const createBaseFetch = () => FetchClient.from(base);
+type BaseFetch = ReturnType<typeof createBaseFetch>;
+
+let fetchCache: BaseFetch | undefined;
+export const fetch = new Proxy({} as BaseFetch, {
+  get(_target, prop, receiver) {
+    fetchCache ??= createBaseFetch();
+    return Reflect.get(fetchCache, prop, receiver);
+  },
+});
+export const getSerializedSignal = () => fetch.serializedSignal;

package/signal/endpoint.ts

@@ -0,0 +1,122 @@
+import type { Assign } from "akanjs/base";
+import { ENDPOINT_META } from "akanjs/base";
+import { applyMixins } from "akanjs/common";
+import { type Adaptor, type AdaptorCls, dangerouslyAdapt, type ServiceModel } from "akanjs/service";
+import { buildEndpoint, type EndpointBuilder, type EndpointInfo } from "./endpointInfo";
+
+export interface Endpoint extends Adaptor {}
+
+export interface EndpointCls<
+  SrvModule extends ServiceModel = ServiceModel,
+  EndpointInfoObj extends { [key: string]: EndpointInfo } = { [key: string]: EndpointInfo },
+> extends AdaptorCls {
+  baseName: SrvModule["srv"]["refName"];
+  srv: SrvModule;
+  [ENDPOINT_META]: EndpointInfoObj;
+}
+
+type ExtendedEndpointReturn<ClientReturns, Full, Light, Insight> = ClientReturns extends (infer R)[]
+  ? ExtendedEndpointReturn<R, Full, Light, Insight>[]
+  : Full extends ClientReturns
+    ? Full
+    : Light extends ClientReturns
+      ? Light
+      : Insight extends ClientReturns
+        ? Insight
+        : ClientReturns;
+
+type EndpointMetaOf<EndpCls> = EndpCls extends EndpointCls<any, infer EndpointInfoObj> ? EndpointInfoObj : never;
+
+type MergeEndpointMetas<EndpClses extends readonly EndpointCls[], Acc = unknown> = EndpClses extends readonly [
+  infer First extends EndpointCls,
+  ...infer Rest extends readonly EndpointCls[],
+]
+  ? MergeEndpointMetas<Rest, Assign<Acc, EndpointMetaOf<First>>>
+  : Acc;
+
+type ExtendEndpoints<
+  SrvModule extends ServiceModel,
+  LibEndpoints extends readonly EndpointCls[],
+  _Full = NonNullable<SrvModule["cnst"]>["_Full"],
+  _Light = NonNullable<SrvModule["cnst"]>["_Light"],
+  _Insight = NonNullable<SrvModule["cnst"]>["_Insight"],
+  _Merged = MergeEndpointMetas<LibEndpoints>,
+> = {
+  [K in keyof _Merged]: _Merged[K] extends EndpointInfo<
+    infer ReqType,
+    infer Srvs,
+    infer ArgNames,
+    infer Args,
+    infer InternalArgs,
+    infer ServerArgs,
+    infer Returns,
+    infer ClientReturns,
+    infer ServerReturns,
+    infer Nullable
+  >
+    ? EndpointInfo<
+        ReqType,
+        Srvs,
+        ArgNames,
+        Args,
+        InternalArgs,
+        ServerArgs,
+        Returns,
+        ExtendedEndpointReturn<ClientReturns, _Full, _Light, _Insight>,
+        ServerReturns,
+        Nullable
+      >
+    : never;
+};
+
+/** Builds a typed endpoint adaptor from a service module and endpoint builder. */
+export function endpoint<
+  SrvModule extends ServiceModel,
+  Builder extends EndpointBuilder<SrvModule>,
+  LibEndpoints extends readonly EndpointCls[],
+>(
+  srv: SrvModule,
+  builder: Builder,
+  ...libEndpoints: LibEndpoints
+): EndpointCls<
+  SrvModule,
+  LibEndpoints extends readonly []
+    ? ReturnType<Builder>
+    : Assign<ReturnType<Builder>, ExtendEndpoints<SrvModule, LibEndpoints>>
+> {
+  const srvKeys = [
+    ...new Set([
+      ...Object.keys(srv.srvMap),
+      ...libEndpoints.flatMap((libEndpoint) => Object.keys(libEndpoint.srv.srvMap)),
+    ]),
+  ];
+  const endpointCls = class Endpoint extends dangerouslyAdapt(`${srv.srv.refName}Endpoint`, ({ service }) => ({
+    ...Object.fromEntries(srvKeys.map((srvRefName) => [srvRefName, service()])),
+  })) {
+    static baseName = srv.srv.refName;
+    static srv = srv;
+    static [ENDPOINT_META] = builder(buildEndpoint);
+  };
+  libEndpoints.forEach((libEndpoint) => {
+    Object.assign(endpointCls[ENDPOINT_META], libEndpoint[ENDPOINT_META]);
+    Object.assign(endpointCls.srv.srvMap, libEndpoint.srv.srvMap);
+  });
+  applyMixins(endpointCls, [...libEndpoints]);
+  return endpointCls as any;
+}
+
+export function sliceEndpoint<SrvModule extends ServiceModel, Builder extends EndpointBuilder<SrvModule>>(
+  srv: SrvModule,
+  builder: Builder,
+): EndpointCls<SrvModule, ReturnType<Builder>> {
+  const sigRef = class SliceEndpoint extends dangerouslyAdapt(`${srv.srv.refName}SliceEndpoint`, ({ service }) => ({
+    ...Object.fromEntries(Object.keys(srv.srvMap).map((srvRefName) => [srvRefName, service()])),
+  })) {
+    static baseName = srv.srv.refName;
+    static srv = srv;
+    static [ENDPOINT_META] = {};
+  };
+  Object.assign(sigRef[ENDPOINT_META], builder(buildEndpoint));
+  Object.assign(sigRef.srv.srvMap, srv.srvMap);
+  return sigRef as any;
+}