@dagger.io/dagger 0.13.3 → 0.13.5

package/dist/api/utils.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLClient } from "graphql-request";
+import { QueryTree } from "./client.gen.js";
+/**
+ * Convert the queryTree into a GraphQL query
+ * @param q
+ * @returns
+ */
+export declare function buildQuery(q: QueryTree[]): string;
+/**
+ * Convert querytree into a Graphql query then compute it
+ * @param q | QueryTree[]
+ * @param client | GraphQLClient
+ * @returns
+ */
+export declare function computeQuery<T>(q: QueryTree[], client: GraphQLClient): Promise<T>;
+/**
+ * Return a Graphql query result flattened
+ * @param response any
+ * @returns
+ */
+export declare function queryFlatten<T>(response: any): T;
+/**
+ * Send a GraphQL document to the server
+ * return a flatten result
+ * @hidden
+ */
+export declare function compute<T>(query: string, client: GraphQLClient): Promise<T>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/api/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../api/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,aAAa,EAAE,MAAM,iBAAiB,CAAA;AASjE,OAAO,EAAY,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAkHrD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,MAAM,CAYjD;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,CAAC,EAClC,CAAC,EAAE,SAAS,EAAE,EACd,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,CAAC,CAAC,CAMZ;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,GAAG,GAAG,CAAC,CAuBhD;AAED;;;;GAIG;AACH,wBAAsB,OAAO,CAAC,CAAC,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,CAAC,CAAC,CA4CZ"}

package/dist/api/utils.js

