@dagger.io/dagger 0.0.1-0

package/dist/src/common/errors/errors-codes.d.ts

@@ -0,0 +1,55 @@
+export declare const ERROR_CODES: {
+    /**
+     * {@link GraphQLRequestError}
+     */
+    readonly GraphQLRequestError: "D100";
+    /**
+     * {@link UnknownDaggerError}
+     */
+    readonly UnknownDaggerError: "D101";
+    /**
+     * {@link TooManyNestedObjectsError}
+     */
+    readonly TooManyNestedObjectsError: "D102";
+    /**
+     * {@link EngineSessionConnectParamsParseError}
+     */
+    readonly EngineSessionConnectParamsParseError: "D103";
+    /**
+     * {@link EngineSessionConnectionTimeoutError}
+     */
+    readonly EngineSessionConnectionTimeoutError: "D104";
+    /**
+     * {@link EngineSessionError}
+     */
+    readonly EngineSessionError: "D105";
+    /**
+     * {@link InitEngineSessionBinaryError}
+     */
+    readonly InitEngineSessionBinaryError: "D106";
+    /**
+     * {@link DockerImageRefValidationError}
+     */
+    readonly DockerImageRefValidationError: "D107";
+    /**
+     * {@link NotAwaitedRequestError}
+     */
+    readonly NotAwaitedRequestError: "D108";
+    /**
+     * (@link ExecError}
+     */
+    readonly ExecError: "D109";
+    /**
+     * {@link IntrospectionError}
+     */
+    readonly IntrospectionError: "D110";
+};
+type ErrorCodesType = typeof ERROR_CODES;
+export type ErrorNames = keyof ErrorCodesType;
+export type ErrorCodes = ErrorCodesType[ErrorNames];
+type ErrorNamesMap = {
+    readonly [Key in ErrorNames]: Key;
+};
+export declare const ERROR_NAMES: ErrorNamesMap;
+export {};
+//# sourceMappingURL=errors-codes.d.ts.map

package/dist/src/common/errors/errors-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors-codes.d.ts","sourceRoot":"","sources":["../../../../src/common/errors/errors-codes.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;IACtB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;CAEK,CAAA;AAEV,KAAK,cAAc,GAAG,OAAO,WAAW,CAAA;AACxC,MAAM,MAAM,UAAU,GAAG,MAAM,cAAc,CAAA;AAC7C,MAAM,MAAM,UAAU,GAAG,cAAc,CAAC,UAAU,CAAC,CAAA;AAEnD,KAAK,aAAa,GAAG;IAAE,QAAQ,EAAE,GAAG,IAAI,UAAU,GAAG,GAAG;CAAE,CAAA;AAC1D,eAAO,MAAM,WAAW,EAAE,aAKzB,CAAA"}

package/dist/src/common/errors/errors-codes.js

@@ -0,0 +1,47 @@
+export const ERROR_CODES = {
+    /**
+     * {@link GraphQLRequestError}
+     */
+    GraphQLRequestError: "D100",
+    /**
+     * {@link UnknownDaggerError}
+     */
+    UnknownDaggerError: "D101",
+    /**
+     * {@link TooManyNestedObjectsError}
+     */
+    TooManyNestedObjectsError: "D102",
+    /**
+     * {@link EngineSessionConnectParamsParseError}
+     */
+    EngineSessionConnectParamsParseError: "D103",
+    /**
+     * {@link EngineSessionConnectionTimeoutError}
+     */
+    EngineSessionConnectionTimeoutError: "D104",
+    /**
+     * {@link EngineSessionError}
+     */
+    EngineSessionError: "D105",
+    /**
+     * {@link InitEngineSessionBinaryError}
+     */
+    InitEngineSessionBinaryError: "D106",
+    /**
+     * {@link DockerImageRefValidationError}
+     */
+    DockerImageRefValidationError: "D107",
+    /**
+     * {@link NotAwaitedRequestError}
+     */
+    NotAwaitedRequestError: "D108",
+    /**
+     * (@link ExecError}
+     */
+    ExecError: "D109",
+    /**
+     * {@link IntrospectionError}
+     */
+    IntrospectionError: "D110",
+};
+export const ERROR_NAMES = Object.keys(ERROR_CODES).reduce((obj, item) => ({ ...obj, [item]: item }), {});

