@scaffoldly/rowdy 0.1.0-beta.20251029121749.6bd8f24 → 0.1.0-beta.20251107133750.a03c442

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { Observable, ReplaySubject } from 'rxjs';
 import { AxiosInstance, AxiosHeaders, AxiosResponseHeaders } from 'axios';
-import * as path_to_regexp from 'path-to-regexp';
 import { PassThrough, Readable, Writable } from 'stream';
 import { GrpcRouter, GrpcResponse } from '@scaffoldly/rowdy-grpc';
 import { Agent } from 'https';
@@ -40,6 +39,8 @@ declare abstract class Pipeline implements ILoggable {
     readonly environment: Environment;
     private _createdAt;
     constructor(environment: Environment);
+    get name(): string;
+    get version(): string;
     get log(): Logger;
     get env(): Record<string, string | undefined>;
     get signal(): AbortSignal;
@@ -121,8 +122,12 @@ declare class Environment implements ILoggable {
     private _command?;
     private _env;
     private _args;
+    private _rowdy;
     constructor(log: Logger);
     get opts(): Args;
+    get name(): string;
+    get version(): string;
+    get rowdy(): Rowdy;
     get routes(): Routes;
     get command(): string[] | undefined;
     get env(): Record<string, string | undefined>;
@@ -132,105 +137,29 @@ declare class Environment implements ILoggable {
     repr(): string;
 }
 
-interface IImageApi {
-    log: Logger;
+type ApiVersion = 'rowdy.run/v1alpha1';
+interface IApi {
     http: AxiosInstance;
-    getImage(req: Image['Req'], opts?: Image['Opts']['GET']): Observable<ApiSchema<Image['Req'], Image['Res']>>;
-    putImage(req: Image['Req'], opts?: Image['Opts']['PUT']): Observable<ApiSchema<Image['Req'], Image['Res']>>;
+    log: Logger;
+    environment: Environment | undefined;
 }
-interface IRegistryApi {
+type PullImageOptions = {
+    authorization?: string;
+    registry?: string;
+};
+interface IImageApi {
     log: Logger;
     http: AxiosInstance;
-    infer(): Observable<IRegistryApi>;
-    getRegistry(req?: Registry['Req']): Observable<ApiSchema<Registry['Req'], Registry['Res']>>;
+    registry: Observable<TRegistry>;
+    pullImage(image: string, opts?: PullImageOptions): Observable<TPulledImage>;
 }
-type ApiVersion = 'rowdy.run/v1alpha1';
-type ApiKind = 'Routes' | 'NotFound' | 'BadRequest' | Health$1['kind'] | Image['kind'] | Registry['kind'];
-type ApiSchema<Spec, Status> = {
-    apiVersion: ApiVersion;
-    kind: ApiKind;
-    spec?: Spec;
-    status: Status;
+type TPulledImage = {
+    image: string;
+    imageRef: string;
 };
-type ApiResponseStatus = {
-    code: number;
-    headers?: {
-        [key: string]: string | string[];
-    };
-    reason?: string | undefined;
-};
-type Health$1 = {
-    kind: 'Health';
-    req: never;
-    opts: never;
-    res: {
-        healthy: boolean;
-    };
-};
-type Registry = {
-    kind: 'Registry';
-    Req: {
-        registry?: string;
-        authorization?: string;
-    };
-    Res: ApiResponseStatus & {
-        registry: string;
-    };
-};
-type Image = {
-    kind: 'Image';
-    Req: {
-        image: string | string[];
-    };
-    Opts: {
-        GET: {
-            authorization?: string;
-        };
-        PUT: Image['Opts']['GET'] & {
-            namepace?: string;
-            registry?: string;
-        };
-    };
-    Res: ApiResponseStatus & {
-        registry: string;
-        namespace: string;
-        name: string;
-        reference: string;
-        tags: string[];
-        index: Image['External']['ImageIndex'];
-        images: Record<string, Image['External']['ImageManifest']>;
-        blobs: (Image['External']['Ref'] & {
-            platform: string;
-            url: string;
-        })[];
-    };
-    External: {
-        Ref: Partial<{
-            mediaType: string;
-            size: number;
-            digest: string;
-            annotations: Record<string, string>;
-        }>;
-        Config: Image['External']['Ref'];
-        Layer: Image['External']['Ref'];
-        Manifest: Image['External']['Ref'] & Partial<{
-            platform: Partial<{
-                architecture: string;
-                os: string;
-            }>;
-        }>;
-        ImageIndex: Image['External']['Ref'] & Partial<{
-            schemaVersion: number;
-            mediaType: 'application/vnd.oci.image.index.v1+json' | 'application/vnd.docker.distribution.manifest.list.v2+json';
-            manifests: Image['External']['Manifest'][];
-        }>;
-        ImageManifest: Image['External']['Manifest'] & Partial<{
-            schemaVersion: number;
-            mediaType: 'application/vnd.oci.image.manifest.v1+json' | 'application/vnd.docker.distribution.manifest.v2+json';
-            config: Image['External']['Config'];
-            layers: Image['External']['Layer'][];
-        }>;
-    };
+type TRegistry = {
+    registry: string;
+    authorization?: string;
 };
 
 type RoutePaths = {
@@ -310,6 +239,7 @@ declare abstract class HttpProxy<P extends Pipeline> extends Proxy<P, HttpRespon
     readonly body: Buffer;
     readonly source: Source;
     constructor(pipeline: P, request: Request<P>, method: string, uri: URI, headers: HttpHeaders, body: Buffer, source: Source);
+    get environment(): Environment;
     get httpsAgent(): Agent | undefined;
     invoke(): Observable<HttpResponse>;
     repr(): string;
@@ -320,22 +250,24 @@ declare class HttpHeaders implements ILoggable {
     get userAgent(): string;
     get(header: string): string | string[] | undefined;
     proxy(): HttpHeaders;
-    static from(obj: Record<string, string | string[]>): HttpHeaders;
+    static from(obj: Record<string, string | string[] | undefined | null>): HttpHeaders;
     static fromHeaders(headers: Headers): HttpHeaders;
     static fromAxios(axiosHeaders: Partial<AxiosHeaders | AxiosResponseHeaders>): HttpHeaders;
     static fromLambda(headers: Partial<APIGatewayProxyEventV2['headers']>): HttpHeaders;
     intoAxios(): AxiosHeaders;
     intoJSON(): Record<string, unknown>;
     intoHeaders(): Headers;
-    override(key: string, value?: string | string[]): this;
+    override(key: string, value?: string | string[] | undefined): this;
     repr(): string;
 }
 declare abstract class HttpResponse implements ILoggable {
+    protected environment: Environment;
     private _status;
     private _headers;
     private _cookies;
     private _data;
-    constructor(status: number, headers: HttpHeaders, cookies: string[], data: Readable);
+    constructor(environment: Environment, status: number, headers: HttpHeaders, cookies: string[], data: Readable);
+    get rowdy(): Rowdy;
     get status(): number;
     get headers(): HttpHeaders;
     get cookies(): string[];
@@ -354,13 +286,12 @@ declare abstract class HttpResponse implements ILoggable {
     abstract repr(): string;
 }
 
-declare class Rowdy {
+declare class Rowdy implements IApi {
     readonly log: Logger;
     readonly signal: AbortSignal;
     static readonly SLUG = "@rowdy";
     static readonly ERROR = "error";
     static readonly HTTP = "http";
-    static readonly API = "api";
     static readonly CRI = "cri";
     static readonly HEALTH = "health";
     static readonly PING = "ping";
@@ -370,42 +301,14 @@ declare class Rowdy {
     };
     readonly http: AxiosInstance;
     private _images;
-    private _registry;
     private _proxy?;
     constructor(log: Logger, signal: AbortSignal);
-    get Images(): IImageApi;
-    get Registry(): IRegistryApi;
+    get images(): IImageApi;
+    get registry(): Observable<TRegistry>;
     get proxy(): HttpProxy<Pipeline> | undefined;
     get environment(): Environment | undefined;
-    readonly routes: {
-        GET: ({
-            match: path_to_regexp.MatchFunction<never>;
-            handler: () => Observable<ApiSchema<Health$1["res"], ApiResponseStatus>>;
-        } | {
-            match: path_to_regexp.MatchFunction<{
-                image: string | string[];
-            }>;
-            handler: (req: Image["Req"], opts?: Image["Opts"]["GET"]) => Observable<ApiSchema<Image["Req"], Image["Res"]>>;
-        } | {
-            match: path_to_regexp.MatchFunction<{
-                registry?: string;
-                authorization?: string;
-            }>;
-            handler: (req?: Registry["Req"]) => Observable<ApiSchema<Registry["Req"], Registry["Res"]>>;
-        })[];
-        PUT: {
-            match: path_to_regexp.MatchFunction<{
-                image: string | string[];
-            }>;
-            handler: (req: Image["Req"], opts?: Image["Opts"]["PUT"]) => Observable<ApiSchema<Image["Req"], Image["Res"]>>;
-        }[];
-    };
     withProxy(proxy: HttpProxy<Pipeline>): this;
-    health(): Observable<ApiSchema<Health$1['res'], ApiResponseStatus>>;
     cri(proxy: HttpProxy<Pipeline>): Observable<GrpcResponse>;
-    api(): Observable<ApiSchema<unknown, ApiResponseStatus>>;
-    private notFound;
-    private badRequest;
 }
 
 declare const ABORT: AbortController;