@@ -0,0 +1,170 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ClientError, gql } from "graphql-request";
+import { GraphQLRequestError, TooManyNestedObjectsError, UnknownDaggerError, NotAwaitedRequestError, ExecError, } from "../common/errors/index.js";
+/**
+ * Format argument into GraphQL query format.
+ */
+function buildArgs(args) {
+    const metadata = args.__metadata || {};
+    // Remove unwanted quotes
+    const formatValue = (key, value) => {
+        // Special treatment for enumeration, they must be inserted without quotes
+        if (metadata[key]?.is_enum) {
+            return JSON.stringify(value).replace(/['"]+/g, "");
+        }
+        return JSON.stringify(value).replace(/\{"[a-zA-Z]+":|,"[a-zA-Z]+":/gi, (str) => {
+            return str.replace(/"/g, "");
+        });
+    };
+    if (args === undefined || args === null) {
+        return "";
+    }
+    const formattedArgs = Object.entries(args).reduce((acc, [key, value]) => {
+        // Ignore internal metadata key
+        if (key === "__metadata") {
+            return acc;
+        }
+        if (value !== undefined && value !== null) {
+            acc.push(`${key}: ${formatValue(key, value)}`);
+        }
+        return acc;
+    }, []);
+    if (formattedArgs.length === 0) {
+        return "";
+    }
+    return `(${formattedArgs})`;
+}
+/**
+ * Find QueryTree, convert them into GraphQl query
+ * then compute and return the result to the appropriate field
+ */
+async function computeNestedQuery(query, client) {
+    // Check if there is a nested queryTree to be executed
+    const isQueryTree = (value) => value["_queryTree"] !== undefined;
+    // Check if there is a nested array of queryTree to be executed
+    const isArrayQueryTree = (value) => value.every((v) => v instanceof Object && isQueryTree(v));
+    // Prepare query tree for final query by computing nested queries
+    // and building it with their results.
+    const computeQueryTree = async (value) => {
+        // Resolve sub queries if operation's args is a subquery
+        for (const op of value["_queryTree"]) {
+            await computeNestedQuery([op], client);
+        }
+        // push an id that will be used by the container
+        return buildQuery([
+            ...value["_queryTree"],
+            {
+                operation: "id",
+            },
+        ]);
+    };
+    // Remove all undefined args and assert args type
+    const queryToExec = query.filter((q) => !!q.args);
+    for (const q of queryToExec) {
+        await Promise.all(
+        // Compute nested query for single object
+        Object.entries(q.args).map(async ([key, value]) => {
+            if (value instanceof Object && isQueryTree(value)) {
+                // push an id that will be used by the container
+                const getQueryTree = await computeQueryTree(value);
+                q.args[key] = await compute(getQueryTree, client);
+            }
+            // Compute nested query for array of object
+            if (Array.isArray(value) && isArrayQueryTree(value)) {
+                const tmp = q.args[key];
+                for (let i = 0; i < value.length; i++) {
+                    // push an id that will be used by the container
+                    const getQueryTree = await computeQueryTree(value[i]);
+                    tmp[i] = await compute(getQueryTree, client);
+                }
+                q.args[key] = tmp;
+            }
+        }));
+    }
+}
+/**
+ * Convert the queryTree into a GraphQL query
+ * @param q
+ * @returns
+ */
+export function buildQuery(q) {
+    const query = q.reduce((acc, { operation, args }, i) => {
+        const qLen = q.length;
+        acc += ` ${operation} ${args ? `${buildArgs(args)}` : ""} ${qLen - 1 !== i ? "{" : "}".repeat(qLen - 1)}`;
+        return acc;
+    }, "");
+    return `{${query} }`;
+}
+/**
+ * Convert querytree into a Graphql query then compute it
+ * @param q | QueryTree[]
+ * @param client | GraphQLClient
+ * @returns
+ */
+export async function computeQuery(q, client) {
+    await computeNestedQuery(q, client);
+    const query = buildQuery(q);
+    return await compute(query, client);
+}
+/**
+ * Return a Graphql query result flattened
+ * @param response any
+ * @returns
+ */
+export function queryFlatten(response) {
+    // Recursion break condition
+    // If our response is not an object or an array we assume we reached the value
+    if (!(response instanceof Object) || Array.isArray(response)) {
+        return response;
+    }
+    const keys = Object.keys(response);
+    if (keys.length != 1) {
+        // Dagger is currently expecting to only return one value
+        // If the response is nested in a way were more than one object is nested inside throw an error
+        throw new TooManyNestedObjectsError("Too many nested objects inside graphql response", {
+            response: response,
+        });
+    }
+    const nestedKey = keys[0];
+    return queryFlatten(response[nestedKey]);
+}
+/**
+ * Send a GraphQL document to the server
+ * return a flatten result
+ * @hidden
+ */
+export async function compute(query, client) {
+    let computeQuery;
+    try {
+        computeQuery = await client.request(gql `
+      ${query}
+    `);
+    }
+    catch (e) {
+        if (e instanceof ClientError) {
+            const msg = e.response.errors?.[0]?.message ?? `API Error`;
+            const ext = e.response.errors?.[0]?.extensions;
+            if (ext?._type === "EXEC_ERROR") {
+                throw new ExecError(msg, {
+                    cmd: ext.cmd ?? [],
+                    exitCode: ext.exitCode ?? -1,
+                    stdout: ext.stdout ?? "",
+                    stderr: ext.stderr ?? "",
+                });
+            }
+            throw new GraphQLRequestError(msg, {
+                error: e,
+                cause: e,
+            });
+        }
+        // Looking for connection error in case the function has not been awaited.
+        if (e.errno === "ECONNREFUSED") {
+            throw new NotAwaitedRequestError("Encountered an error while requesting data via graphql through a synchronous call. Make sure the function called is awaited.", { cause: e });
+        }
+        // Just throw the unknown error
+        throw new UnknownDaggerError("Encountered an unknown error while requesting data via graphql", {
+            cause: e,
+        });
+    }
+    return queryFlatten(computeQuery);
+}

package/dist/common/errors/DaggerSDKError.d.ts

@@ -0,0 +1,32 @@
+import { ErrorCodes, ErrorNames } from "./errors-codes.js";
+export interface DaggerSDKErrorOptions {
+    cause?: Error;
+}
+/**
+ * The base error. Every other error inherits this error.
+ */
+export declare abstract class DaggerSDKError extends Error {
+    /**
+     * The name of the dagger error.
+     */
+    abstract readonly name: ErrorNames;
+    /**
+     * The dagger specific error code.
+     * Use this to identify dagger errors programmatically.
+     */
+    abstract readonly code: ErrorCodes;
+    /**
+     * The original error, which caused the DaggerSDKError.
+     */
+    cause?: Error;
+    protected constructor(message: string, options?: DaggerSDKErrorOptions);
+    /**
+     * @hidden
+     */
+    get [Symbol.toStringTag](): "GraphQLRequestError" | "UnknownDaggerError" | "TooManyNestedObjectsError" | "EngineSessionConnectParamsParseError" | "EngineSessionConnectionTimeoutError" | "EngineSessionError" | "InitEngineSessionBinaryError" | "DockerImageRefValidationError" | "NotAwaitedRequestError" | "ExecError";
+    /**
+     * Pretty prints the error
+     */
+    printStackTrace(): void;
+}
+//# sourceMappingURL=DaggerSDKError.d.ts.map

package/dist/common/errors/DaggerSDKError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DaggerSDKError.d.ts","sourceRoot":"","sources":["../../../common/errors/DaggerSDKError.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAE1D,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,KAAK,CAAA;CACd;AAED;;GAEG;AACH,8BAAsB,cAAe,SAAQ,KAAK;IAChD;;OAEG;IACH,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IAElC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IAElC;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,CAAA;IAEb,SAAS,aAAa,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB;IAKtE;;OAEG;IACH,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,mSAEvB;IAED;;OAEG;IACH,eAAe;CAGhB"}

package/dist/common/errors/DaggerSDKError.js

@@ -0,0 +1,26 @@
+import { log } from "../utils.js";
+/**
+ * The base error. Every other error inherits this error.
+ */
+export class DaggerSDKError extends Error {
+    /**
+     * The original error, which caused the DaggerSDKError.
+     */
+    cause;
+    constructor(message, options) {
+        super(message);
+        this.cause = options?.cause;
+    }
+    /**
+     * @hidden
+     */
+    get [Symbol.toStringTag]() {
+        return this.name;
+    }
+    /**
+     * Pretty prints the error
+     */
+    printStackTrace() {
+        log(this.stack);
+    }
+}

package/dist/common/errors/DockerImageRefValidationError.d.ts

@@ -0,0 +1,22 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.js";
+interface DockerImageRefValidationErrorOptions extends DaggerSDKErrorOptions {
+    ref: string;
+}
+/**
+ *  This error is thrown if the passed image reference does not pass validation and is not compliant with the
+ *  DockerImage constructor.
+ */
+export declare class DockerImageRefValidationError extends DaggerSDKError {
+    name: "DockerImageRefValidationError";
+    code: "D107";
+    /**
+     *  The docker image reference, which caused the error.
+     */
+    ref: string;
+    /**
+     *  @hidden
+     */
+    constructor(message: string, options: DockerImageRefValidationErrorOptions);
+}
+export {};
+//# sourceMappingURL=DockerImageRefValidationError.d.ts.map

package/dist/common/errors/DockerImageRefValidationError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DockerImageRefValidationError.d.ts","sourceRoot":"","sources":["../../../common/errors/DockerImageRefValidationError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAG3E,UAAU,oCAAqC,SAAQ,qBAAqB;IAC1E,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;;GAGG;AACH,qBAAa,6BAA8B,SAAQ,cAAc;IAC/D,IAAI,kCAA4C;IAChD,IAAI,SAA4C;IAEhD;;OAEG;IACH,GAAG,EAAE,MAAM,CAAA;IAEX;;OAEG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,oCAAoC;CAI3E"}

package/dist/common/errors/DockerImageRefValidationError.js

@@ -0,0 +1,21 @@
+import { DaggerSDKError } from "./DaggerSDKError.js";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
+/**
+ *  This error is thrown if the passed image reference does not pass validation and is not compliant with the
+ *  DockerImage constructor.
+ */
+export class DockerImageRefValidationError extends DaggerSDKError {
+    name = ERROR_NAMES.DockerImageRefValidationError;
+    code = ERROR_CODES.DockerImageRefValidationError;
+    /**
+     *  The docker image reference, which caused the error.
+     */
+    ref;
+    /**
+     *  @hidden
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.ref = options?.ref;
+    }
+}

package/dist/common/errors/EngineSessionConnectParamsParseError.d.ts

@@ -0,0 +1,21 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.js";
+interface EngineSessionConnectParamsParseErrorOptions extends DaggerSDKErrorOptions {
+    parsedLine: string;
+}
+/**
+ * This error is thrown if the EngineSession does not manage to parse the required connection parameters from the session binary
+ */
+export declare class EngineSessionConnectParamsParseError extends DaggerSDKError {
+    name: "EngineSessionConnectParamsParseError";
+    code: "D103";
+    /**
+     *  the line, which caused the error during parsing, if the error was caused because of parsing.
+     */
+    parsedLine: string;
+    /**
+     * @hidden
+     */
+    constructor(message: string, options: EngineSessionConnectParamsParseErrorOptions);
+}
+export {};
+//# sourceMappingURL=EngineSessionConnectParamsParseError.d.ts.map

package/dist/common/errors/EngineSessionConnectParamsParseError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineSessionConnectParamsParseError.d.ts","sourceRoot":"","sources":["../../../common/errors/EngineSessionConnectParamsParseError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAG3E,UAAU,2CACR,SAAQ,qBAAqB;IAC7B,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,qBAAa,oCAAqC,SAAQ,cAAc;IACtE,IAAI,yCAAmD;IACvD,IAAI,SAAmD;IAEvD;;OAEG;IACH,UAAU,EAAE,MAAM,CAAA;IAElB;;OAEG;gBAED,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,2CAA2C;CAKvD"}

package/dist/common/errors/EngineSessionConnectParamsParseError.js

@@ -0,0 +1,20 @@
+import { DaggerSDKError } from "./DaggerSDKError.js";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
+/**
+ * This error is thrown if the EngineSession does not manage to parse the required connection parameters from the session binary
+ */
+export class EngineSessionConnectParamsParseError extends DaggerSDKError {
+    name = ERROR_NAMES.EngineSessionConnectParamsParseError;
+    code = ERROR_CODES.EngineSessionConnectParamsParseError;
+    /**
+     *  the line, which caused the error during parsing, if the error was caused because of parsing.
+     */
+    parsedLine;
+    /**
+     * @hidden
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.parsedLine = options.parsedLine;
+    }
+}

package/dist/common/errors/EngineSessionConnectionTimeoutError.d.ts

@@ -0,0 +1,21 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.js";
+interface EngineSessionConnectionTimeoutErrorOptions extends DaggerSDKErrorOptions {
+    timeOutDuration: number;
+}
+/**
+ * This error is thrown if the EngineSession does not manage to parse the required port successfully because the sessions connection timed out.
+ */
+export declare class EngineSessionConnectionTimeoutError extends DaggerSDKError {
+    name: "EngineSessionConnectionTimeoutError";
+    code: "D104";
+    /**
+     * The duration until the timeout occurred in ms.
+     */
+    timeOutDuration: number;
+    /**
+     * @hidden
+     */
+    constructor(message: string, options: EngineSessionConnectionTimeoutErrorOptions);
+}
+export {};
+//# sourceMappingURL=EngineSessionConnectionTimeoutError.d.ts.map

package/dist/common/errors/EngineSessionConnectionTimeoutError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineSessionConnectionTimeoutError.d.ts","sourceRoot":"","sources":["../../../common/errors/EngineSessionConnectionTimeoutError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAG3E,UAAU,0CACR,SAAQ,qBAAqB;IAC7B,eAAe,EAAE,MAAM,CAAA;CACxB;AAED;;GAEG;AACH,qBAAa,mCAAoC,SAAQ,cAAc;IACrE,IAAI,wCAAkD;IACtD,IAAI,SAAkD;IAEtD;;OAEG;IACH,eAAe,EAAE,MAAM,CAAA;IAEvB;;OAEG;gBAED,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,0CAA0C;CAKtD"}

package/dist/common/errors/EngineSessionConnectionTimeoutError.js

@@ -0,0 +1,20 @@
+import { DaggerSDKError } from "./DaggerSDKError.js";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
+/**
+ * This error is thrown if the EngineSession does not manage to parse the required port successfully because the sessions connection timed out.
+ */
+export class EngineSessionConnectionTimeoutError extends DaggerSDKError {
+    name = ERROR_NAMES.EngineSessionConnectionTimeoutError;
+    code = ERROR_CODES.EngineSessionConnectionTimeoutError;
+    /**
+     * The duration until the timeout occurred in ms.
+     */
+    timeOutDuration;
+    /**
+     * @hidden
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.timeOutDuration = options.timeOutDuration;
+    }
+}

package/dist/common/errors/EngineSessionErrorOptions.d.ts

@@ -0,0 +1,16 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.js";
+type EngineSessionErrorOptions = DaggerSDKErrorOptions;
+/**
+ * This error is thrown if the EngineSession does not manage to parse the required port successfully because a EOF is read before any valid port.
+ * This usually happens if no connection can be established.
+ */
+export declare class EngineSessionError extends DaggerSDKError {
+    name: "EngineSessionError";
+    code: "D105";
+    /**
+     * @hidden
+     */
+    constructor(message: string, options?: EngineSessionErrorOptions);
+}
+export {};
+//# sourceMappingURL=EngineSessionErrorOptions.d.ts.map

package/dist/common/errors/EngineSessionErrorOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineSessionErrorOptions.d.ts","sourceRoot":"","sources":["../../../common/errors/EngineSessionErrorOptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAG3E,KAAK,yBAAyB,GAAG,qBAAqB,CAAA;AAEtD;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD,IAAI,uBAAiC;IACrC,IAAI,SAAiC;IAErC;;OAEG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,yBAAyB;CAGjE"}

package/dist/common/errors/EngineSessionErrorOptions.js

@@ -0,0 +1,16 @@
+import { DaggerSDKError } from "./DaggerSDKError.js";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
+/**
+ * This error is thrown if the EngineSession does not manage to parse the required port successfully because a EOF is read before any valid port.
+ * This usually happens if no connection can be established.
+ */
+export class EngineSessionError extends DaggerSDKError {
+    name = ERROR_NAMES.EngineSessionError;
+    code = ERROR_CODES.EngineSessionError;
+    /**
+     * @hidden
+     */
+    constructor(message, options) {
+        super(message, options);
+    }
+}

package/dist/common/errors/ExecError.d.ts

@@ -0,0 +1,37 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.js";
+interface ExecErrorOptions extends DaggerSDKErrorOptions {
+    cmd: string[];
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+/**
+ *  API error from an exec operation in a pipeline.
+ */
+export declare class ExecError extends DaggerSDKError {
+    name: "ExecError";
+    code: "D109";
+    /**
+     *  The command that caused the error.
+     */
+    cmd: string[];
+    /**
+     *  The exit code of the command.
+     */
+    exitCode: number;
+    /**
+     * The stdout of the command.
+     */
+    stdout: string;
+    /**
+     * The stderr of the command.
+     */
+    stderr: string;
+    /**
+     *  @hidden
+     */
+    constructor(message: string, options: ExecErrorOptions);
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=ExecError.d.ts.map

package/dist/common/errors/ExecError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExecError.d.ts","sourceRoot":"","sources":["../../../common/errors/ExecError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAG3E,UAAU,gBAAiB,SAAQ,qBAAqB;IACtD,GAAG,EAAE,MAAM,EAAE,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,qBAAa,SAAU,SAAQ,cAAc;IAC3C,IAAI,cAAwB;IAC5B,IAAI,SAAwB;IAE5B;;OAEG;IACH,GAAG,EAAE,MAAM,EAAE,CAAA;IAEb;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IAEd;;OAEG;IACH,MAAM,EAAE,MAAM,CAAA;IAEd;;OAEG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB;IAQtD,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/common/errors/ExecError.js

@@ -0,0 +1,38 @@
+import { DaggerSDKError } from "./DaggerSDKError.js";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
+/**
+ *  API error from an exec operation in a pipeline.
+ */
+export class ExecError extends DaggerSDKError {
+    name = ERROR_NAMES.ExecError;
+    code = ERROR_CODES.ExecError;
+    /**
+     *  The command that caused the error.
+     */
+    cmd;
+    /**
+     *  The exit code of the command.
+     */
+    exitCode;
+    /**
+     * The stdout of the command.
+     */
+    stdout;
+    /**
+     * The stderr of the command.
+     */
+    stderr;
+    /**
+     *  @hidden
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.cmd = options.cmd;
+        this.exitCode = options.exitCode;
+        this.stdout = options.stdout;
+        this.stderr = options.stderr;
+    }
+    toString() {
+        return `${super.toString()}\nStdout:\n${this.stdout}\nStderr:\n${this.stderr}`;
+    }
+}

package/dist/common/errors/GraphQLRequestError.d.ts

@@ -0,0 +1,26 @@
+import { ClientError } from "graphql-request";
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.js";
+interface GraphQLRequestErrorOptions extends DaggerSDKErrorOptions {
+    error: ClientError;
+}
+/**
+ *  This error originates from the dagger engine. It means that some error was thrown and sent back via GraphQL.
+ */
+export declare class GraphQLRequestError extends DaggerSDKError {
+    name: "GraphQLRequestError";
+    code: "D100";
+    /**
+     *  The query and variables, which caused the error.
+     */
+    requestContext: ClientError["request"];
+    /**
+     *  the GraphQL response containing the error.
+     */
+    response: ClientError["response"];
+    /**
+     *  @hidden
+     */
+    constructor(message: string, options: GraphQLRequestErrorOptions);
+}
+export {};
+//# sourceMappingURL=GraphQLRequestError.d.ts.map

package/dist/common/errors/GraphQLRequestError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphQLRequestError.d.ts","sourceRoot":"","sources":["../../../common/errors/GraphQLRequestError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE7C,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAG3E,UAAU,0BAA2B,SAAQ,qBAAqB;IAChE,KAAK,EAAE,WAAW,CAAA;CACnB;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,IAAI,wBAAkC;IACtC,IAAI,SAAkC;IAEtC;;OAEG;IACH,cAAc,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;IAEtC;;OAEG;IACH,QAAQ,EAAE,WAAW,CAAC,UAAU,CAAC,CAAA;IAEjC;;OAEG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,0BAA0B;CAKjE"}

package/dist/common/errors/GraphQLRequestError.js

@@ -0,0 +1,25 @@
+import { DaggerSDKError } from "./DaggerSDKError.js";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
+/**
+ *  This error originates from the dagger engine. It means that some error was thrown and sent back via GraphQL.
+ */
+export class GraphQLRequestError extends DaggerSDKError {
+    name = ERROR_NAMES.GraphQLRequestError;
+    code = ERROR_CODES.GraphQLRequestError;
+    /**
+     *  The query and variables, which caused the error.
+     */
+    requestContext;
+    /**
+     *  the GraphQL response containing the error.
+     */
+    response;
+    /**
+     *  @hidden
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.requestContext = options.error.request;
+        this.response = options.error.response;
+    }
+}

package/dist/common/errors/InitEngineSessionBinaryError.d.ts

@@ -0,0 +1,13 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.js";
+/**
+ *  This error is thrown if the dagger binary cannot be copied from the dagger docker image and copied to the local host.
+ */
+export declare class InitEngineSessionBinaryError extends DaggerSDKError {
+    name: "InitEngineSessionBinaryError";
+    code: "D106";
+    /**
+     *  @hidden
+     */
+    constructor(message: string, options?: DaggerSDKErrorOptions);
+}
+//# sourceMappingURL=InitEngineSessionBinaryError.d.ts.map

package/dist/common/errors/InitEngineSessionBinaryError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InitEngineSessionBinaryError.d.ts","sourceRoot":"","sources":["../../../common/errors/InitEngineSessionBinaryError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAG3E;;GAEG;AACH,qBAAa,4BAA6B,SAAQ,cAAc;IAC9D,IAAI,iCAA2C;IAC/C,IAAI,SAA2C;IAE/C;;OAEG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB;CAG7D"}

package/dist/common/errors/InitEngineSessionBinaryError.js

@@ -0,0 +1,15 @@
+import { DaggerSDKError } from "./DaggerSDKError.js";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
+/**
+ *  This error is thrown if the dagger binary cannot be copied from the dagger docker image and copied to the local host.
+ */
+export class InitEngineSessionBinaryError extends DaggerSDKError {
+    name = ERROR_NAMES.InitEngineSessionBinaryError;
+    code = ERROR_CODES.InitEngineSessionBinaryError;
+    /**
+     *  @hidden
+     */
+    constructor(message, options) {
+        super(message, options);
+    }
+}

package/dist/common/errors/NotAwaitedRequestError.d.ts

@@ -0,0 +1,13 @@
+import { DaggerSDKError, DaggerSDKErrorOptions } from "./DaggerSDKError.js";
+/**
+ * This error is thrown when the compute function isn't awaited.
+ */
+export declare class NotAwaitedRequestError extends DaggerSDKError {
+    name: "NotAwaitedRequestError";
+    code: "D108";
+    /**
+     * @hidden
+     */
+    constructor(message: string, options?: DaggerSDKErrorOptions);
+}
+//# sourceMappingURL=NotAwaitedRequestError.d.ts.map

package/dist/common/errors/NotAwaitedRequestError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotAwaitedRequestError.d.ts","sourceRoot":"","sources":["../../../common/errors/NotAwaitedRequestError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAG3E;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,cAAc;IACxD,IAAI,2BAAqC;IACzC,IAAI,SAAqC;IAEzC;;OAEG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB;CAG7D"}

package/dist/common/errors/NotAwaitedRequestError.js

@@ -0,0 +1,15 @@
+import { DaggerSDKError } from "./DaggerSDKError.js";
+import { ERROR_CODES, ERROR_NAMES } from "./errors-codes.js";
+/**
+ * This error is thrown when the compute function isn't awaited.
+ */
+export class NotAwaitedRequestError extends DaggerSDKError {
+    name = ERROR_NAMES.NotAwaitedRequestError;
+    code = ERROR_CODES.NotAwaitedRequestError;
+    /**
+     * @hidden
+     */
+    constructor(message, options) {
+        super(message, options);
+    }
+}