@scaffoldly/rowdy 0.0.2-1-beta.20251015163349.e61c10e → 0.0.2-1-beta.20251016225027.95deb3d

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import { Observable, ReplaySubject } from 'rxjs';
+import * as path_to_regexp from 'path-to-regexp';
 import { PassThrough, Readable, Writable } from 'stream';
-import { AxiosHeaders, AxiosResponseHeaders } from 'axios';
+import { AxiosHeaders, AxiosResponseHeaders, AxiosInstance } from 'axios';
 import { Agent } from 'https';
 import { APIGatewayProxyEventV2 } from 'aws-lambda';
 
@@ -34,29 +35,8 @@ type CheckResult = {
     reason?: string | undefined;
 };
 
-type Secrets = Record<string, string>;
-declare class Environment implements ILoggable {
-    readonly log: Logger;
-    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;
+    readonly environment: Environment;
     private _createdAt;
     constructor(environment: Environment);
     get log(): Logger;
@@ -120,55 +100,45 @@ declare class Result<P extends Pipeline> implements ILoggable {
     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();
-    get userAgent(): string;
-    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;
+type Secrets = Record<string, string>;
+type Args = {
+    debug: boolean;
+    trace: boolean;
+    routes: string;
+    registry: string | undefined;
+    '--'?: string[];
+};
+declare class Environment implements ILoggable {
+    readonly log: Logger;
+    abort: AbortController;
+    readonly signal: AbortSignal;
+    readonly bin: string | undefined;
+    private _pipelines;
+    private subscriptions;
+    private _routes;
+    private _command?;
+    private _env;
+    private _args;
+    constructor(log: Logger);
+    get opts(): Args;
+    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 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 IImageApi = {
+    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']>>;
+};
+interface IRegistryApi {
+    getRegistry(req: Registry['Req']): Observable<ApiSchema<Registry['Req'], Registry['Res']>>;
+}
 type ApiVersion = 'rowdy.run/v1alpha1';
-type ApiKind = 'Routes' | 'NotFound' | Health$1['kind'] | Image['kind'];
+type ApiKind = 'Routes' | 'NotFound' | Health$1['kind'] | Image['kind'] | Registry['kind'];
 type ApiSchema<Spec, Status> = {
     apiVersion: ApiVersion;
     kind: ApiKind;
@@ -190,67 +160,71 @@ type Health$1 = {
         healthy: boolean;
     };
 };
-type Ref = Partial<{
-    mediaType: string;
-    size: number;
-    digest: string;
-    annotations: Record<string, string>;
-}>;
-type Config = Ref;
-type Layer = Ref;
-type Manifest = Ref & Partial<{
-    platform: Partial<{
-        architecture: string;
-        os: string;
-    }>;
-}>;
-type ImageManifest = Partial<{
-    schemaVersion: number;
-    mediaType: 'application/vnd.oci.image.manifest.v1+json' | 'application/vnd.docker.distribution.manifest.v2+json';
-    config: Config;
-    layers: Layer[];
-}>;
-type IndexManifest = Partial<{
-    schemaVersion: number;
-    mediaType: 'application/vnd.oci.image.index.v1+json' | 'application/vnd.docker.distribution.manifest.list.v2+json';
-    manifests: Manifest[];
-}>;
+type Registry = {
+    kind: 'Registry';
+    Req: {
+        registry?: string;
+        authorization?: string;
+    };
+    Res: ApiResponseStatus & {
+        registry: string;
+        authorization: string;
+    };
+};
 type Image = {
     kind: 'Image';
-    req: {
+    Req: {
         image: string | string[];
     };
-    opts: {
-        authorization?: string | undefined;
+    Opts: {
+        GET: {
+            authorization?: string;
+        };
+        PUT: Image['Opts']['GET'] & {
+            registry?: string;
+        };
     };
-    res: ApiResponseStatus & {
+    Res: ApiResponseStatus & {
         registry: string;
         namespace: string;
         name: string;
         reference: string;
         tags: string[];
-        index: IndexManifest;
-        images: Record<string, ImageManifest>;
-        blobs: (Ref & {
+        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: Partial<{
+            schemaVersion: number;
+            mediaType: 'application/vnd.oci.image.index.v1+json' | 'application/vnd.docker.distribution.manifest.list.v2+json';
+            manifests: Image['External']['Manifest'][];
+        }>;
+        ImageManifest: 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'][];
+        }>;
+    };
 };
-declare class Api {
-    private log;
-    static readonly SLUG = "@rowdy";
-    private proxy?;
-    private axios;
-    constructor(log: Logger);
-    private routes;
-    withProxy(proxy: HttpProxy<Pipeline>): this;
-    health(): Observable<ApiSchema<Health$1['res'], ApiResponseStatus>>;
-    image(req: Image['req'], opts?: Image['opts']): Observable<ApiSchema<Image['req'], Image['res']>>;
-    handle(): Observable<ApiSchema<unknown, ApiResponseStatus>>;
-    private handler;
-    private notFound;
-}
 
 type RoutePaths = {
     [key: string]: string | undefined;
@@ -317,6 +291,95 @@ declare class Routes implements IRoutes, ILoggable {
     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();
+    get userAgent(): string;
+    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;
+}
+
+declare class Rowdy {
+    readonly log: Logger;
+    static readonly SLUG = "@rowdy";
+    readonly http: AxiosInstance;
+    private _images;
+    private _registry;
+    private _proxy?;
+    constructor(log: Logger);
+    get Images(): IImageApi;
+    get Registry(): IRegistryApi;
+    get proxy(): HttpProxy<Pipeline>;
+    get environment(): Environment;
+    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>>;
+    handle(): Observable<ApiSchema<unknown, ApiResponseStatus>>;
+    private handler;
+    private notFound;
+}
+
 declare const ABORT: AbortController;
 
-export { ABORT, Api, Logger, Routes, URI };
+export { ABORT, Logger, Routes, Rowdy, URI };