akanjs 0.0.1 → 2.0.0-beta.0

package/signal/internalInfo.ts

@@ -0,0 +1,208 @@
+import { Any, type Cls, type FIELD_META, type PromiseOrObject } from "akanjs/base";
+import type {
+  ConstantCls,
+  ConstantField,
+  ConstantFieldTypeInput,
+  DocumentModel,
+  FieldObject,
+  FieldToValue,
+  PlainTypeToFieldType,
+} from "akanjs/constant";
+import type { AkanJob, ServiceModel } from "akanjs/service";
+import { type ArgInfo, EndpointInfo, type InternalArgInfo, type ReturnInfo } from "./endpointInfo";
+import type { InternalArgCls } from "./internalArg";
+import type { SignalOption } from "./types";
+
+type InternalType = "resolveField" | "interval" | "cron" | "timeout" | "init" | "destroy" | "process";
+
+interface InternalArgProps<Nullable extends boolean = false> {
+  nullable?: Nullable;
+}
+
+export class InternalInfo<
+  ReqType extends InternalType = InternalType,
+  Srvs extends { [key: string]: any } = { [key: string]: any },
+  Args extends any[] = any,
+  InternalArgs extends any[] = any,
+  DefaultArgs extends any[] = any,
+  Returns extends ConstantFieldTypeInput = ConstantFieldTypeInput,
+  ServerReturns = any,
+  Nullable extends boolean = boolean,
+> {
+  readonly type: ReqType;
+  readonly args: ArgInfo<InternalArgProps<boolean>>[] = [];
+  readonly internalArgs: InternalArgInfo<boolean>[] = [];
+  readonly defaultArgs: string[] = [];
+  readonly returns: ReturnInfo<Returns, Nullable>;
+  readonly signalOption: SignalOption<Returns, Nullable>;
+
+  execFn: ((...args: [...Args, ...DefaultArgs, ...InternalArgs]) => ServerReturns) | null = null;
+
+  constructor(type: ReqType, returnRef: Returns, signalOption: SignalOption<Returns, Nullable> = {}) {
+    this.type = type;
+    this.returns = EndpointInfo.getReturnInfo(returnRef, signalOption);
+    this.signalOption = signalOption;
+    if (type === "resolveField") this.defaultArgs.push("Parent");
+    else if (type === "process") this.defaultArgs.push("Job");
+  }
+  msg<
+    ExplicitType,
+    Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+    Nullable extends boolean = false,
+    _FieldToValue = FieldToValue<Arg>,
+  >(name: string, arg: Arg, option?: InternalArgProps<Nullable>) {
+    if (this.execFn) throw new Error("Query function is already set");
+    else if (this.args.at(-1)?.option?.nullable) throw new Error("Last argument is nullable");
+    this.args.push(EndpointInfo.getArgInfo("msg", name, arg, option));
+    return this as unknown as InternalInfo<
+      ReqType,
+      Srvs,
+      [...Args, arg: _FieldToValue | (Nullable extends true ? undefined : never)],
+      InternalArgs,
+      DefaultArgs,
+      Returns,
+      ServerReturns,
+      Nullable
+    >;
+  }
+  with<ArgType, Optional extends boolean = false>(
+    argRef: InternalArgCls<ArgType>,
+    option?: InternalArgProps<Optional>,
+  ) {
+    if (this.execFn) throw new Error("Query function is already set");
+    this.internalArgs.push({
+      argRef,
+      option: { ...option, ...(this.type === "resolveField" ? { nullable: true } : {}) }, //? for resolveField, nullable is true by default
+    });
+    return this as unknown as InternalInfo<
+      ReqType,
+      Srvs,
+      Args,
+      [
+        ...InternalArgs,
+        arg: NonNullable<ArgType> | (Optional extends true ? null : ReqType extends "resolveField" ? null : never),
+      ],
+      DefaultArgs,
+      Returns,
+      ServerReturns,
+      Nullable
+    >;
+  }
+  exec<
+    ExecReturn extends ReqType extends "process" | "resolveField"
+      ? PromiseOrObject<DocumentModel<FieldToValue<Returns>> | (Nullable extends true ? null : never)>
+      : PromiseOrObject<void>,
+  >(execFn: (this: Srvs, ...args: [...Args, ...DefaultArgs, ...InternalArgs]) => ExecReturn) {
+    if (this.execFn) throw new Error("Query function is already set");
+    this.execFn = execFn as unknown as (...args: [...Args, ...DefaultArgs, ...InternalArgs]) => ServerReturns;
+    return this as unknown as InternalInfo<
+      ReqType,
+      Srvs,
+      Args,
+      InternalArgs,
+      DefaultArgs,
+      Returns,
+      ExecReturn,
+      Nullable
+    >;
+  }
+}
+
+export type BuildInternal<SrvModule extends ServiceModel, ParentDoc = SrvModule["db"]["_Doc"]> = {
+  resolveField: <Returns extends ConstantFieldTypeInput, Nullable extends boolean = false>(
+    returnRef: Returns,
+    signalOption?: Pick<SignalOption<Returns, Nullable>, "nullable">,
+  ) => InternalInfo<"resolveField", SrvModule["srvMap"], [], [], [ParentDoc], Returns, never, Nullable>;
+  interval: <Nullable extends boolean = false>(
+    scheduleTime: number,
+    signalOption?: SignalOption<typeof Any, Nullable>,
+  ) => InternalInfo<"interval", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  cron: <Nullable extends boolean = false>(
+    scheduleCron: string,
+    signalOption?: SignalOption<typeof Any, Nullable>,
+  ) => InternalInfo<"cron", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  timeout: <Nullable extends boolean = false>(
+    timeout: number,
+    signalOption?: SignalOption<typeof Any, Nullable>,
+  ) => InternalInfo<"timeout", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  initialize: <Nullable extends boolean = false>(
+    signalOption?: SignalOption<typeof Any, Nullable>,
+  ) => InternalInfo<"init", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  destroy: <Nullable extends boolean = false>(
+    signalOption?: SignalOption<typeof Any, Nullable>,
+  ) => InternalInfo<"destroy", SrvModule["srvMap"], [], [], [], typeof Any, never, Nullable>;
+  process: <Returns extends ConstantFieldTypeInput, Nullable extends boolean = false>(
+    returnRef: Returns,
+    signalOption?: SignalOption<Returns, Nullable>,
+  ) => InternalInfo<"process", SrvModule["srvMap"], [], [], [AkanJob], Returns, never, Nullable>;
+};
+
+export type InternalBuilder<
+  SrvModule extends ServiceModel,
+  _FullCls extends ConstantCls = SrvModule["cnst"]["full"],
+  _FieldObj extends FieldObject = _FullCls[typeof FIELD_META],
+  _ResolveFieldObj extends FieldObject = {
+    [K in keyof _FieldObj as _FieldObj[K] extends ConstantField<"resolve", any, any, any, any, any>
+      ? K
+      : never]: _FieldObj[K];
+  },
+> = (builder: BuildInternal<SrvModule>) => SrvModule["cnst"] extends never
+  ? { [key: string]: InternalInfo<Exclude<InternalType, "resolveField">> }
+  : {
+      [K in keyof _ResolveFieldObj]: _ResolveFieldObj[K] extends ConstantField<
+        "resolve",
+        infer Value,
+        any,
+        any,
+        infer Nullable
+      >
+        ? InternalInfo<"resolveField", any, any, any, any, NonNullable<Value>, Nullable>
+        : InternalInfo<Exclude<InternalType, "resolveField">>;
+    };
+
+export const buildInternal = {
+  resolveField: (returnRef: Cls, signalOption?: SignalOption) =>
+    new InternalInfo("resolveField", returnRef, signalOption),
+  interval: (scheduleTime: number, signalOption?: SignalOption) =>
+    new InternalInfo("interval", Any, {
+      enabled: true,
+      lock: true,
+      scheduleType: "interval",
+      scheduleTime,
+      ...signalOption,
+    }),
+  cron: (scheduleCron: string, signalOption?: SignalOption) =>
+    new InternalInfo("cron", Any, {
+      enabled: true,
+      lock: true,
+      scheduleType: "cron",
+      scheduleCron,
+      ...signalOption,
+    }),
+  timeout: (timeout: number, signalOption?: SignalOption) =>
+    new InternalInfo("timeout", Any, {
+      enabled: true,
+      lock: true,
+      scheduleType: "timeout",
+      scheduleTime: timeout,
+      ...signalOption,
+    }),
+  initialize: (signalOption?: SignalOption) =>
+    new InternalInfo("init", Any, {
+      enabled: true,
+      scheduleType: "init",
+      ...signalOption,
+    }),
+  destroy: (signalOption?: SignalOption) =>
+    new InternalInfo("destroy", Any, {
+      enabled: true,
+      lock: true,
+      scheduleType: "destroy",
+      ...signalOption,
+    }),
+  process: (returnRef: Cls, signalOption?: SignalOption) =>
+    new InternalInfo("process", returnRef, {
+      serverMode: "all",
+      ...signalOption,
+    }),
+} as BuildInternal<any, any>;

