drej 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,124 @@
+import { StepDef, Predicate, IStorageAdapter, SnapshotConfig, LedgerEntry } from '@drej/core';
+export { IStorageAdapter, LedgerEvent, SnapshotConfig, StepDef } from '@drej/core';
+import { ImageSpec, Resources, CreateSandboxOptions, Sandbox, ListSandboxesOptions, Snapshot, ListSnapshotsOptions, DiagnosticLog, DiagnosticEvent } from '@drej/opensandbox';
+export { CreateSandboxOptions, DiagnosticEvent, DiagnosticLog, ImageAuth, ImageSpec, ListSandboxesOptions, ListSnapshotsOptions, Resources, Sandbox, SandboxState, SandboxStatus, Snapshot, SnapshotState } from '@drej/opensandbox';
+
+type LoopItem = {
+    toString(): string;
+};
+type SandboxOpts = {
+    image?: ImageSpec;
+    snapshotId?: string;
+    timeout?: number;
+    entrypoint?: string[];
+    env?: Record<string, string>;
+    metadata?: Record<string, string>;
+    resourceLimits?: Resources;
+};
+type ForEachOpts = {
+    concurrency?: number;
+    as?: string;
+};
+type ForEachSource = unknown[] | {
+    from: string;
+};
+type ForEachCallback = (s: SandboxStepBuilder, item: LoopItem) => SandboxStepBuilder | string;
+declare class SandboxStepBuilder {
+    protected _steps: StepDef[];
+    exec(command: string, opts?: {
+        cwd?: string;
+        envs?: Record<string, string>;
+    }): this;
+    writeFile(path: string, content: string, encoding?: "utf8" | "base64"): this;
+    retry(maxAttempts: number, fn: (s: SandboxStepBuilder) => SandboxStepBuilder, opts?: {
+        delayMs?: number;
+        backoff?: "fixed" | "exponential";
+    }): this;
+    forEach(source: ForEachSource, fn: ForEachCallback): this;
+    forEach(source: ForEachSource, opts: ForEachOpts, fn: ForEachCallback): this;
+    when(condition: Predicate, thenFn: (s: SandboxStepBuilder) => SandboxStepBuilder, elseFn?: (s: SandboxStepBuilder) => SandboxStepBuilder): this;
+    parallel(fn: (p: SandboxParallelBuilder) => SandboxParallelBuilder): this;
+    build(): StepDef[];
+}
+declare class SandboxParallelBuilder {
+    private _branches;
+    branch(fn: (s: SandboxStepBuilder) => SandboxStepBuilder): this;
+    build(): StepDef[];
+}
+declare class WorkflowParallelBuilder {
+    private _branches;
+    sandbox(opts: SandboxOpts, fn: (s: SandboxStepBuilder) => SandboxStepBuilder): this;
+    branch(fn: (s: SandboxStepBuilder) => SandboxStepBuilder): this;
+    build(): StepDef[];
+}
+declare class WorkflowBuilder {
+    private _name;
+    private _steps;
+    constructor(_name: string);
+    sandbox(opts: SandboxOpts, fn: (s: SandboxStepBuilder) => SandboxStepBuilder): this;
+    parallel(fn: (p: WorkflowParallelBuilder) => WorkflowParallelBuilder): this;
+    build(): {
+        name: string;
+        steps: StepDef[];
+    };
+}
+declare function workflow(name: string): WorkflowBuilder;
+
+declare class DrejError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+interface DrejClientOptions {
+    /** OpenSandbox server URL */
+    baseUrl: string;
+    /** OpenSandbox API key (empty string for local dev) */
+    apiKey?: string;
+    /** Storage adapter for persisting workflow events. Use @drej/sqlite, @drej/postgres, or implement IStorageAdapter. */
+    adapter: IStorageAdapter;
+}
+interface RunOptions {
+    snapshotConfig?: SnapshotConfig;
+}
+type WorkflowEvent = LedgerEntry;
+declare class WorkflowRun implements AsyncIterable<WorkflowEvent> {
+    readonly name: string;
+    readonly id: string;
+    private readonly _events;
+    constructor(name: string, id: string, _events: AsyncGenerator<WorkflowEvent>);
+    [Symbol.asyncIterator](): AsyncIterator<WorkflowEvent>;
+}
+declare class DrejClient {
+    private readonly control;
+    private readonly adapter;
+    constructor(options: DrejClientOptions);
+    /** Call once before first use when using a DB-backed adapter. */
+    connect(): Promise<void>;
+    /** Releases adapter resources (e.g. closes DB connection pool). */
+    close(): Promise<void>;
+    createSandbox(options: CreateSandboxOptions): Promise<Sandbox>;
+    listSandboxes(options?: ListSandboxesOptions): Promise<Sandbox[]>;
+    getSandbox(id: string): Promise<Sandbox>;
+    deleteSandbox(id: string): Promise<void>;
+    pauseSandbox(id: string): Promise<void>;
+    resumeSandbox(id: string): Promise<void>;
+    renewSandbox(id: string): Promise<void>;
+    waitForRunning(id: string, options?: {
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+    }): Promise<Sandbox>;
+    createSnapshot(sandboxId: string): Promise<Snapshot>;
+    listSnapshots(options?: ListSnapshotsOptions): Promise<Snapshot[]>;
+    getSnapshot(id: string): Promise<Snapshot>;
+    deleteSnapshot(id: string): Promise<void>;
+    getDiagnosticLogs(sandboxId: string): Promise<DiagnosticLog[]>;
+    getDiagnosticEvents(sandboxId: string): Promise<DiagnosticEvent[]>;
+    run(w: WorkflowBuilder, options?: RunOptions): Promise<WorkflowRun>;
+    replayFromSnapshot(name: string, runId: string, w: WorkflowBuilder): Promise<WorkflowRun>;
+    resumeRun(name: string, runId: string, w: WorkflowBuilder): Promise<WorkflowRun>;
+    listRuns(workflowName: string): Promise<string[]>;
+    getRunLedger(workflowName: string, runId: string): Promise<WorkflowEvent[]>;
+    private _execute;
+    private _makeStream;
+}
+
+export { DrejClient, type DrejClientOptions, DrejError, type LoopItem, type RunOptions, type SandboxOpts, SandboxStepBuilder, WorkflowBuilder, type WorkflowEvent, WorkflowRun, workflow };