elysia 1.4.28 → 2.0.0-beta.0

package/dist/trace.d.ts

@@ -1,135 +1,150 @@
-import type { Context } from './context';
-import type { Prettify, RouteSchema, SingletonBase } from './types';
-export type TraceEvent = 'request' | 'parse' | 'transform' | 'beforeHandle' | 'handle' | 'afterHandle' | 'mapResponse' | 'afterResponse' | 'error';
-export type TraceStream = {
-    id: number;
-    event: TraceEvent;
-    type: 'begin' | 'end';
-    begin: number;
-    name?: string;
-    total?: number;
-};
-type TraceEndDetail = {
-    /**
-     * Timestamp of a function after it's executed since the server start
-     */
-    end: TraceProcess<'end'>;
-    /**
-     * Error that was thrown in the lifecycle
-     */
-    error: Error | null;
-    /**
-     * Elapsed time of the lifecycle
-     */
-    elapsed: number;
-};
-export type TraceProcess<Type extends 'begin' | 'end' = 'begin' | 'end', WithChildren extends boolean = true> = Type extends 'begin' ? Prettify<{
-    /**
-     * Function name
-     */
-    name: string;
-    /**
-     * Timestamp of a function is called since the server start
-     */
-    begin: number;
-    /**
-     * Timestamp of a function after it's executed since the server start
-     */
-    end: Promise<number>;
-    /**
-     * Error that was thrown in the lifecycle
-     */
-    error: Promise<Error | null>;
-    /**
-     * Listener to intercept the end of the lifecycle
-     *
-     * If you want to mutate the context, you must do it in this function
-     * as there's a lock mechanism to ensure the context is mutate successfully
-     */
-    onStop(
-    /**
-     * A callback function that will be called when the function ends
-     *
-     * If you want to mutate the context, you must do it in this function
-     * as there's a lock mechanism to ensure the context is mutate successfully
-     */
-    callback?: (detail: TraceEndDetail) => unknown): Promise<void>;
+import { Prettify, RouteSchema, SingletonBase } from "./types.js";
+import { Context } from "./context.js";
+
+//#region src/trace.d.ts
+type TraceEvent = 'request' | 'parse' | 'transform' | 'beforeHandle' | 'handle' | 'afterHandle' | 'mapResponse' | 'afterResponse' | 'error';
+declare function unionTracePhases(handlers: readonly Function[] | undefined): Set<TraceEvent> | null;
+interface TraceStream {
+  id: number;
+  event: TraceEvent;
+  begin: number;
+  name?: string;
+  total?: number;
+}
+interface TraceEndDetail {
+  /**
+   * Timestamp of a function after it's executed since the server start
+   */
+  end: TraceProcess<'end'>;
+  /**
+   * Error that was thrown in the lifecycle
+   */
+  error: Error | null;
+  /**
+   * Elapsed time of the lifecycle
+   */
+  elapsed: number;
+}
+type TraceProcess<Type extends 'begin' | 'end' = 'begin' | 'end', WithChildren extends boolean = true> = Type extends 'begin' ? Prettify<{
+  /**
+   * Function name
+   */
+  name: string;
+  /**
+   * Timestamp of a function is called since the server start
+   */
+  begin: number;
+  /**
+   * Timestamp of a function after it's executed since the server start
+   */
+  end: Promise<number>;
+  /**
+   * Error that was thrown in the lifecycle
+   */
+  error: Promise<Error | null>;
+  /**
+   * Listener to intercept the end of the lifecycle
+   *
+   * If you want to mutate the context, you must do it in this function
+   * as there's a lock mechanism to ensure the context is mutate successfully
+   */
+  onStop(
+  /**
+   * A callback function that will be called when the function ends
+   *
+   * If you want to mutate the context, you must do it in this function
+   * as there's a lock mechanism to ensure the context is mutate successfully
+   */
+
+  callback?: (detail: TraceEndDetail) => unknown): Promise<void>;
 } & (WithChildren extends true ? {
-    /**
-     * total number of lifecycle's children and
-     * total number of `onEvent` will be called
-     * if there were no early exists or error thrown
-     */
-    total: number;
-    /**
-     * Listener to intercept each child lifecycle
-     */
-    onEvent(
-    /**
-     * Callback function that will be called for when each child start
-     */
-    callback?: (process: TraceProcess<'begin', false>) => unknown): Promise<void>;
+  /**
+   * total number of lifecycle's children and
+   * total number of `onEvent` will be called
+   * if there were no early exists or error thrown
+   */
+  total: number;
+  /**
+   * Listener to intercept each child lifecycle
+   */
+  onEvent(
+  /**
+   * Callback function that will be called for when each child start
+   */
+
+  callback?: (process: TraceProcess<'begin', false>) => unknown): void;
 } : {
-    /**
-     * Index of the child event
-     */
-    index: number;
+  /**
+   * Index of the child event
+   */
+  index: number;
 })> : number;
-export type TraceListener = (callback?: (process: TraceProcess<'begin'>) => unknown) => Promise<TraceProcess<'begin'>>;
-export type TraceHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
-    decorator: {};
-    store: {};
-    derive: {};
-    resolve: {};
+type TraceListener = (callback?: (process: TraceProcess<'begin'>) => unknown) => Promise<TraceProcess<'begin'>>;
+type TraceHandler<in out Route extends RouteSchema = {}, in out Singleton extends SingletonBase = {
+  decorator: {};
+  store: {};
+  derive: {};
 }> = {
-    (lifecycle: Prettify<{
-        id: number;
-        context: Context<Route, Singleton>;
-        set: Context['set'];
-        time: number;
-        store: Singleton['store'];
-        response: unknown;
-    } & {
-        [x in `on${Capitalize<TraceEvent>}`]: TraceListener;
-    }>): unknown;
-};
-export declare const ELYSIA_TRACE: unique symbol;
-export declare const createTracer: (traceListener: TraceHandler) => (context: Context) => {
-    request: (process: TraceStream) => {
-        resolveChild: ((process: TraceStream) => () => void)[];
-        resolve(error?: Error | null): void;
-    };
-    parse: (process: TraceStream) => {
-        resolveChild: ((process: TraceStream) => () => void)[];
-        resolve(error?: Error | null): void;
-    };
-    transform: (process: TraceStream) => {
-        resolveChild: ((process: TraceStream) => () => void)[];
-        resolve(error?: Error | null): void;
-    };
-    beforeHandle: (process: TraceStream) => {
-        resolveChild: ((process: TraceStream) => () => void)[];
-        resolve(error?: Error | null): void;
-    };
-    handle: (process: TraceStream) => {
-        resolveChild: ((process: TraceStream) => () => void)[];
-        resolve(error?: Error | null): void;
-    };
-    afterHandle: (process: TraceStream) => {
-        resolveChild: ((process: TraceStream) => () => void)[];
-        resolve(error?: Error | null): void;
-    };
-    error: (process: TraceStream) => {
-        resolveChild: ((process: TraceStream) => () => void)[];
-        resolve(error?: Error | null): void;
-    };
-    mapResponse: (process: TraceStream) => {
-        resolveChild: ((process: TraceStream) => () => void)[];
-        resolve(error?: Error | null): void;
-    };
-    afterResponse: (process: TraceStream) => {
-        resolveChild: ((process: TraceStream) => () => void)[];
-        resolve(error?: Error | null): void;
-    };
+  (lifecycle: Prettify<{
+    /**
+     * Per-request id. Sourced from `crypto.randomUUIDv7()` when
+     * the runtime supports it (Bun ≥ 1.1.40), otherwise
+     * `crypto.randomUUID()`. Useful for log correlation.
+     */
+    id: string;
+    context: Context<Route, Singleton>;
+    set: Context['set'];
+    time: number;
+    store: Singleton['store'];
+    response: unknown;
+  } & { [x in `on${Capitalize<TraceEvent>}`]: TraceListener }>): unknown;
 };
-export {};
+declare class TraceRecorder {
+  #private;
+  begun?: TraceStream;
+  remaining: number;
+  childIndex: number;
+  groupError: Error | null;
+  ended: boolean;
+  endTime: number;
+  endError: Error | null;
+  callbacksBegin?: Function[];
+  callbacksEnd?: Function[];
+  callbacksChild?: Function[];
+  pendingPromise?: Promise<TraceProcess<'begin'>>;
+  pendingResolve?: (result: TraceProcess<'begin'>) => void;
+  endPromise?: Promise<number>;
+  endResolve?: (end: number) => void;
+  errorPromise?: Promise<Error | null>;
+  errorResolve?: (error: Error | null) => void;
+  result?: TraceProcess<'begin'>;
+  listenFn?: (callback?: Function) => Promise<TraceProcess<'begin'>>;
+  childBegin?: (process: TraceStream) => (error?: Error | null) => void;
+  listen(): (callback?: Function) => Promise<TraceProcess<"begin">>;
+  begin(process: TraceStream): this;
+  get resolveChild(): this;
+  shift(): ((process: TraceStream) => (error?: Error | null) => void) | undefined;
+  resolve(error?: Error | null, at?: number): void;
+}
+declare class TracerHandle {
+  slots: (TraceRecorder | undefined)[];
+  rid: string;
+  bt?: number[];
+  et?: number[];
+  er?: (Error | null)[];
+  tt?: number[];
+  nm?: string[];
+  b(index: number, total: number, name?: string): number;
+  gc(rp: number | TraceRecorder | undefined, error: Error): void;
+  r(rp: number | TraceRecorder | undefined, error?: Error | null): void;
+  listen(index: number): NonNullable<TraceRecorder['listenFn']>;
+  begin(index: number, process: TraceStream): TraceRecorder;
+}
+declare const createTracer: (traceListener: TraceHandler) => (context: Context) => TracerHandle;
+interface TraceCapability {
+  readonly id: string;
+  readonly createTracer: typeof createTracer;
+  readonly unionTracePhases: typeof unionTracePhases;
+}
+//#endregion
+export { TraceCapability, TraceEndDetail, TraceEvent, TraceHandler, TraceListener, TraceProcess, TraceStream, createTracer, unionTracePhases };