akanjs 2.2.4 → 2.2.6

package/types/server/webRouter.d.ts

@@ -0,0 +1,44 @@
+import { type AkanI18nConfig } from "akanjs/common";
+import type { AkanMetricsReport } from "akanjs/service";
+import { type BuilderRpc, type RouteSeedIndex } from "./artifact.d.ts";
+import type { HmrWsData, HmrWsHub } from "./hmr/wsHub.d.ts";
+import { RscWorker } from "./rscWorkerHost.d.ts";
+import type { BaseBuildArtifact, HttpRoutes, RenderState } from "./types.d.ts";
+export declare function normalizeRscTargetUrlForHostBasePath(targetUrl: URL, options: {
+    basePath: string | null;
+    basePaths?: readonly string[];
+    i18n: AkanI18nConfig;
+    seedEntries?: RouteSeedIndex["entries"];
+}): {
+    url: URL;
+    basePath: string | null;
+};
+export interface SsrRoutesResult {
+    renderEnvRoutes: HttpRoutes;
+    hmrHub: HmrWsHub | null;
+    builderRpc: BuilderRpc | null;
+}
+export interface SsrRoutesInputs {
+    upgradeHmrWs: (req: Request, data: HmrWsData) => boolean;
+}
+interface WebRouterOptions {
+    artifact: BaseBuildArtifact;
+    cssBytesByUrl: Record<string, Uint8Array>;
+    rsc: RscWorker;
+    seedIndex: RouteSeedIndex;
+    upgradeHmrWs: (req: Request, data: HmrWsData) => boolean;
+}
+export declare class WebRouter {
+    #private;
+    renderState: RenderState;
+    constructor({ artifact, cssBytesByUrl, rsc, seedIndex, upgradeHmrWs }: WebRouterOptions);
+    initializeRoute(): Promise<{
+        renderEnvRoutes: Bun.Serve.Routes<unknown, string> | Bun.Serve.RoutesWithUpgrade<unknown, string>;
+        hmrHub: HmrWsHub | null;
+        builderRpc: BuilderRpc | null;
+    }>;
+    dispose(): void;
+    getMetrics(): AkanMetricsReport;
+    static create({ upgradeHmrWs }: SsrRoutesInputs): Promise<WebRouter>;
+}
+export {};

package/types/server.d.ts

@@ -0,0 +1 @@
+export * from "./server/index.d.ts";

package/types/service/adapt.d.ts

@@ -0,0 +1,15 @@
+import { type Cls, INJECT_META } from "akanjs/base";
+import { Logger } from "akanjs/common";
+import { type ExtractInjectInfoObject, type InjectBuilder, type InjectInfo } from "./injectInfo.d.ts";
+export interface Adaptor {
+    readonly logger: Logger;
+    onInit(): Promise<void>;
+    onDestroy(): Promise<void>;
+}
+export type AdaptorCls<Methods = any, InjectMap extends Record<string, InjectInfo> = {}> = Cls<Methods & ExtractInjectInfoObject<InjectMap> & Adaptor, {
+    readonly [INJECT_META]: InjectMap;
+    readonly refName: string;
+}>;
+export declare function adapt<Name extends string>(name: Name): AdaptorCls;
+export declare function adapt<Name extends string, Injection extends InjectBuilder<"use" | "env" | "memory" | "plug">>(name: Name, injectBuilder: Injection): AdaptorCls<{}, ReturnType<Injection>>;
+export declare function dangerouslyAdapt<Name extends string, Injection extends InjectBuilder>(name: Name, injectBuilder: Injection): AdaptorCls<{}, ReturnType<Injection>>;

package/types/service/base.service.d.ts

@@ -0,0 +1,18 @@
+import type { Base } from "akanjs/signal";
+import { ServiceModel } from "./serviceModule.d.ts";
+declare const BaseService_base: import("./serve.d.ts").ServiceCls<"base", {}, {
+    onCleanup: import("./injectInfo.d.ts").InjectInfo<"env", (() => Promise<void>) | undefined, {
+        onCleanup?: () => Promise<void>;
+    }, never>;
+    baseSignal: import("./injectInfo.d.ts").InjectInfo<"signal", Base, never, never>;
+}>;
+export declare class BaseService extends BaseService_base {
+    publishPing(): void;
+    cleanup(): Promise<void>;
+}
+export declare const srv: {
+    base: ServiceModel<typeof BaseService, any, any, {
+        baseService: BaseService;
+    }>;
+};
+export {};

