brustjs 0.1.50-alpha → 0.1.52-alpha

package/types/treaty.d.ts

@@ -0,0 +1,70 @@
+import type { ActionsBuilder, EndpointEntry } from './define-actions.ts';
+export interface TreatyResponse<Data = unknown, Err = unknown> {
+    data: Data | null;
+    error: {
+        status: number;
+        value: Err;
+    } | null;
+    status: number;
+    headers: Record<string, string>;
+    response: Response | null;
+}
+export interface ClientOptions {
+    prefix?: string;
+    /** Absolute origin of ANOTHER brust deployment to target, e.g.
+     * `https://api.example.com` (a path suffix like `/v2` composes by
+     * concatenation). Must match `^https?://`; a trailing slash is stripped.
+     * When set, the action prefix is `prefix ?? '/_brust/action'` — the global
+     * `__BRUST_ACTION_PREFIX__` belongs to the SERVING app and is never
+     * consulted. Cross-origin cookies: pass a `fetch` override that sets
+     * `credentials: 'include'` (and configure `cors.credentials` server-side). */
+    baseUrl?: string;
+    headers?: Record<string, string> | (() => Record<string, string>);
+    fetch?: typeof fetch;
+}
+export type PermissiveProxy = {
+    (arg?: any): PermissiveProxy;
+    [key: string]: PermissiveProxy;
+} & {
+    get: (options?: any) => Promise<TreatyResponse<any, any>>;
+    post: (body?: any, options?: any) => Promise<TreatyResponse<any, any>>;
+    put: (body?: any, options?: any) => Promise<TreatyResponse<any, any>>;
+    patch: (body?: any, options?: any) => Promise<TreatyResponse<any, any>>;
+    delete: (body?: any, options?: any) => Promise<TreatyResponse<any, any>>;
+    head: (options?: any) => Promise<TreatyResponse<any, any>>;
+};
+/** Per-method client signatures for one endpoint-entry map (the `{ GET, POST, … }`
+ * object for a single path). Bodyless methods (GET/HEAD) take only options. */
+type Methods<E> = {
+    [M in keyof E & string as Lowercase<M>]: M extends 'GET' | 'HEAD' ? E[M] extends EndpointEntry ? (o?: {
+        query?: Record<string, string>;
+        headers?: Record<string, string>;
+    }) => Promise<TreatyResponse<E[M]['output'], E[M]['error']>> : never : E[M] extends EndpointEntry ? (b?: E[M]['input'], o?: {
+        headers?: Record<string, string>;
+    }) => Promise<TreatyResponse<E[M]['output'], E[M]['error']>> : never;
+};
+/** A path is static iff it contains no `{param}` segment. */
+type IsStatic<K extends string> = K extends `${string}{${string}}${string}` ? false : true;
+/** Keep only the static path keys of the accumulator. */
+type StaticAcc<Acc> = {
+    [K in keyof Acc as K extends string ? (IsStatic<K> extends true ? K : never) : never]: Acc[K];
+};
+/** Given a path key `K` and the accumulated prefix `P`, the next segment after `P`. */
+type Tail<K extends string, P extends string> = K extends `${P}/${infer Rest}` ? Rest extends `${infer H}/${string}` ? H : Rest : never;
+/** All immediate child segments under prefix `P`. */
+type ChildSegs<SA, P extends string> = {
+    [K in keyof SA]: Tail<K & string, P>;
+}[keyof SA];
+/** The entry map for the exact path `P`, if one exists. */
+type ExactEntry<SA, P extends string> = P extends keyof SA ? SA[P] : {};
+/** A treaty node: methods of the exact path + child segment nodes + permissive fallback. */
+type TNode<SA, P extends string> = Methods<ExactEntry<SA, P>> & {
+    [Seg in ChildSegs<SA, P> & string]: TNode<SA, `${P}/${Seg}`>;
+} & PermissiveProxy;
+export type Treaty<App> = App extends ActionsBuilder<infer Acc> ? TNode<StaticAcc<Acc>, ''> : PermissiveProxy;
+/** Build a treaty proxy. Static segments accumulate as a path; a function call
+ * with an object fills the next {param}(s) positionally (in insertion order); a
+ * terminal method key (.get/.post/…) performs the request. URL is composed from
+ * the literal accumulated segments — never from any inferred type. */
+export declare function client<App = unknown>(opts?: ClientOptions): Treaty<App>;
+export {};

package/types/ws/handler.d.ts

@@ -0,0 +1,26 @@
+import type { Route, RouteCall } from '../routes.ts';
+export type WsCall = Extract<RouteCall, {
+    kind: 'ws';
+}>;
+/** NAPI surface — Rust provides these. Tests use a mock. */
+export interface WsNapi {
+    send(conn_id: bigint, data: Uint8Array, isBinary: boolean): Promise<void>;
+    close(conn_id: bigint, code: number, reason: string): void;
+    signalOpen(conn_id: bigint, status: number, body: string, contentType: string, subprotocol: string): void;
+    registerHandlers(conn_id: bigint, onMessage: (data: Uint8Array, isBinary: boolean) => void, onClose: (code: number, reason: string) => void): void;
+}
+/** Pick the first subprotocol from `routeList` that the client also requested.
+ * Returns null when there's no overlap or routeList is empty/undefined. */
+export declare function pickSubprotocol(clientList: string[], routeList: string[] | undefined): string | null;
+/**
+ * Per-connection JS driver for WebSocket routes. Caller (wsBranch) is
+ * responsible for running middleware FIRST and only invoking this on a 101
+ * verdict — the signalOpen call here is always 101.
+ *
+ * Ordering note: handlers.open is *called* before any message can fire,
+ * but if open is async it is NOT guaranteed to *complete* before the first
+ * message arrives. Handlers that initialise per-connection state in open
+ * and read it in message should await any setup synchronously inside open,
+ * or guard reads in message against missing state.
+ */
+export declare function handleWsConn(call: WsCall, route: Route, napi: WsNapi): Promise<void>;