package/dist/src/common/errors/index.d.ts

@@ -0,0 +1,15 @@
+export { DaggerSDKError } from "./DaggerSDKError.js";
+export { UnknownDaggerError } from "./UnknownDaggerError.js";
+export { DockerImageRefValidationError } from "./DockerImageRefValidationError.js";
+export { EngineSessionConnectParamsParseError } from "./EngineSessionConnectParamsParseError.js";
+export { ExecError } from "./ExecError.js";
+export { GraphQLRequestError } from "./GraphQLRequestError.js";
+export { InitEngineSessionBinaryError } from "./InitEngineSessionBinaryError.js";
+export { TooManyNestedObjectsError } from "./TooManyNestedObjectsError.js";
+export { EngineSessionError } from "./EngineSessionErrorOptions.js";
+export { EngineSessionConnectionTimeoutError } from "./EngineSessionConnectionTimeoutError.js";
+export { NotAwaitedRequestError } from "./NotAwaitedRequestError.js";
+export { FunctionNotFound } from "./FunctionNotFound.js";
+export { IntrospectionError } from "./IntrospectionError.js";
+export { ERROR_CODES } from "./errors-codes.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/common/errors/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/common/errors/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAA;AAClF,OAAO,EAAE,oCAAoC,EAAE,MAAM,2CAA2C,CAAA;AAChG,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAA;AAChF,OAAO,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AACnE,OAAO,EAAE,mCAAmC,EAAE,MAAM,0CAA0C,CAAA;AAC9F,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/src/common/errors/index.js

@@ -0,0 +1,14 @@
+export { DaggerSDKError } from "./DaggerSDKError.js";
+export { UnknownDaggerError } from "./UnknownDaggerError.js";
+export { DockerImageRefValidationError } from "./DockerImageRefValidationError.js";
+export { EngineSessionConnectParamsParseError } from "./EngineSessionConnectParamsParseError.js";
+export { ExecError } from "./ExecError.js";
+export { GraphQLRequestError } from "./GraphQLRequestError.js";
+export { InitEngineSessionBinaryError } from "./InitEngineSessionBinaryError.js";
+export { TooManyNestedObjectsError } from "./TooManyNestedObjectsError.js";
+export { EngineSessionError } from "./EngineSessionErrorOptions.js";
+export { EngineSessionConnectionTimeoutError } from "./EngineSessionConnectionTimeoutError.js";
+export { NotAwaitedRequestError } from "./NotAwaitedRequestError.js";
+export { FunctionNotFound } from "./FunctionNotFound.js";
+export { IntrospectionError } from "./IntrospectionError.js";
+export { ERROR_CODES } from "./errors-codes.js";

package/dist/src/common/graphql/client.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLClient } from "graphql-request";
+export declare function createGQLClient(port: number, token: string): GraphQLClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/src/common/graphql/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/common/graphql/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAuD/C,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CAsB1E"}

package/dist/src/common/graphql/client.js