package/types/service/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./adapt.d.ts";
+export * from "./base.service";
+export * from "./injectInfo.d.ts";
+export * from "./injectInfo.d.ts";
+export * from "./ipcTypes.d.ts";
+export * from "./predefinedAdaptor.d.ts";
+export * from "./serve.d.ts";
+export * from "./serviceModule.d.ts";
+export * from "./serviceRegistry.d.ts";
+export * from "./types.d.ts";

package/types/service/injectInfo.d.ts

@@ -0,0 +1,102 @@
+import { type BaseEnv } from "akanjs/base";
+import { type ConstantFieldTypeInput, type FieldToValue, type PlainTypeToFieldType } from "akanjs/constant";
+import type { DatabaseModel } from "akanjs/document";
+import type { Endpoint, EndpointCls, Internal, InternalCls, ServerSignal, ServerSignalCls, SliceCls } from "akanjs/signal";
+import type { Adaptor, AdaptorCls, Service, ServiceCls } from ".";
+export type InjectType = "database" | "service" | "use" | "signal" | "plug" | "env" | "memory";
+interface InjectBuilderOptions<ReturnType> {
+    generateFactory?: (options: any) => ReturnType;
+    adaptor?: AdaptorCls;
+    additionalPropKeys?: string[];
+    get?: (value: never) => unknown;
+    set?: (value: never) => unknown;
+    local?: boolean;
+    default?: unknown;
+    isMap?: boolean;
+    parentRefName: string;
+}
+export interface InjectRegistry {
+    uses: Map<string, unknown>;
+    adaptorCls: Map<string, AdaptorCls>;
+    adaptor: Map<AdaptorCls, Adaptor>;
+    adaptorRole: Map<AdaptorCls, AdaptorCls>;
+    databaseAdaptorCls: Map<string, AdaptorCls>;
+    databaseAdapor: Map<AdaptorCls, DatabaseModel>;
+    serverSignalCls: Map<string, ServerSignalCls>;
+    serverSignal: Map<ServerSignalCls, ServerSignal>;
+    signalAdaptorCls: Map<string, AdaptorCls>;
+    signalAdapor: Map<AdaptorCls, ServerSignal>;
+    serviceCls: Map<string, ServiceCls>;
+    service: Map<ServiceCls, Service>;
+    internalCls: Map<string, InternalCls>;
+    internal: Map<InternalCls, Internal>;
+    endpointCls: Map<string, EndpointCls>;
+    endpoint: Map<EndpointCls, Endpoint>;
+}
+export declare const getDefaultInjectRegistry: () => InjectRegistry;
+export interface LiveRegistry {
+    adaptor: Map<string, Adaptor>;
+    service: Map<string, Service>;
+    internal: Map<string, Internal>;
+    sliceCls: Map<string, SliceCls>;
+    endpointCls: Map<string, EndpointCls>;
+}
+export declare const getDefaultLiveRegistry: () => LiveRegistry;
+export declare class InjectInfo<Type extends InjectType = any, ReturnType = any, Env extends {
+    [key: string]: any;
+} = never, FieldValue = never> {
+    #private;
+    readonly type: Type;
+    readonly generateFactory: (options: any) => ReturnType;
+    readonly get?: (value: never) => unknown;
+    readonly set?: (value: never) => unknown;
+    readonly additionalPropKeys: string[];
+    readonly local: boolean;
+    readonly adaptor?: AdaptorCls;
+    readonly default?: unknown;
+    readonly isMap?: boolean;
+    readonly parentRefName: string;
+    constructor(type: Type, options: InjectBuilderOptions<ReturnType>);
+    static resolveInjection(instance: Adaptor | Service, applyCls: AdaptorCls | ServiceCls, registry: InjectRegistry, env: BaseEnv): Promise<void>;
+}
+type GetFieldValue<ValueRef, ExplicitType, MapValue = never> = unknown extends ExplicitType ? FieldToValue<ValueRef, MapValue> : ExplicitType;
+export declare const injectionBuilder: (parentRefName: string) => {
+    database: <ReturnType>(additionalPropKeys?: string[]) => InjectInfo<"database", ReturnType, never, never>;
+    service: <ReturnType extends Service>() => InjectInfo<"service", ReturnType, never, never>;
+    use: <ReturnType>() => InjectInfo<"use", ReturnType, never, never>;
+    signal: <Signal>() => InjectInfo<"signal", Signal, never, never>;
+    plug: <Adaptor, GenFactory extends (adaptor: Adaptor) => unknown = (adaptor: Adaptor) => Adaptor>(adaptor: AdaptorCls<Adaptor>, generateFactory?: GenFactory) => InjectInfo<"plug", ReturnType<GenFactory>, never, never>;
+    env: <GenFactory extends (arg: never) => unknown>(generateFactory: GenFactory) => InjectInfo<"env", Awaited<ReturnType<GenFactory>>, GenFactory extends (arg: infer Env extends {
+        [key: string]: any;
+    }) => unknown ? Env : never, never>;
+    memory: <ExplicitType = unknown, ValueRef extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = never, DefaultValue extends GetFieldValue<ValueRef, ExplicitType> = never, GetFn extends (value: GetFieldValue<ValueRef, ExplicitType>) => unknown = never, Local extends boolean = false>(modelRef: ValueRef, opts?: {
+        local?: Local;
+        default?: DefaultValue;
+        of?: MapValue;
+        get?: GetFn;
+        set?: (value: ReturnType<GetFn>) => GetFieldValue<ValueRef, ExplicitType>;
+    }) => InjectInfo<"memory", Local extends true ? MapConstructor extends ValueRef ? Map<string, FieldToValue<MapValue>> : (DefaultValue extends never ? true : false) extends true ? (never extends GetFn ? GetFieldValue<ValueRef, ExplicitType, MapValue> : ReturnType<GetFn>) | null : never extends GetFn ? GetFieldValue<ValueRef, ExplicitType, MapValue> : ReturnType<GetFn> : MapConstructor extends ValueRef ? {
+        get: (key: string) => Promise<(never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>) | undefined>;
+        set: (key: string, value: never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>) => Promise<void>;
+        delete: (key: string) => Promise<void>;
+        getOrInsert: (key: string, value: never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>) => Promise<never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>>;
+        getOrInsertComputed: (key: string, compute: (key: string) => (never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>) | Promise<never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>>) => Promise<never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>>;
+        keys: () => Promise<string[]>;
+        entries: () => Promise<[string, never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>][]>;
+        forEach: (callback: (value: never extends GetFn ? FieldToValue<MapValue> : ReturnType<GetFn>, key: string) => void | Promise<void>) => Promise<void>;
+        clear: () => Promise<void>;
+    } : {
+        get: () => Promise<(DefaultValue extends never ? true : false) extends true ? (never extends GetFn ? GetFieldValue<ValueRef, ExplicitType, MapValue> : ReturnType<GetFn>) | null : never extends GetFn ? GetFieldValue<ValueRef, ExplicitType, MapValue> : ReturnType<GetFn>>;
+        set: (value: (DefaultValue extends never ? true : false) extends true ? (never extends GetFn ? GetFieldValue<ValueRef, ExplicitType, MapValue> : ReturnType<GetFn>) | null : never extends GetFn ? GetFieldValue<ValueRef, ExplicitType, MapValue> : ReturnType<GetFn>) => Promise<void>;
+        delete: () => Promise<void>;
+    }, never, ValueRef>;
+};
+export type InjectBuilder<BuildType extends InjectType = InjectType> = (builder: Pick<ReturnType<typeof injectionBuilder>, BuildType>) => {
+    [key: string]: InjectInfo;
+};
+export type ExtractInjectInfoObject<InjectInfoMap extends {
+    [key: string]: InjectInfo;
+}> = {
+    [K in keyof InjectInfoMap]: ReturnType<InjectInfoMap[K]["generateFactory"]>;
+};
+export {};

