akanjs 0.0.1 → 2.0.0-beta.0

package/signal/signalContext.ts

@@ -0,0 +1,446 @@
+import {
+  type BaseEnv,
+  type Cls,
+  FIELD_META,
+  INTERNAL_META,
+  PrimitiveRegistry,
+  type PromiseOrObject,
+  Upload,
+} from "akanjs/base";
+import {
+  type ConstantCls,
+  type ConstantFieldTypeInput,
+  ConstantRegistry,
+  deserialize,
+  serialize,
+} from "akanjs/constant";
+import type { Adaptor, AdaptorCls, DatabaseService, InjectRegistry, LiveRegistry } from "akanjs/service";
+import type { Internal, InternalCls, InternalInfo, MiddlewareCls } from ".";
+import type { EndpointInfo } from "./endpointInfo";
+import { Exception } from "./exception";
+
+export type SignalTransportType = "http" | "websocket";
+
+interface WebSocketRequest {
+  ws: Bun.ServerWebSocket<unknown>;
+  data: unknown[];
+  eventType: WebSocketEventType;
+}
+type RuntimeRecord = Record<string, unknown>;
+
+interface ExceptionLike {
+  statusCode: number;
+  toJSON(): object;
+}
+
+const isExceptionLike = (error: unknown): error is ExceptionLike => {
+  return (
+    error instanceof Exception ||
+    (error instanceof Error &&
+      "statusCode" in error &&
+      typeof (error as { statusCode?: unknown }).statusCode === "number" &&
+      typeof (error as { toJSON?: unknown }).toJSON === "function")
+  );
+};
+
+export class SignalContext<
+  Ctx extends HttpExecutionContext | WebSocketExecutionContext = HttpExecutionContext | WebSocketExecutionContext,
+  Env extends BaseEnv = BaseEnv,
+> {
+  key: string;
+  transport: SignalTransportType;
+  ctx: Ctx;
+  endpointInfo: EndpointInfo;
+  adaptor: Adaptor;
+  args: unknown[] = [];
+  internalArgs: unknown[] = [];
+  #registry: InjectRegistry;
+  #env: Env;
+  #live: LiveRegistry;
+  #middleware: Map<string, MiddlewareCls>;
+  constructor(
+    key: string,
+    reqOrWsReq: Bun.BunRequest | WebSocketRequest,
+    {
+      endpointInfo,
+      adaptor,
+      registry,
+      env,
+      live,
+      middleware,
+    }: {
+      endpointInfo: EndpointInfo;
+      adaptor: Adaptor;
+      registry: InjectRegistry;
+      env: Env;
+      live: LiveRegistry;
+      middleware: Map<string, MiddlewareCls>;
+    },
+  ) {
+    this.key = key;
+    this.transport = endpointInfo.type === "query" || endpointInfo.type === "mutation" ? "http" : "websocket";
+    this.endpointInfo = endpointInfo;
+    if (this.transport === "http") this.ctx = new HttpExecutionContext(reqOrWsReq as Bun.BunRequest) as Ctx;
+    else this.ctx = new WebSocketExecutionContext(reqOrWsReq as WebSocketRequest) as Ctx;
+    this.adaptor = adaptor;
+    this.#registry = registry;
+    this.#env = env;
+    this.#live = live;
+    this.#middleware = middleware;
+  }
+
+  getAdaptor<T extends Adaptor>(adaptorCls: AdaptorCls<T>): T {
+    const instance = this.#registry.adaptor.get(adaptorCls);
+    if (!instance) {
+      throw new Exception.Error(`Adaptor "${adaptorCls.refName}" not found in registry`);
+    }
+    return instance as T;
+  }
+  async init() {
+    this.args = await this.ctx.getArgs(this.endpointInfo);
+    return this;
+  }
+  async #checkGuards() {
+    const guards = this.endpointInfo.signalOption.guards ?? [];
+    for (const GuardCls of guards) {
+      const guard = new GuardCls();
+      const canPass = guard.canPass(this);
+      if (!canPass) throw new Exception.Forbidden(`Access denied by guard: ${GuardCls.name}`);
+    }
+  }
+  async exec() {
+    if (!this.endpointInfo.execFn) throw new Exception.Error("Exec function is not set");
+    const middlewares = [...this.#middleware.values(), ...(this.endpointInfo.signalOption.middlewares ?? [])];
+    const coreExec = async () => {
+      if (!this.endpointInfo.execFn) throw new Exception.Error("Exec function is not set");
+      await this.#checkGuards();
+      this.internalArgs = await Promise.all(
+        this.endpointInfo.internalArgs.map((arg) => {
+          const argValue = new arg.argRef().getArg(this) ?? null;
+          if (argValue === null && !arg.option?.nullable)
+            throw new Exception.Unauthorized(`Internal Argument ${arg.argRef.name} is required`);
+          return argValue;
+        }),
+      );
+      const result = await this.endpointInfo.execFn.call(this.adaptor, ...this.args, ...this.internalArgs);
+      return result;
+    };
+    let next = coreExec;
+    for (let i = middlewares.length - 1; i >= 0; i--) {
+      const MiddlewareCls = middlewares[i];
+      if (!MiddlewareCls) continue;
+      const middleware = new MiddlewareCls();
+      const currentNext = next;
+      next = async () => await (await middleware.use(this.getEnv()))(this, currentNext);
+    }
+    const result = await next();
+    if (this.endpointInfo.type === "pubsub") return;
+    if (result instanceof Response) return result;
+    const resolved = await SignalContext.resolveReturn(result, {
+      signalContext: this,
+      returnRef: this.endpointInfo.returns.returnRef,
+      arrDepth: this.endpointInfo.returns.arrDepth,
+      registry: this.#registry,
+      live: this.#live,
+    });
+    return this.ctx.makeResponse(resolved, this.endpointInfo);
+  }
+  static async try(
+    endpoint: Adaptor,
+    endpointInfo: EndpointInfo,
+    key: string,
+    fn: () => Promise<Response | undefined>,
+  ): Promise<Response | undefined> {
+    try {
+      return await fn();
+    } catch (error) {
+      if (endpointInfo.type === "message" || endpointInfo.type === "pubsub") throw error;
+      if (isExceptionLike(error)) {
+        return new Response(
+          JSON.stringify({
+            ...error.toJSON(),
+            path: endpointInfo.getPath(key),
+            timestamp: new Date().toISOString(),
+          }),
+          { status: error.statusCode, headers: { "Content-Type": "application/json" } },
+        );
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      const stack = error instanceof Error ? error.stack : undefined;
+      endpoint.logger.error(`Error ${endpointInfo.type}-${key}:\n${stack ?? message}`);
+      return new Response(
+        JSON.stringify({
+          error: message,
+          statusCode: 500,
+          path: endpointInfo.getPath(key),
+          timestamp: new Date().toISOString(),
+          stack: error instanceof Error ? error.stack : undefined,
+        }),
+        { status: 500, headers: { "Content-Type": "application/json" } },
+      );
+    }
+  }
+  static async resolveReturn(
+    value: unknown,
+    {
+      signalContext,
+      returnRef,
+      arrDepth,
+      registry,
+      live,
+    }: {
+      signalContext: SignalContext | null;
+      returnRef: ConstantFieldTypeInput;
+      arrDepth: number;
+      registry: InjectRegistry;
+      live: LiveRegistry;
+    },
+  ): Promise<unknown> {
+    if (value === null || value === undefined) return value;
+    if (PrimitiveRegistry.has(returnRef as Cls)) return value;
+    else if (arrDepth)
+      return await Promise.all(
+        (value as unknown[]).map((v) =>
+          SignalContext.resolveReturn(v, { signalContext, returnRef, arrDepth: arrDepth - 1, registry, live }),
+        ),
+      );
+    const valueRecord = value as RuntimeRecord;
+    const resolvedValue = {} as RuntimeRecord;
+    await Promise.all(
+      Object.entries((returnRef as ConstantCls)[FIELD_META]).map(async ([key, field]) => {
+        if (field.fieldType === "hidden") return;
+        else if (field.fieldType === "resolve") {
+          const refName = ConstantRegistry.getRefName(returnRef as ConstantCls);
+          const internal = live.internal.get(`${refName}Internal`);
+          if (!internal) throw new Error(`Internal ${refName} is not registered`);
+          const internalCls = internal.constructor as InternalCls;
+          const internalInfo = internalCls[INTERNAL_META][key] as InternalInfo<"resolveField"> | undefined;
+          if (!internalInfo) throw new Error(`Internal info ${key} is not found`);
+          const resolveFieldContext = new ResolveFieldContext(valueRecord, { signalContext, internalInfo, internal });
+          const resolved = await resolveFieldContext.exec();
+          resolvedValue[key] = await SignalContext.resolveReturn(resolved, {
+            signalContext,
+            returnRef: field.modelRef,
+            arrDepth: field.arrDepth,
+            registry,
+            live,
+          });
+        } else if (!field.isClass) resolvedValue[key] = valueRecord[key];
+        else if (field.isScalar) {
+          resolvedValue[key] = await SignalContext.resolveReturn(valueRecord[key], {
+            signalContext,
+            returnRef: field.modelRef,
+            arrDepth: field.arrDepth,
+            registry,
+            live,
+          });
+        } else {
+          const refName = ConstantRegistry.getRefName(field.modelRef);
+          const service = live.service.get(refName) as unknown as DatabaseService;
+          if (!service) throw new Error(`Service ${refName} is not registered`);
+          const loaded = await SignalContext.loadNested(valueRecord[key], service, field);
+          const resolved = await SignalContext.resolveReturn(loaded, {
+            signalContext,
+            returnRef: field.modelRef,
+            arrDepth: field.arrDepth,
+            registry,
+            live,
+          });
+          resolvedValue[key] = resolved;
+        }
+      }),
+    );
+    return resolvedValue;
+  }
+  static async loadNested(
+    value: unknown,
+    service: DatabaseService,
+    { arrDepth, nullable }: { arrDepth: number; nullable: boolean },
+  ): Promise<unknown> {
+    if (arrDepth === 0)
+      return await service.__load(String(value)).then((doc) => {
+        if (doc === null) {
+          if (nullable) return null;
+          else throw new Error(`Document ${value} is not found`);
+        } else return doc.toJSON();
+      });
+    if (arrDepth === 1)
+      return await service.__loadMany(value as string[]).then((docs) =>
+        docs.map((doc) => {
+          if (doc === null) {
+            if (nullable) return null;
+            else throw new Error(`Document ${value} is not found`);
+          } else return doc.toJSON();
+        }),
+      );
+    return await Promise.all(
+      (value as unknown[]).map(
+        async (v) => await SignalContext.loadNested(v, service, { arrDepth: arrDepth - 1, nullable }),
+      ),
+    );
+  }
+  getHttpContext<Appended = unknown>() {
+    if (this.transport !== "http") throw new Error("Transport is not http");
+    return this.ctx as HttpExecutionContext<Appended>;
+  }
+  getWebSocketContext<Appended = unknown>() {
+    if (this.transport !== "websocket") throw new Error("Transport is not websocket");
+    return this.ctx as WebSocketExecutionContext<Appended>;
+  }
+  getRoomId(key: string) {
+    if (this.transport !== "websocket") throw new Error("Transport is not websocket");
+    else if (this.endpointInfo.type !== "pubsub") throw new Error("Endpoint is not pubsub");
+    return `${key}${this.args.length ? "-" : ""}${this.args.join("-")}`;
+  }
+  getEnv() {
+    return this.#env;
+  }
+}
+
+export class HttpExecutionContext<Appended = unknown> {
+  req: Bun.BunRequest & Appended;
+  res = Response;
+  url: URL;
+  params: RuntimeRecord = {};
+  searchParams: RuntimeRecord = {};
+  body: RuntimeRecord = {};
+  constructor(req: Bun.BunRequest) {
+    this.req = req as Bun.BunRequest & Appended;
+    this.url = new URL(req.url);
+  }
+  async getArgs(endpointInfo: EndpointInfo): Promise<unknown[]> {
+    this.params = this.req.params;
+    
+    const hasUploadArgs = endpointInfo.args.some((arg) => arg.type === "body" && arg.argRef === Upload);
+    if (endpointInfo.type === "mutation" && this.req.body) {
+      if (hasUploadArgs) {
+        const formData = await this.req.formData();
+        this.body = {};
+        for (const [key, value] of formData.entries()) {
+          const argInfo = endpointInfo.args.find((arg) => arg.name === key && arg.type === "body");
+          if (argInfo && argInfo.argRef === Upload) {
+            if (argInfo.arrDepth > 0) {
+              const values = Array.isArray(this.body[key]) ? this.body[key] : [];
+              values.push(value);
+              this.body[key] = values;
+            } else this.body[key] = value;
+          } else {
+            this.body[key] = value as string;
+          }
+        }
+      } else this.body = (await this.req.json()) as RuntimeRecord;
+    }
+
+    const args = endpointInfo.args.map((arg) => {
+      switch (arg.type) {
+        case "param":
+          return deserialize(arg.argRef, arg.arrDepth, this.params[arg.name], {
+            key: arg.name,
+            nullable: arg.option?.nullable,
+          });
+        case "body":
+          if (arg.argRef === Upload) return this.body[arg.name];
+          return deserialize(arg.argRef, arg.arrDepth, this.body[arg.name], {
+            key: arg.name,
+            nullable: arg.option?.nullable,
+          });
+        case "search": {
+          const value = arg.arrDepth ? this.url.searchParams.getAll(arg.name) : this.url.searchParams.get(arg.name);
+          const result = deserialize(arg.argRef, arg.arrDepth, value, {
+            key: arg.name,
+            nullable: arg.option?.nullable,
+          });
+          this.searchParams[arg.name] = result;
+          return result;
+        }
+        default:
+          return undefined;
+      }
+    });
+    return args;
+  }
+  makeResponse(result: unknown, endpointInfo: EndpointInfo) {
+    if (result instanceof Response) return result;
+    const value = serialize(endpointInfo.returns.returnRef, endpointInfo.returns.arrDepth, result, "object", {
+      nullable: endpointInfo.returns.nullable,
+    });
+    return this.res.json(value);
+  }
+}
+
+export type WebSocketEventType = "open" | "subscribe" | "unsubscribe" | "message" | "close";
+export class WebSocketExecutionContext<Appended = unknown> {
+  ws: Bun.ServerWebSocket<Appended>;
+  data: unknown[];
+  roomId: string = "";
+  eventType: WebSocketEventType;
+  onDisconnect: Set<() => PromiseOrObject<void>> = new Set();
+  onUnsubscribe: Set<() => PromiseOrObject<void>> = new Set();
+  constructor(wsReq: WebSocketRequest) {
+    this.ws = wsReq.ws as Bun.ServerWebSocket<Appended>;
+    this.data = wsReq.data;
+    this.eventType = wsReq.eventType;
+  }
+  async getArgs(endpointInfo: EndpointInfo): Promise<unknown[]> {
+    const args = endpointInfo.args.map((arg, idx) => {
+      switch (arg.type) {
+        case "msg":
+          return deserialize(arg.argRef, arg.arrDepth, this.data[idx], {
+            key: arg.name,
+            nullable: arg.option?.nullable,
+          });
+        case "room":
+          return deserialize(arg.argRef, arg.arrDepth, this.data[idx], {
+            key: arg.name,
+            nullable: arg.option?.nullable,
+          });
+        default:
+          return undefined;
+      }
+    });
+    return args;
+  }
+  makeResponse(result: unknown, endpointInfo: EndpointInfo) {
+    return serialize(endpointInfo.returns.returnRef, endpointInfo.returns.arrDepth, result, "object", {
+      nullable: endpointInfo.returns.nullable,
+    }) as unknown as Response; 
+  }
+  on(event: "disconnect" | "unsubscribe", handler: () => void) {
+    if (event === "disconnect") this.onDisconnect.add(handler);
+    else this.onUnsubscribe.add(handler);
+  }
+  off(event: "disconnect" | "unsubscribe", handler: () => void) {
+    if (event === "disconnect") this.onDisconnect.delete(handler);
+    else this.onUnsubscribe.delete(handler);
+  }
+}
+
+export class ResolveFieldContext {
+  signalContext: SignalContext | null;
+  internalInfo: InternalInfo<"resolveField">;
+  internal: Internal;
+  parent: unknown;
+  constructor(
+    parent: unknown,
+    {
+      signalContext,
+      internalInfo,
+      internal,
+    }: { signalContext: SignalContext | null; internalInfo: InternalInfo<"resolveField">; internal: Internal },
+  ) {
+    this.signalContext = signalContext;
+    this.internalInfo = internalInfo;
+    this.internal = internal;
+    this.parent = parent;
+  }
+  async exec() {
+    if (!this.internalInfo.execFn) throw new Error("Exec function is not set");
+    const internalArgs = await Promise.all(
+      this.internalInfo.internalArgs.map((arg) =>
+        this.signalContext ? (new arg.argRef().getArg(this.signalContext) ?? null) : null,
+      ),
+    );
+    const result = await this.internalInfo.execFn.call(this.internal, this.parent, ...internalArgs);
+    return result;
+  }
+}

package/signal/signalRegistry.ts

@@ -0,0 +1,82 @@
+import type { EndpointCls } from "./endpoint";
+import type { InternalCls } from "./internal";
+import { FetchSerializer } from "./serializer";
+import type { ServerSignalCls } from "./serverSignal";
+import type { SliceCls } from "./slice";
+import type { SerializedSignal } from "./types";
+
+export class DatabaseSignal<
+  IntlCls extends InternalCls = InternalCls,
+  EndpCls extends EndpointCls = EndpointCls,
+  SlceCls extends SliceCls = SliceCls,
+  SrvrCls extends ServerSignalCls = ServerSignalCls,
+> {
+  internal: IntlCls;
+  endpoint: EndpCls;
+  slice: SlceCls;
+  server: SrvrCls;
+  serializedSignal: SerializedSignal;
+
+  constructor(internal: IntlCls, endpoint: EndpCls, slice: SlceCls, server: SrvrCls) {
+    this.internal = internal;
+    this.endpoint = endpoint;
+    this.slice = slice;
+    this.server = server;
+    this.serializedSignal = FetchSerializer.serializeDatabaseSignal(slice, endpoint);
+  }
+}
+
+export class ServiceSignal<
+  IntlCls extends InternalCls = InternalCls,
+  EndpCls extends EndpointCls = EndpointCls,
+  SrvrCls extends ServerSignalCls = ServerSignalCls,
+> {
+  internal: IntlCls;
+  endpoint: EndpCls;
+  server: SrvrCls;
+  serializedSignal: SerializedSignal;
+
+  constructor(internal: IntlCls, endpoint: EndpCls, server: SrvrCls) {
+    this.internal = internal;
+    this.endpoint = endpoint;
+    this.server = server;
+    this.serializedSignal = FetchSerializer.serializeServiceSignal(endpoint);
+  }
+}
+
+/** Registry for database and service signals used by routing and fetch serialization. */
+export class SignalRegistry {
+  static readonly #database = new Map<string, DatabaseSignal<any, any, any, any>>();
+  static readonly #service = new Map<string, ServiceSignal<any, any, any>>();
+
+  static registerDatabase<
+    IntlCls extends InternalCls,
+    EndpCls extends EndpointCls,
+    SlceCls extends SliceCls,
+    SrvrCls extends ServerSignalCls,
+  >(
+    internal: IntlCls,
+    endpoint: EndpCls,
+    slice: SlceCls,
+    server: SrvrCls,
+  ): DatabaseSignal<IntlCls, EndpCls, SlceCls, SrvrCls> {
+    const databaseSignal = new DatabaseSignal(internal, endpoint, slice, server);
+    SignalRegistry.#database.set(internal.refName, databaseSignal);
+    return databaseSignal;
+  }
+  static getDatabase(refName: string) {
+    return SignalRegistry.#database.get(refName);
+  }
+  static registerService<IntlCls extends InternalCls, EndpCls extends EndpointCls, SrvrCls extends ServerSignalCls>(
+    internal: IntlCls,
+    endpoint: EndpCls,
+    server: SrvrCls,
+  ): ServiceSignal<IntlCls, EndpCls, SrvrCls> {
+    const serviceSignal = new ServiceSignal(internal, endpoint, server);
+    SignalRegistry.#service.set(internal.refName, serviceSignal);
+    return serviceSignal;
+  }
+  static getService(refName: string) {
+    return SignalRegistry.#service.get(refName);
+  }
+}

package/signal/slice.ts

@@ -0,0 +1,158 @@
+import { Any, type Assign, type Cls, type MergeAllKeyOfObjects, SLICE_META } from "akanjs/base";
+import { applyMixins } from "akanjs/common";
+import type { DocumentModel, QueryOf } from "akanjs/constant";
+import type { FilterInstance } from "akanjs/document";
+import { type Adaptor, type AdaptorCls, dangerouslyAdapt, type ServiceModel } from "akanjs/service";
+import type { Guard, GuardCls } from "./guard";
+import { buildSlice, type SliceBuilder, type SliceInfo } from "./sliceInfo";
+
+export interface Slice extends Adaptor {}
+
+export type SliceCls<
+  SrvModule extends ServiceModel = ServiceModel,
+  SliceInfoObj extends { [key: string]: SliceInfo } = { [key: string]: SliceInfo },
+> = AdaptorCls & {
+  baseName: SrvModule["srv"]["refName"];
+  srv: SrvModule;
+  [SLICE_META]: SliceInfoObj;
+  getGuards: GuardCls[];
+  cruGuards: GuardCls[];
+};
+
+interface RootSliceOption {
+  guards?: {
+    root?: Cls<Guard> | Cls<Guard>[];
+    get?: Cls<Guard> | Cls<Guard>[];
+    cru?: Cls<Guard> | Cls<Guard>[];
+  };
+  prefix?: string;
+}
+
+type ExtendSliceInfoObj<
+  SrvModule extends ServiceModel,
+  LibSlices extends SliceCls[],
+  _Input = NonNullable<SrvModule["cnst"]>["_Input"],
+  _Full = NonNullable<SrvModule["cnst"]>["_Full"],
+  _Light = NonNullable<SrvModule["cnst"]>["_Light"],
+  _Insight = NonNullable<SrvModule["cnst"]>["_Insight"],
+  _Filter extends FilterInstance = any,
+  _Merged = MergeAllKeyOfObjects<LibSlices, typeof SLICE_META>,
+> = {
+  [K in keyof _Merged]: _Merged[K] extends SliceInfo<
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    infer Srvs,
+    infer ArgNames,
+    infer Args,
+    infer InternalArgs,
+    infer ServerArgs
+  >
+    ? SliceInfo<
+        SrvModule["srv"]["refName"],
+        _Input,
+        _Full,
+        _Light,
+        _Insight,
+        _Filter,
+        Srvs,
+        ArgNames,
+        Args,
+        InternalArgs,
+        ServerArgs
+      >
+    : never;
+};
+
+/** Builds database-backed slice APIs for list, insight, init, view, edit, create, update, and remove flows. */
+export function slice<
+  SrvModule extends ServiceModel,
+  BuildSlice extends SliceBuilder<SrvModule>,
+  LibSlices extends SliceCls[],
+  _Input = NonNullable<SrvModule["cnst"]>["_Input"],
+  _Full = NonNullable<SrvModule["cnst"]>["_Full"],
+  _Light = NonNullable<SrvModule["cnst"]>["_Light"],
+  _Insight = NonNullable<SrvModule["cnst"]>["_Insight"],
+  _Filter extends FilterInstance = NonNullable<SrvModule["db"]>["_Filter"],
+  _Query = QueryOf<DocumentModel<_Full>>,
+>(
+  srv: SrvModule,
+  option: RootSliceOption,
+  sliceBuilder: BuildSlice,
+  ...libSlices: LibSlices
+): SliceCls<
+  SrvModule,
+  Assign<
+    ReturnType<BuildSlice>,
+    LibSlices extends []
+      ? {
+          [""]: SliceInfo<
+            SrvModule["srv"]["refName"],
+            _Input,
+            _Full,
+            _Light,
+            _Insight,
+            _Filter,
+            SrvModule["srvMap"],
+            ["query"],
+            [_Query],
+            [],
+            [_Query]
+          >;
+        }
+      : ExtendSliceInfoObj<SrvModule, LibSlices>
+  >
+> {
+  if (!srv.cnst || !srv.db) throw new Error("cnst and db are required");
+  const init = buildSlice(
+    srv.srv.refName,
+    srv.cnst.input,
+    srv.cnst.full,
+    srv.cnst.light,
+    srv.cnst.insight,
+    srv.db.filter,
+  );
+  const rootGuards = option.guards?.root
+    ? Array.isArray(option.guards.root)
+      ? option.guards.root
+      : [option.guards.root]
+    : [];
+  const getGuards = option.guards?.get
+    ? Array.isArray(option.guards.get)
+      ? option.guards.get
+      : [option.guards.get]
+    : [];
+  const cruGuards = option.guards?.cru
+    ? Array.isArray(option.guards.cru)
+      ? option.guards.cru
+      : [option.guards.cru]
+    : [];
+  const srvKeys = [
+    ...new Set([...Object.keys(srv.srvMap), ...libSlices.flatMap((libSlice) => Object.keys(libSlice.srv.srvMap))]),
+  ];
+  const sliceCls = class Slice extends dangerouslyAdapt(`${srv.srv.refName}Slice`, ({ service }) => ({
+    ...Object.fromEntries(srvKeys.map((srvRefName) => [srvRefName, service()])),
+  })) {
+    static baseName = srv.srv.refName;
+    static srv = srv;
+    static getGuards = getGuards;
+    static cruGuards = cruGuards;
+    static [SLICE_META] = Object.assign(
+      {
+        [""]: init({ guards: rootGuards })
+          .search<"query", object>("query", Any)
+          .exec((query) => query ?? {}),
+      },
+      sliceBuilder(init),
+    );
+  };
+  libSlices.forEach((libSlice) => {
+    Object.assign(sliceCls[SLICE_META], libSlice[SLICE_META]);
+    Object.assign(sliceCls.srv.srvMap, libSlice.srv.srvMap);
+  });
+  applyMixins(sliceCls, libSlices);
+  return sliceCls as any;
+}