@@ -0,0 +1,58 @@
+import * as opentelemetry from "@opentelemetry/api";
+import { GraphQLClient } from "graphql-request";
+import nodeFetch from "node-fetch";
+import { isDeno } from "../utils.js";
+const createFetchWithTimeout = (timeout) => async (input, init) => {
+    if (init?.signal) {
+        throw new Error("Internal error: could not create fetch client with timeout");
+    }
+    const controller = new AbortController();
+    const timerId = setTimeout(() => {
+        controller.abort();
+    }, timeout);
+    try {
+        // Edge case for Deno that doesn't work as expected with node-fetch and would
+        // rather rely on its native fetch implementation
+        // See: https://github.com/dagger/dagger/issues/10546
+        if (isDeno()) {
+            return await fetch(input, {
+                ...init,
+                signal: controller.signal,
+            });
+        }
+        return (await nodeFetch(input, {
+            ...init,
+            signal: controller.signal,
+        }));
+    }
+    finally {
+        clearTimeout(timerId);
+    }
+};
+/**
+ * Customer setter to inject trace parent into the request headers
+ * This is required because `graphql-request` 7.0.1 changes its header
+ * type to `Headers` which break the default open telemetry propagator.
+ */
+class CustomSetter {
+    set(carrier, key, value) {
+        carrier.set(key, value);
+    }
+}
+export function createGQLClient(port, token) {
+    const client = new GraphQLClient(`http://127.0.0.1:${port}/query`, {
+        // 1 week timeout so we should never hit that one.
+        // This is to bypass the current graphql-request timeout, which depends on
+        // node-fetch and is 5minutes by default.
+        fetch: createFetchWithTimeout(1000 * 60 * 60 * 24 * 7),
+        headers: {
+            Authorization: "Basic " + Buffer.from(token + ":").toString("base64"),
+        },
+        // Inject trace parent into the request headers so it can be correctly linked
+        requestMiddleware: async (req) => {
+            opentelemetry.propagation.inject(opentelemetry.context.active(), req.headers, new CustomSetter());
+            return req;
+        },
+    });
+    return client;
+}

package/dist/src/common/graphql/compute_query.d.ts

@@ -0,0 +1,37 @@
+import { GraphQLClient } from "graphql-request";
+export type QueryTree = {
+    operation: string;
+    args?: Record<string, unknown>;
+};
+export type Metadata = {
+    [key: string]: {
+        is_enum?: boolean;
+        value_to_name?: (value: any) => string;
+    };
+};
+/**
+ * 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=compute_query.d.ts.map

package/dist/src/common/graphql/compute_query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_query.d.ts","sourceRoot":"","sources":["../../../../src/common/graphql/compute_query.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAUjE,MAAM,MAAM,SAAS,GAAG;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG;QACb,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,MAAM,CAAA;KACvC,CAAA;CACF,CAAA;AAqHD;;;;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,CA6CZ"}

package/dist/src/common/graphql/compute_query.js

@@ -0,0 +1,171 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ClientError, gql } from "graphql-request";
+import { GraphQLRequestError, TooManyNestedObjectsError, UnknownDaggerError, NotAwaitedRequestError, ExecError, } from "../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(metadata[key].value_to_name?.(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["_ctx"] !== 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["_ctx"]["_queryTree"]) {
+            await computeNestedQuery([op], client);
+        }
+        // push an id that will be used by the container
+        return buildQuery([
+            ...value["_ctx"]["_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 ?? "",
+                    extensions: ext,
+                });
+            }
+            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/src/common/graphql/connect.d.ts

@@ -0,0 +1,8 @@
+import { GraphQLClient } from "graphql-request";
+import { ConnectOpts } from "../../connectOpts.js";
+/**
+ * Execute the callback with a GraphQL client connected to the Dagger engine.
+ * It automatically provisions the engine if needed.
+ */
+export declare function withGQLClient<T>(connectOpts: ConnectOpts, cb: (gqlClient: GraphQLClient) => Promise<T>): Promise<T>;
+//# sourceMappingURL=connect.d.ts.map

package/dist/src/common/graphql/connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../../src/common/graphql/connect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAGlD;;;GAGG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,WAAW,EAAE,WAAW,EACxB,EAAE,EAAE,CAAC,SAAS,EAAE,aAAa,KAAK,OAAO,CAAC,CAAC,CAAC,GAC3C,OAAO,CAAC,CAAC,CAAC,CAuBZ"}

package/dist/src/common/graphql/connect.js

