@scaffoldly/rowdy 0.0.2-1-beta.20251011182751.ccfebc8 → 0.0.2-1-beta.20251013190835.df2655f

package/dist/index.d.ts

@@ -1,13 +1,211 @@
 #!/usr/bin/env node
-import { Observable } from 'rxjs';
+import { Observable, ReplaySubject } from 'rxjs';
+import { PassThrough, Readable, Writable } from 'stream';
+import { AxiosHeaders, AxiosResponseHeaders } from 'axios';
+import { Agent } from 'https';
+import { APIGatewayProxyEventV2 } from 'aws-lambda';
 
 interface ILoggable {
     repr(): string;
 }
+type Primitive = string | number | boolean | undefined | null | Error;
+type Loggable = Error | AbortSignal | Buffer | Primitive | Array<Primitive> | ILoggable | Array<ILoggable>;
+declare class Logger {
+    private _debug;
+    private _trace;
+    constructor();
+    get isDebugging(): boolean;
+    get isTracing(): boolean;
+    withDebugging(): this;
+    withTracing(): this;
+    static asPrimitive(value: Loggable): Primitive;
+    private log;
+    info: (message: string, params?: Record<string, Loggable>) => void;
+    error: (message: string, params?: Record<string, Loggable>) => void;
+    warn: (message: string, params?: Record<string, Loggable>) => void;
+    debug: (message: string, params?: Loggable | Record<string, Loggable>) => void;
+}
+
+type Status = 'ok' | 'error' | 'timeout' | 'unknown';
+type Latency = `${number}ms`;
+type CheckResult = {
+    status: Status;
+    latency?: Latency;
+    reason?: string | undefined;
+};
+
+type Secrets = Record<string, string>;
+declare class Environment implements ILoggable {
+    private log;
+    abort: AbortController;
+    readonly signal: AbortSignal;
+    readonly bin: string | undefined;
+    private _pipelines;
+    private subscriptions;
+    private _routes;
+    private _command?;
+    private _env;
+    constructor(log: Logger);
+    get routes(): Routes;
+    get command(): string[] | undefined;
+    get env(): Record<string, string | undefined>;
+    init(): this;
+    poll(): Observable<Result<Pipeline>>;
+    protected withSecrets(secrets: Secrets): this;
+    repr(): string;
+}
+
+declare abstract class Pipeline implements ILoggable {
+    protected readonly environment: Environment;
+    private _createdAt;
+    constructor(environment: Environment);
+    get env(): Record<string, string | undefined>;
+    get signal(): AbortSignal;
+    get routes(): Routes;
+    get createdAt(): number;
+    abstract into(): Observable<Request<Pipeline>>;
+    abstract repr(): string;
+}
+declare class FileDescriptors {
+    readonly stdin: PassThrough;
+    readonly stdout: PassThrough;
+    readonly stderr: PassThrough;
+    end(): void;
+}
+declare abstract class Request<P extends Pipeline> implements ILoggable {
+    protected readonly pipeline: P;
+    readonly createdAt: number;
+    readonly fds: FileDescriptors;
+    constructor(pipeline: P);
+    get signal(): AbortSignal;
+    get stdin(): Readable;
+    get stdout(): Writable;
+    get stderr(): Writable;
+    withInput(input: Readable): this;
+    abstract into(): Observable<Proxy<P, unknown>>;
+    abstract repr(): string;
+}
+declare abstract class Proxy<P extends Pipeline, T> implements ILoggable {
+    readonly pipeline: P;
+    readonly request: Request<P>;
+    constructor(pipeline: P, request: Request<P>);
+    get signal(): AbortSignal;
+    abstract invoke(): Observable<T>;
+    abstract into(): Observable<Response<P>>;
+    abstract repr(): string;
+}
+declare class Chunk {
+    readonly data: Buffer | string;
+    readonly bytes: number;
+    constructor(data: Buffer | string, bytes: number);
+}
+declare abstract class Response<P extends Pipeline> extends ReplaySubject<Chunk> implements ILoggable {
+    protected readonly pipeline: P;
+    readonly request: Request<P>;
+    constructor(pipeline: P, request: Request<P>);
+    get signal(): AbortSignal;
+    abstract into(): Observable<Result<P>>;
+    abstract repr(): string;
+}
+declare class Result<P extends Pipeline> implements ILoggable {
+    protected readonly pipeline: P;
+    readonly request: Request<P>;
+    readonly success: boolean;
+    readonly bytes: number;
+    readonly createdAt: number;
+    constructor(pipeline: P, request: Request<P>, success: boolean, bytes: number);
+    get uptime(): number;
+    get duration(): number;
+    repr(): string;
+}
+
+declare abstract class HttpProxy<P extends Pipeline> extends Proxy<P, HttpResponse> {
+    readonly method: string;
+    readonly uri: URI;
+    readonly headers: HttpHeaders;
+    readonly body: Buffer;
+    constructor(pipeline: P, request: Request<P>, method: string, uri: URI, headers: HttpHeaders, body: Buffer);
+    get httpsAgent(): Agent | undefined;
+    invoke(): Observable<HttpResponse>;
+    repr(): string;
+}
+declare class HttpHeaders implements ILoggable {
+    private headers;
+    private constructor();
+    proxy(): HttpHeaders;
+    static from(obj: Record<string, string | string[]>): HttpHeaders;
+    static fromAxios(axiosHeaders: Partial<AxiosHeaders | AxiosResponseHeaders>): HttpHeaders;
+    static fromLambda(headers: Partial<APIGatewayProxyEventV2['headers']>): HttpHeaders;
+    intoAxios(): AxiosHeaders;
+    intoJSON(): Record<string, unknown>;
+    override(key: string, value?: string | string[]): this;
+    repr(): string;
+}
+declare abstract class HttpResponse implements ILoggable {
+    private _status;
+    private _headers;
+    private _cookies;
+    private _data;
+    constructor(status: number, headers: HttpHeaders, cookies: string[], data: Readable);
+    get status(): number;
+    get headers(): HttpHeaders;
+    get cookies(): string[];
+    get data(): Readable;
+    prelude(): {
+        statusCode?: number;
+        headers?: Record<string, unknown>;
+        cookies?: string[];
+    };
+    withStatus(code: number): this;
+    withHeader(key: string, value?: string): this;
+    withHeaders(headers: HttpHeaders): this;
+    withCookies(cookies: string[]): this;
+    withData(data: Readable): this;
+    abstract handle<P extends Pipeline>(proxy: HttpProxy<P>): Observable<HttpResponse>;
+    abstract repr(): string;
+}
 