package/types/service/ipcTypes.d.ts

@@ -0,0 +1,194 @@
+export type AkanChildRole = "all" | "federation" | "batch";
+export type AkanChildStatus = "starting" | "ready" | "healthy" | "draining" | "unhealthy" | "exited";
+export type AkanUpstream = {
+    type: "unix";
+    socketPath: string;
+} | {
+    type: "tcp";
+    host: string;
+    port: number;
+};
+export interface AkanJobOptions {
+    delay?: number;
+    attempts?: number;
+    priority?: number;
+    backoff?: number | {
+        type?: string;
+        delay?: number;
+    };
+    removeOnComplete?: boolean | number;
+    removeOnFail?: boolean | number;
+}
+export interface AkanJob<Data = unknown, Returns = unknown> {
+    id: string;
+    name: string;
+    data: Data;
+    attemptsMade: number;
+    opts?: AkanJobOptions;
+    returnvalue?: Returns;
+}
+export interface AkanWorker {
+    close(): Promise<void> | void;
+}
+export interface AkanMetricsReport {
+    role?: string;
+    pid?: number;
+    reportedAt?: number;
+    activeRequests?: number;
+    totalRequests?: number;
+    activeWebSockets?: number;
+    roomCount?: number;
+    queueWakeCount?: number;
+    pubsubDeliverCount?: number;
+    pubsubDropCount?: number;
+    rssBytes?: number;
+    heapTotalBytes?: number;
+    heapUsedBytes?: number;
+    externalBytes?: number;
+    arrayBuffersBytes?: number;
+    cpuUserMicros?: number;
+    cpuSystemMicros?: number;
+    maxRssKb?: number;
+    jscHeapSizeBytes?: number;
+    jscHeapCapacityBytes?: number;
+    jscExtraMemorySizeBytes?: number;
+    jscObjectCount?: number;
+    jscProtectedObjectCount?: number;
+    rscWorkerPid?: number;
+    rscWorkerStatus?: string;
+    rscWorkerRestartCount?: number;
+    rscWorkerRecycleCount?: number;
+    rscWorkerLastRecycleReason?: string;
+    rscPendingRenderCount?: number;
+    rscQueuedSendCount?: number;
+    rscRenderCount?: number;
+    rscInFlightRenderCount?: number;
+    rscLastRenderedPath?: string;
+    rscLastRenderKind?: string;
+    rscLastFlightBytes?: number;
+    rscLastFlightChunks?: number;
+    rscTotalFlightBytes?: number;
+    rscTotalFlightChunks?: number;
+    rscPagesBundleBuildId?: number;
+    rscRouteModuleCount?: number;
+    rscLoadedRouteModuleCount?: number;
+    rscRouteModuleCacheHits?: number;
+    rscRouteModuleCacheMisses?: number;
+    rscRouteModuleCacheDisabled?: boolean;
+    rscLoadedRouteModuleKeys?: string[];
+    rscTopRoutesByRenderCount?: Array<{
+        routeId: string;
+        count: number;
+        flightBytes: number;
+        avgDurationMs: number;
+    }>;
+    rscTopRoutesByFlightBytes?: Array<{
+        routeId: string;
+        count: number;
+        flightBytes: number;
+        avgDurationMs: number;
+    }>;
+    rscLastRenderDurationMs?: number;
+    rscLastRenderRouteId?: string;
+    rscLastRenderLoadedModuleDelta?: number;
+    rscLastRenderLoadedModules?: string[];
+    rscResultCacheEntries?: number;
+    rscResultCacheHits?: number;
+    rscResultCacheMisses?: number;
+    rscResultCacheBypass?: number;
+    ssrChunkRegistrySize?: number;
+    ssrChunkLoadCount?: number;
+    ssrChunkCacheHitCount?: number;
+    httpFullSsrCount?: number;
+    httpRscNavigationCount?: number;
+    httpStaticAssetCount?: number;
+    httpCsrCount?: number;
+    httpImageCount?: number;
+    httpHtmlCacheEntries?: number;
+    httpHtmlCacheHits?: number;
+    httpHtmlCacheMisses?: number;
+    httpHtmlCacheBypass?: number;
+    eventLoopLagMeanMs?: number;
+    eventLoopLagP99Ms?: number;
+    eventLoopLagMaxMs?: number;
+    gcDurationMs?: number;
+    trace?: unknown;
+}
+export type AkanIpcMessage = {
+    type: "ready";
+    pid: number;
+    replicaIdx: number;
+    role: AkanChildRole;
+    upstream?: AkanUpstream;
+    healthPath?: string;
+} | {
+    type: "backend-ready";
+    pid: number;
+} | {
+    type: "pubsub.publish";
+    roomId: string;
+    data: object | object[];
+    origin?: string;
+} | {
+    type: "pubsub.deliver";
+    roomId: string;
+    data: object | object[];
+    origin?: string;
+} | {
+    type: "pubsub.subscribe";
+    roomId: string;
+    socketId?: string;
+    pid?: number;
+} | {
+    type: "pubsub.unsubscribe";
+    roomId: string;
+    socketId?: string;
+    pid?: number;
+} | {
+    type: "pubsub.snapshot.request";
+} | {
+    type: "pubsub.snapshot";
+    rooms: string[];
+    pid?: number;
+} | {
+    type: "queue.enqueued";
+    queue: string;
+    name: string;
+    jobId: string;
+} | {
+    type: "queue.wake";
+    queue?: string;
+    name?: string;
+} | {
+    type: "health.ping";
+    nonce: string;
+    sentAt: number;
+} | {
+    type: "health.pong";
+    nonce: string;
+    sentAt: number;
+    pid?: number;
+} | {
+    type: "ws.opened";
+    socketId: string;
+    roomId?: string;
+    pid?: number;
+} | {
+    type: "ws.closed";
+    socketId: string;
+    roomId?: string;
+    pid?: number;
+} | {
+    type: "metrics.report";
+    metrics: AkanMetricsReport;
+    pid?: number;
+} | {
+    type: "shutdown";
+    signal?: string;
+} | {
+    type: "error";
+    message: string;
+    stack?: string;
+    pid?: number;
+};
+export declare const sendAkanIpc: (message: AkanIpcMessage) => void;