@@ -0,0 +1,22 @@
+import { createGQLClient } from "./client.js";
+/**
+ * Execute the callback with a GraphQL client connected to the Dagger engine.
+ * It automatically provisions the engine if needed.
+ */
+export async function withGQLClient(connectOpts, cb) {
+    if (process.env["DAGGER_SESSION_PORT"]) {
+        const port = process.env["DAGGER_SESSION_PORT"];
+        if (!process.env["DAGGER_SESSION_TOKEN"]) {
+            throw new Error("DAGGER_SESSION_TOKEN must be set if DAGGER_SESSION_PORT is set");
+        }
+        const token = process.env["DAGGER_SESSION_TOKEN"];
+        return await cb(createGQLClient(Number(port), token));
+    }
+    try {
+        const provisioning = await import("../../provisioning/index.js");
+        return await provisioning.withEngineSession(connectOpts, cb);
+    }
+    catch (e) {
+        throw new Error(`failed to execute function with automatic provisioning: ${e}`);
+    }
+}

package/dist/src/common/graphql/connection.d.ts

@@ -0,0 +1,14 @@
+import { GraphQLClient } from "graphql-request";
+/**
+ * Wraps the GraphQL client to allow lazy initialization and setting
+ * the GQL client of the global Dagger client instance (`dag`).
+ */
+export declare class Connection {
+    private _gqlClient?;
+    constructor(_gqlClient?: GraphQLClient | undefined);
+    resetClient(): void;
+    setGQLClient(gqlClient: GraphQLClient): void;
+    getGQLClient(): GraphQLClient;
+}
+export declare const globalConnection: Connection;
+//# sourceMappingURL=connection.d.ts.map

package/dist/src/common/graphql/connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.d.ts","sourceRoot":"","sources":["../../../../src/common/graphql/connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C;;;GAGG;AACH,qBAAa,UAAU;IACT,OAAO,CAAC,UAAU,CAAC;gBAAX,UAAU,CAAC,EAAE,aAAa,YAAA;IAE9C,WAAW;IAIX,YAAY,CAAC,SAAS,EAAE,aAAa;IAIrC,YAAY,IAAI,aAAa;CAO9B;AAED,eAAO,MAAM,gBAAgB,YAAmB,CAAA"}

package/dist/src/common/graphql/connection.js

@@ -0,0 +1,23 @@
+/**
+ * Wraps the GraphQL client to allow lazy initialization and setting
+ * the GQL client of the global Dagger client instance (`dag`).
+ */
+export class Connection {
+    _gqlClient;
+    constructor(_gqlClient) {
+        this._gqlClient = _gqlClient;
+    }
+    resetClient() {
+        this._gqlClient = undefined;
+    }
+    setGQLClient(gqlClient) {
+        this._gqlClient = gqlClient;
+    }
+    getGQLClient() {
+        if (!this._gqlClient) {
+            throw new Error("GraphQL client is not set");
+        }
+        return this._gqlClient;
+    }
+}
+export const globalConnection = new Connection();

package/dist/src/common/utils.d.ts