-type CheckResult = `${number}ms` | 'timeout' | 'error' | 'unknown';
+type ApiVersion = 'rowdy.run/v1alpha1';
+type ApiKind = 'Routes' | 'Health' | 'Hello' | 'NotFound';
+type ApiSchema<Spec, Status> = {
+    apiVersion: ApiVersion;
+    kind: ApiKind;
+    spec?: Spec;
+    status: Status;
+};
+type ApiResponseStatus = {
+    code: number;
+    headers: {
+        [key: string]: string | string[];
+    };
+};
+type Health$1 = {
+    req: never;
+    opts: never;
+    res: {
+        healthy: boolean;
+    };
+};
+type Hello = {
+    req: {
+        to: string;
+    };
+    opts: {
+        enthusiastic?: boolean;
+    };
+    res: {
+        to: string;
+    };
+};
+declare class Api {
+    private routes;
+    constructor();
+    health(): Observable<ApiSchema<Health$1['res'], ApiResponseStatus>>;
+    hello(req: Hello['req'], opts?: Hello['opts']): Observable<ApiSchema<Hello['res'], ApiResponseStatus>>;
+    handle<P extends Pipeline>(proxy: HttpProxy<P>): Observable<ApiSchema<unknown, ApiResponseStatus>>;
+    private handler;
+}
 
-type RoutesApiVersion = 'rowdy.run/v1alpha1';
 type RoutePaths = {
     [key: string]: string | undefined;
 };
@@ -27,13 +225,10 @@ type RouteRule = {
     backendRefs?: Array<RouteRuleBackendRef>;
 };
 interface IRoutes {
-    readonly version: RoutesApiVersion;
+    readonly version: ApiVersion;
     readonly rules: Array<RouteRule>;
 }
-type URIHealth = {
-    healthy: boolean;
-    latency: CheckResult;
-};
+type URIHealth = CheckResult;
 type Search = {
     key: string;
     value: string;
@@ -41,9 +236,10 @@ type Search = {
 declare class URI extends URL implements ILoggable {
     readonly insecure: boolean;
     protected static awaits: Map<string, Observable<URI>>;
-    static REASON: string;
+    static ERROR: string;
     protected constructor(url: URL, insecure?: boolean);
-    get reason(): string | undefined;
+    get server(): string;
+    get error(): string | undefined;
     withSearch(search: Search, value?: string): this;
     static from(uri: string): URI;
     static fromError(error: Error, code?: number): URI;
@@ -55,7 +251,7 @@ type Health = {
     [origin: string]: URIHealth;
 };
 declare class Routes implements IRoutes, ILoggable {
-    readonly version: RoutesApiVersion;
+    readonly version: ApiVersion;
     readonly rules: Array<RouteRule>;
     private constructor();
     static empty(): Routes;
@@ -77,4 +273,4 @@ declare class Routes implements IRoutes, ILoggable {
 
 declare const ABORT: AbortController;
 
-export { ABORT, Routes, URI };
+export { ABORT, Api, Routes, URI };