package/types/service/predefinedAdaptor/cache.adaptor.d.ts

@@ -0,0 +1,46 @@
+import type { BaseEnv, Dayjs, SshOptions } from "akanjs/base";
+import type { Redis } from "ioredis";
+export interface CacheAdaptor {
+    set(topic: string, key: string, value: string | number | Buffer, option?: {
+        expireAt?: Dayjs;
+    }): Promise<void>;
+    get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined>;
+    delete(topic: string, key: string): Promise<void>;
+    getClient?(): Redis;
+    hset(topic: string, key: string, subKey: string, value: string | number | Buffer, option?: {
+        expireAt?: Dayjs;
+    }): Promise<void>;
+    hget<T extends string | number | Buffer>(topic: string, key: string, subKey: string): Promise<T | undefined>;
+    hdelete(topic: string, key: string, subKey: string): Promise<void>;
+    hkeys(topic: string, key: string): Promise<string[]>;
+    hentries<T extends string | number | Buffer>(topic: string, key: string): Promise<[string, T][]>;
+    hclear(topic: string, key: string): Promise<void>;
+}
+interface RedisEnv extends BaseEnv {
+    redis?: {
+        username?: string;
+        password?: string;
+        sshOptions?: SshOptions;
+    };
+}
+declare const RedisCache_base: import("..").AdaptorCls<{}, {
+    redis: import("..").InjectInfo<"env", Redis, RedisEnv, never>;
+}>;
+export declare class RedisCache extends RedisCache_base implements CacheAdaptor {
+    set(topic: string, key: string, value: string | number | Buffer, option?: {
+        expireAt?: Dayjs;
+    }): Promise<void>;
+    get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined>;
+    delete(topic: string, key: string): Promise<void>;
+    hset(topic: string, key: string, subKey: string, value: string | number | Buffer, option?: {
+        expireAt?: Dayjs;
+    }): Promise<void>;
+    hget<T extends string | number | Buffer>(topic: string, key: string, subKey: string): Promise<T | undefined>;
+    hdelete(topic: string, key: string, subKey: string): Promise<void>;
+    hkeys(topic: string, key: string): Promise<string[]>;
+    hentries<T extends string | number | Buffer>(topic: string, key: string): Promise<[string, T][]>;
+    hclear(topic: string, key: string): Promise<void>;
+    getClient(): Redis;
+    onDestroy(): Promise<void>;
+}
+export {};