@@ -0,0 +1,70 @@
+export declare const log: (stack?: string) => {
+    command: string;
+    lastCommand: string;
+    level: any;
+    noColor: boolean;
+    setLevel(level: "error" | "debug" | "info" | "warn" | "disable" | "success"): void;
+    createNamedLogger(name: string): /*elided*/ any;
+    setLogStream(stream: import("node:stream")): /*elided*/ any;
+    setLevelNoColor(): void;
+    setLevelColor(): void;
+    enableFileAndLine(enable: boolean, isShortFile?: boolean): void;
+    isLevelValid(level: "error" | "debug" | "info" | "warn" | "disable" | "success"): boolean;
+    isAllowedLevel(level: "error" | "debug" | "info" | "warn" | "disable" | "success"): boolean;
+    checkSetting(setting: {
+        reverse?: boolean | undefined;
+        bold?: boolean | undefined;
+        italic?: boolean | undefined;
+        dim?: boolean | undefined;
+        underscore?: boolean | undefined;
+        strikethrough?: boolean | undefined;
+    }): string;
+    joint(): /*elided*/ any;
+    append(...args: any[]): /*elided*/ any;
+    reset(): /*elided*/ any;
+    setDate(callback: Function): void;
+    getDate(): string;
+    color(ticket: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white"): /*elided*/ any;
+    bgColor(ticket: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white"): /*elided*/ any;
+    bold(): /*elided*/ any;
+    dim(): /*elided*/ any;
+    underscore(): /*elided*/ any;
+    strikethrough(): /*elided*/ any;
+    reverse(): /*elided*/ any;
+    italic(): /*elided*/ any;
+    fontColorLog(ticket: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white", text: string, setting?: {
+        reverse?: boolean | undefined;
+        bold?: boolean | undefined;
+        italic?: boolean | undefined;
+        dim?: boolean | undefined;
+        underscore?: boolean | undefined;
+        strikethrough?: boolean | undefined;
+    }): void;
+    bgColorLog(ticket: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white", text: string, setting?: {
+        reverse?: boolean | undefined;
+        bold?: boolean | undefined;
+        italic?: boolean | undefined;
+        dim?: boolean | undefined;
+        underscore?: boolean | undefined;
+        strikethrough?: boolean | undefined;
+    }): void;
+    colorLog(ticketObj: {
+        font?: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
+        bg?: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
+    }, text: string, setting?: {
+        reverse?: boolean | undefined;
+        bold?: boolean | undefined;
+        italic?: boolean | undefined;
+        dim?: boolean | undefined;
+        underscore?: boolean | undefined;
+        strikethrough?: boolean | undefined;
+    }): void;
+    log(...args: any[]): /*elided*/ any;
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    info(...args: any[]): void;
+    debug(...args: any[]): void;
+    success(...args: any[]): void;
+};
+export declare function isDeno(): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/common/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/common/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,GAAI,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACe,CAAA;AAEjD,wBAAgB,MAAM,IAAI,OAAO,CAGhC"}

package/dist/src/common/utils.js

@@ -0,0 +1,6 @@
+import logger from "node-color-log";
+export const log = (stack) => logger.bgColor("red").color("black").log(stack);
+export function isDeno() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return typeof globalThis.Deno !== "undefined";
+}

package/dist/src/connect.d.ts

@@ -0,0 +1,28 @@
+import { Client } from "./api/client.gen.js";
+import { ConnectOpts } from "./connectOpts.js";
+export type CallbackFct = (client: Client) => Promise<void>;
+/**
+ * connection executes the given function using the default global Dagger client.
+ *
+ * @example
+ * ```ts
+ * await connection(
+ *   async () => {
+ *     await dag
+ *       .container()
+ *       .from("alpine")
+ *       .withExec(["apk", "add", "curl"])
+ *       .withExec(["curl", "https://dagger.io/"])
+ *       .sync()
+ *   }, { LogOutput: process.stderr }
+ * )
+ * ```
+ */
+export declare function connection(fct: () => Promise<void>, cfg?: ConnectOpts): Promise<void>;
+/**
+ * connect runs GraphQL server and initializes a
+ * GraphQL client to execute query on it through its callback.
+ * This implementation is based on the existing Go SDK.
+ */
+export declare function connect(cb: CallbackFct, config?: ConnectOpts): Promise<void>;
+//# sourceMappingURL=connect.d.ts.map

package/dist/src/connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../src/connect.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAI5C,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAG9C,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE3D;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EACxB,GAAG,GAAE,WAAgB,iBAqBtB;AAED;;;;GAIG;AACH,wBAAsB,OAAO,CAC3B,EAAE,EAAE,WAAW,EACf,MAAM,GAAE,WAAgB,GACvB,OAAO,CAAC,IAAI,CAAC,CAef"}