package/signal/middleware.ts

@@ -0,0 +1,108 @@
+import type { BaseEnv, Cls, PromiseOrObject } from "akanjs/base";
+import { type CacheAdaptor, CacheAdaptorRole } from "akanjs/service";
+import dayjs from "dayjs";
+import type { SignalContext } from "./signalContext";
+
+export interface Middleware<Env extends BaseEnv = BaseEnv> {
+  use(env: Env): PromiseOrObject<(context: SignalContext, next: () => Promise<unknown>) => PromiseOrObject<unknown>>;
+}
+
+export type MiddlewareCls = Cls<Middleware, { readonly refName: string }>;
+
+export const middleware = (refName: string) => {
+  return class Middleware {
+    static refName = refName;
+    async use(env: BaseEnv) {
+      return async (context: SignalContext, next: () => Promise<unknown>) => {
+        return await next();
+      };
+    }
+  };
+};
+
+export class Logging extends middleware("logging") {
+  override async use() {
+    return async (context: SignalContext, next: () => Promise<unknown>) => {
+      const start = Date.now();
+      context.adaptor.logger.debug(`Before ${context.endpointInfo.type}-${context.key} / ${start}`);
+      try {
+        const result = await next();
+        const duration = Date.now() - start;
+        context.adaptor.logger.debug(`After ${context.endpointInfo.type}-${context.key} / ${duration}ms`);
+        return result;
+      } catch (error) {
+        const duration = Date.now() - start;
+        context.adaptor.logger.error(
+          `Error ${context.endpointInfo.type}-${context.key} / ${duration}ms: ${String(error)}`,
+        );
+        throw error;
+      }
+    };
+  }
+}
+
+export class Cache extends middleware("cache") {
+  override async use() {
+    return async (context: SignalContext, next: () => Promise<unknown>) => {
+      const cache = context.getAdaptor(CacheAdaptorRole) as unknown as CacheAdaptor;
+      const topic = "cache";
+      const key = `${context.key}:${JSON.stringify(context.args)}`;
+
+      const cached = await cache.get<string>(topic, key);
+      if (cached) {
+        context.adaptor.logger.debug(`Cache hit ${context.key}`);
+        try {
+          return JSON.parse(cached);
+        } catch (parseError) {
+          context.adaptor.logger.warn(`Cache parse error ${context.key}: ${String(parseError)}`);
+          await cache.delete(topic, key);
+        }
+      }
+
+      const result = await next();
+
+      context.adaptor.logger.debug(`Caching result type ${context.key}: ${typeof result} / ${Array.isArray(result)}`);
+
+      const serialized = JSON.stringify(result);
+      await cache.set(topic, key, serialized, { expireAt: dayjs().add(60, "second") });
+
+      return result;
+    };
+  }
+}
+
+export class Timeout extends middleware("timeout") {
+  override async use() {
+    return async (context: SignalContext, next: () => Promise<unknown>) => {
+      const timeout = context.endpointInfo.signalOption.timeout ?? 5000;
+      return Promise.race([
+        next(),
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Request timeout after ${timeout}ms`)), timeout)),
+      ]);
+    };
+  }
+}
+
+export class Retry extends middleware("retry") {
+  override async use() {
+    return async (context: SignalContext, next: () => Promise<unknown>) => {
+      const maxRetries = 3;
+      let lastError: Error | null = null;
+
+      for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+          return await next();
+        } catch (error) {
+          lastError = error instanceof Error ? error : new Error(String(error));
+          console.warn(`[${context.key}] Retry ${attempt + 1}/${maxRetries}:`, lastError.message);
+
+          if (attempt < maxRetries - 1) {
+            
+            await new Promise((resolve) => setTimeout(resolve, 2 ** attempt * 100));
+          }
+        }
+      }
+      throw lastError;
+    };
+  }
+}

package/signal/serializer/fetch.serializer.ts

@@ -0,0 +1,128 @@
+import { type Cls, ENDPOINT_META, PrimitiveRegistry, type PrimitiveScalar, SLICE_META } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import { ConstantRegistry, type ConstantType } from "akanjs/constant";
+import type { LiveRegistry } from "akanjs/service";
+import type {
+  ArgInfo,
+  EndpointArgProps,
+  EndpointCls,
+  EndpointInfo,
+  SerializedArg,
+  SerializedEndpoint,
+  SerializedReturns,
+  SerializedSignal,
+  SerializedSlice,
+  SliceCls,
+  SliceInfo,
+} from "akanjs/signal";
+
+export class FetchSerializer {
+  static logger = new Logger("FetchSerializer");
+
+  static #resolveRefInfo(modelRef: Cls): { refName: string; modelType?: ConstantType } {
+    if (PrimitiveRegistry.has(modelRef))
+      return { refName: PrimitiveRegistry.getName(modelRef as typeof PrimitiveScalar) };
+    const refName = ConstantRegistry.getRefName(modelRef);
+    const modelType = (modelRef as Cls<unknown, { modelType?: ConstantType }>).modelType;
+    return { refName, modelType };
+  }
+
+  static #serializeArg(argInfo: ArgInfo<EndpointArgProps<boolean>>): SerializedArg {
+    const { refName, modelType } = FetchSerializer.#resolveRefInfo(argInfo.argRef as Cls);
+    return {
+      type: argInfo.type,
+      refName,
+      name: argInfo.name,
+      ...(modelType ? { modelType: modelType as SerializedArg["modelType"] } : {}),
+      ...(argInfo.arrDepth ? { arrDepth: argInfo.arrDepth } : {}),
+      ...(argInfo.option?.nullable ? { nullable: true } : {}),
+      ...(argInfo.option?.example != null
+        ? {
+            example:
+              typeof argInfo.option.example === "object" ? argInfo.option.example.toDate() : argInfo.option.example,
+          }
+        : {}),
+      ...(argInfo.enum ? { enum: argInfo.enum.refName } : {}),
+    };
+  }
+
+  static #serializeReturns(endpointInfo: EndpointInfo): SerializedReturns {
+    const { refName, modelType } = FetchSerializer.#resolveRefInfo(endpointInfo.returns.returnRef as Cls);
+    return {
+      refName,
+      ...(modelType ? { modelType: modelType as SerializedReturns["modelType"] } : {}),
+      ...(endpointInfo.returns.arrDepth ? { arrDepth: endpointInfo.returns.arrDepth } : {}),
+      ...(endpointInfo.signalOption.partial?.length ? { partial: endpointInfo.signalOption.partial as string[] } : {}),
+      ...(endpointInfo.signalOption.nullable ? { nullable: true } : {}),
+    };
+  }
+
+  static #serializeEndpoint(endpointInfo: EndpointInfo): SerializedEndpoint {
+    const guards = endpointInfo.signalOption.guards?.map((g) => g.name);
+    return {
+      type: endpointInfo.type,
+      args: endpointInfo.args.map(FetchSerializer.#serializeArg),
+      returns: FetchSerializer.#serializeReturns(endpointInfo),
+      ...(endpointInfo.signalOption.path ? { path: endpointInfo.signalOption.path } : {}),
+      ...(guards?.length ? { guards } : {}),
+    };
+  }
+
+  static #serializeSlice(sliceInfo: SliceInfo): SerializedSlice {
+    const guards = sliceInfo.signalOption.guards?.map((g) => g.name);
+    return {
+      args: sliceInfo.args.map(FetchSerializer.#serializeArg),
+      ...(sliceInfo.signalOption.path ? { path: sliceInfo.signalOption.path } : {}),
+      ...(guards?.length ? { guards } : {}),
+    };
+  }
+
+  static serializeDatabaseSignal(sliceCls: SliceCls, endpointCls: EndpointCls): SerializedSignal {
+    const sliceMeta = sliceCls[SLICE_META] as { [key: string]: SliceInfo };
+    const endpointMeta = endpointCls[ENDPOINT_META] as { [key: string]: EndpointInfo };
+    const prefix = sliceCls.srv.cnst?.refName;
+    const slice: { [key: string]: SerializedSlice } = {};
+    for (const [key, sliceInfo] of Object.entries(sliceMeta)) {
+      slice[key] = FetchSerializer.#serializeSlice(sliceInfo);
+    }
+    const endpoint: { [key: string]: SerializedEndpoint } = {};
+    for (const [key, endpointInfo] of Object.entries(endpointMeta)) {
+      endpoint[key] = FetchSerializer.#serializeEndpoint(endpointInfo);
+    }
+    return {
+      ...(prefix ? { prefix } : {}),
+      ...(Object.keys(slice).length ? { slice } : {}),
+      ...(sliceCls.getGuards.filter((g) => g.name !== "None").length
+        ? { getGuards: sliceCls.getGuards.map((g) => g.name) }
+        : {}),
+      ...(sliceCls.cruGuards.filter((g) => g.name !== "None").length
+        ? { cruGuards: sliceCls.cruGuards.map((g) => g.name) }
+        : {}),
+      endpoint,
+    };
+  }
+
+  static serializeServiceSignal(endpointCls: EndpointCls): SerializedSignal {
+    const endpointMeta = endpointCls[ENDPOINT_META] as { [key: string]: EndpointInfo };
+    const endpoint: { [key: string]: SerializedEndpoint } = {};
+    for (const [key, endpointInfo] of Object.entries(endpointMeta)) {
+      endpoint[key] = FetchSerializer.#serializeEndpoint(endpointInfo);
+    }
+    return { endpoint };
+  }
+
+  static serializeRegistry({ endpointCls, sliceCls }: LiveRegistry): { signal: { [key: string]: SerializedSignal } } {
+    const serializedSignals: { [key: string]: SerializedSignal } = {};
+    for (const [baseName, endpoint] of endpointCls.entries()) {
+      const cnst = endpoint.srv.cnst;
+      if (cnst) {
+        const slice = sliceCls.get(baseName);
+        if (!slice) throw new Error(`No slice found for service signal "${baseName}"`);
+        serializedSignals[baseName] = FetchSerializer.serializeDatabaseSignal(slice, endpoint);
+      } else {
+        serializedSignals[baseName] = FetchSerializer.serializeServiceSignal(endpoint);
+      }
+    }
+    return { signal: serializedSignals };
+  }
+}

package/signal/serializer/index.ts

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

package/signal/serverSignal.ts

@@ -0,0 +1,114 @@
+import { ENDPOINT_META, INJECT_META, INTERNAL_META } from "akanjs/base";
+import type { DocumentModel } from "akanjs/constant";
+import {
+  type Adaptor,
+  type AdaptorCls,
+  type AkanJob,
+  type AkanJobOptions,
+  adapt,
+  type QueueAdaptor,
+  QueueAdaptorRole,
+} from "akanjs/service";
+import type { ServerWebSocket } from "bun";
+import type { EndpointCls } from "./endpoint";
+import type { EndpointInfo } from "./endpointInfo";
+import type { InternalCls } from "./internal";
+import type { InternalInfo } from "./internalInfo";
+
+export interface ServerSignal extends Adaptor {
+  readonly websocket: ServerWebSocket;
+  readonly queue: QueueAdaptor;
+}
+
+type EndpointServerSignalMethods<EnpCls> = EnpCls extends { [ENDPOINT_META]: infer EndpointInfoObj }
+  ? {
+      [K in keyof EndpointInfoObj as EndpointInfoObj[K] extends EndpointInfo<
+        "pubsub",
+        any,
+        any,
+        any,
+        any,
+        any,
+        any,
+        any,
+        any
+      >
+        ? K
+        : never]: EndpointInfoObj[K] extends EndpointInfo<
+        any,
+        any,
+        any,
+        any,
+        any,
+        infer ServerArgs,
+        any,
+        infer ClientReturns,
+        any,
+        any
+      >
+        ? (...args: [...ServerArgs, data: DocumentModel<ClientReturns>]) => void
+        : never;
+    }
+  : never;
+
+type InternalServerSignalMethods<IntCls> = IntCls extends { [INTERNAL_META]: infer InternalInfoObj }
+  ? {
+      [K in keyof InternalInfoObj as InternalInfoObj[K] extends InternalInfo<
+        "process",
+        any,
+        any,
+        any,
+        any,
+        any,
+        any,
+        any
+      >
+        ? K
+        : never]: InternalInfoObj[K] extends InternalInfo<
+        any,
+        any,
+        infer ServerArgs,
+        any,
+        any,
+        any,
+        infer ServerReturns
+      >
+        ? (...args: [...args: ServerArgs, jobOptions?: AkanJobOptions]) => Promise<AkanJob<any, ServerReturns>>
+        : never;
+    }
+  : never;
+
+type ServerSignalClsStatics = {
+  readonly refName: string;
+  readonly [INJECT_META]: { queue: QueueAdaptor };
+  readonly [ENDPOINT_META]: { [key: string]: EndpointInfo };
+  readonly [INTERNAL_META]: { [key: string]: InternalInfo };
+};
+
+export type ServerSignalCls<EnpCls = any, IntCls = any> = AdaptorCls<
+  EndpointServerSignalMethods<EnpCls> & InternalServerSignalMethods<IntCls> & ServerSignal
+> &
+  ServerSignalClsStatics;
+
+/** Composes endpoint and internal classes into a server-side signal class. */
+export const serverSignal = <EnpCls, IntCls>(
+  endpointRef: EnpCls,
+  internalRef: IntCls,
+): ServerSignalCls<EnpCls, IntCls> => {
+  const refName = (endpointRef as unknown as EndpointCls).refName.slice(0, -8);
+  return class ServerSignal extends adapt(`${refName}Signal`, ({ plug }) => ({
+    
+    queue: plug(QueueAdaptorRole),
+  })) {
+    static readonly [ENDPOINT_META] = Object.fromEntries(
+      Object.entries((endpointRef as unknown as EndpointCls)[ENDPOINT_META])
+        .filter(([key, endpointInfo]) => endpointInfo.type === "pubsub")
+        .map(([key, value]) => [key, value]),
+    );
+    static readonly [INTERNAL_META] = Object.fromEntries(
+      Object.entries((internalRef as unknown as InternalCls)[INTERNAL_META])
+        .filter(([key, internalInfo]) => internalInfo.type === "process")
+        .map(([key, value]) => [key, value]),
+    );
+  } as unknown as ServerSignalCls<EnpCls, IntCls>;
+};