package/types/service/predefinedAdaptor/compress.adaptor.d.ts

@@ -0,0 +1,22 @@
+import { type Cls } from "akanjs/base";
+export interface CompressAdaptor {
+    encode(ref: Cls, arrDepth: number, value: unknown): Buffer | null;
+    decode<T = unknown>(ref: Cls, arrDepth: number, buffer: Buffer): T;
+}
+declare const JsonCompressor_base: import("..").AdaptorCls<{}, {}>;
+export declare class JsonCompressor extends JsonCompressor_base implements CompressAdaptor {
+    encode(_ref: Cls, _arrDepth: number, value: unknown): Buffer | null;
+    decode<T = unknown>(ref: Cls, arrDepth: number, buffer: Buffer, { raw }?: {
+        raw?: boolean;
+    }): T;
+}
+declare const ProtobufCompressor_base: import("..").AdaptorCls<{}, {}>;
+export declare class ProtobufCompressor extends ProtobufCompressor_base implements CompressAdaptor {
+    #private;
+    onInit(): Promise<void>;
+    encode(ref: Cls, arrDepth: number, value: unknown): Buffer | null;
+    decode<T = unknown>(ref: Cls, arrDepth: number, buffer: Buffer, { raw }?: {
+        raw?: boolean;
+    }): T;
+}
+export {};