@dagger.io/dagger 0.13.3 → 0.13.4

package/dist/entrypoint/entrypoint.js

@@ -0,0 +1,71 @@
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { dag } from "../api/client.gen.js";
+import { connection } from "../connect.js";
+import { scan } from "../introspector/scanner/scan.js";
+import { listFiles } from "../introspector/utils/files.js";
+import { invoke } from "./invoke.js";
+import { load } from "./load.js";
+import { register } from "./register.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const moduleSrcDirectory = `${__dirname}/../../src/`;
+export async function entrypoint() {
+    // Pre list all files of the modules since we need it either for a registration
+    // or an invocation
+    const files = await listFiles(moduleSrcDirectory);
+    // Start a Dagger session to get the call context
+    await connection(async () => {
+        const fnCall = dag.currentFunctionCall();
+        const moduleName = await dag.currentModule().name();
+        const parentName = await fnCall.parentName();
+        const scanResult = scan(files, moduleName);
+        // Pre allocate the result, we got one in both case.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let result;
+        if (parentName === "") {
+            result = await register(files, scanResult);
+        }
+        else {
+            // Invocation
+            const fnName = await fnCall.name();
+            const parentJson = JSON.parse(await fnCall.parent());
+            const fnArgs = await fnCall.inputArgs();
+            const args = {};
+            const parentArgs = parentJson ?? {};
+            for (const arg of fnArgs) {
+                args[await arg.name()] = JSON.parse(await arg.value());
+            }
+            await load(files);
+            try {
+                result = await invoke(scanResult, {
+                    parentName,
+                    fnName,
+                    parentArgs,
+                    fnArgs: args,
+                });
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    if (e.cause) {
+                        console.error(`${e.cause}`);
+                    }
+                    console.error(`Error: ${e.message}`);
+                }
+                else {
+                    console.error(e);
+                }
+                process.exit(1);
+            }
+        }
+        // If result is set, we stringify it
+        if (result !== undefined && result !== null) {
+            result = JSON.stringify(result);
+        }
+        else {
+            result = "null";
+        }
+        // Send the result to Dagger
+        await fnCall.returnValue(result);
+    }, { LogOutput: process.stdout });
+}

package/dist/entrypoint/invoke.d.ts

@@ -0,0 +1,13 @@
+import { DaggerModule } from "../introspector/scanner/abtractions/module.js";
+import { InvokeCtx } from "./context.js";
+/**
+ * A wrapper around the registry to invoke a function.
+ *
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the parent object.
+ * @param fnName The name of the function to call.
+ * @param parentArgs The arguments of the parent object.
+ * @param fnArgs The arguments of the function to call.
+ */
+export declare function invoke(module: DaggerModule, ctx: InvokeCtx): Promise<any>;
+//# sourceMappingURL=invoke.d.ts.map

package/dist/entrypoint/invoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../entrypoint/invoke.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAA;AAE5E,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAcxC;;;;;;;;GAQG;AACH,wBAAsB,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,GAAG,EAAE,SAAS,gBAoChE"}

package/dist/entrypoint/invoke.js

@@ -0,0 +1,40 @@
+import { registry } from "../introspector/registry/registry.js";
+import { loadResult, loadInvokedMethod, loadInvokedObject, loadArgs, loadParentState, loadObjectReturnType, } from "./load.js";
+function isConstructor(method) {
+    return method.name === "";
+}
+/**
+ * A wrapper around the registry to invoke a function.
+ *
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the parent object.
+ * @param fnName The name of the function to call.
+ * @param parentArgs The arguments of the parent object.
+ * @param fnArgs The arguments of the function to call.
+ */
+export async function invoke(module, ctx) {
+    const object = loadInvokedObject(module, ctx.parentName);
+    if (!object) {
+        throw new Error(`could not find object ${ctx.parentName}`);
+    }
+    const method = loadInvokedMethod(object, ctx);
+    if (!method) {
+        throw new Error(`could not find method ${ctx.fnName}`);
+    }
+    const args = await loadArgs(registry, method, ctx);
+    const parentState = await loadParentState(registry, object, ctx);
+    let result = await registry.getResult(object.name, method.name, parentState, args);
+    if (result) {
+        let returnType;
+        // Handle alias serialization by getting the return type to load
+        // if the function called isn't a constructor.
+        if (!isConstructor(method)) {
+            returnType = loadObjectReturnType(module, object, method);
+        }
+        else {
+            returnType = object;
+        }
+        result = await loadResult(result, module, returnType);
+    }
+    return result;
+}

package/dist/entrypoint/load.d.ts

@@ -0,0 +1,56 @@
+import { TypeDefKind } from "../api/client.gen.js";
+import { Args, Registry } from "../introspector/registry/registry.js";
+import { Constructor } from "../introspector/scanner/abtractions/constructor.js";
+import { DaggerEnum } from "../introspector/scanner/abtractions/enum.js";
+import { Method } from "../introspector/scanner/abtractions/method.js";
+import { DaggerModule } from "../introspector/scanner/abtractions/module.js";
+import { DaggerObject } from "../introspector/scanner/abtractions/object.js";
+import { TypeDef } from "../introspector/scanner/typeDefs.js";
+import { InvokeCtx } from "./context.js";
+/**
+ * Import all given typescript files so that trigger their decorators
+ * and register their class and functions inside the Registry.
+ *
+ * @param files List of files to load.
+ */
+export declare function load(files: string[]): Promise<void>;
+/**
+ * Return the object invoked from the module.
+ *
+ * @param module The module to load the object from.
+ * @param parentName The name of the parent object.
+ */
+export declare function loadInvokedObject(module: DaggerModule, parentName: string): DaggerObject;
+export declare function loadInvokedMethod(object: DaggerObject, ctx: InvokeCtx): (Method | Constructor) | undefined;
+/**
+ * Load the values of the arguments from the context.
+ *
+ * @param method Method to load the arguments from.
+ * @param ctx The context of the invocation.
+ */
+export declare function loadArgs(registry: Registry, method: Method | Constructor, ctx: InvokeCtx): Promise<Args>;
+/**
+ * Load the state of the parent object from the context.
+ *
+ * @param object The object to load the parent state from.
+ * @param ctx The context of the invocation.
+ */
+export declare function loadParentState(registry: Registry, object: DaggerObject, ctx: InvokeCtx): Promise<Args>;
+/**
+ * This function load the value as a Dagger type.
+ *
+ * Note: The JSON.parse() is required to remove extra quotes
+ */
+export declare function loadValue(registry: Registry, value: any, type: TypeDef<TypeDefKind>): Promise<any>;
+/**
+ * Load the object type from the return type of the method.
+ * This covers the case where the return type is an other object of the module.
+ * For example: `msg(): Message` where message is an object of the module.
+ *
+ * @param module  The module to load the object from.
+ * @param object The current object to load the return type from.
+ * @param method The method to load the return type from.
+ */
+export declare function loadObjectReturnType(module: DaggerModule, object: DaggerObject, method: Method): DaggerObject | DaggerEnum;
+export declare function loadResult(result: any, module: DaggerModule, object: DaggerObject | DaggerEnum): Promise<any>;
+//# sourceMappingURL=load.d.ts.map

package/dist/entrypoint/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../entrypoint/load.ts"],"names":[],"mappings":"AACA,OAAO,EAAO,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,sCAAsC,CAAA;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,oDAAoD,CAAA;AAChF,OAAO,EAAE,UAAU,EAAE,MAAM,6CAA6C,CAAA;AACxE,OAAO,EAAE,MAAM,EAAE,MAAM,+CAA+C,CAAA;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAA;AAC5E,OAAO,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAA;AAC5E,OAAO,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAA;AAC7D,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExC;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,MAAM,GACjB,YAAY,CAEd;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,SAAS,GACb,CAAC,MAAM,GAAG,WAAW,CAAC,GAAG,SAAS,CAMpC;AAED;;;;;GAKG;AACH,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,GAAG,WAAW,EAC5B,GAAG,EAAE,SAAS,GACb,OAAO,CAAC,IAAI,CAAC,CAyCf;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,SAAS,GACb,OAAO,CAAC,IAAI,CAAC,CAaf;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GACzB,OAAO,CAAC,GAAG,CAAC,CA4Cd;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACb,YAAY,GAAG,UAAU,CAqB3B;AAED,wBAAsB,UAAU,CAC9B,MAAM,EAAE,GAAG,EACX,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,GAAG,UAAU,GAChC,OAAO,CAAC,GAAG,CAAC,CA0Ed"}

package/dist/entrypoint/load.js

@@ -0,0 +1,198 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { dag, TypeDefKind } from "../api/client.gen.js";
+import { DaggerEnum } from "../introspector/scanner/abtractions/enum.js";
+import { DaggerObject } from "../introspector/scanner/abtractions/object.js";
+/**
+ * Import all given typescript files so that trigger their decorators
+ * and register their class and functions inside the Registry.
+ *
+ * @param files List of files to load.
+ */
+export async function load(files) {
+    await Promise.all(files.map(async (f) => await import(f)));
+}
+/**
+ * Return the object invoked from the module.
+ *
+ * @param module The module to load the object from.
+ * @param parentName The name of the parent object.
+ */
+export function loadInvokedObject(module, parentName) {
+    return module.objects[parentName];
+}
+export function loadInvokedMethod(object, ctx) {
+    if (ctx.fnName === "") {
+        return object._constructor;
+    }
+    return object.methods[ctx.fnName];
+}
+/**
+ * Load the values of the arguments from the context.
+ *
+ * @param method Method to load the arguments from.
+ * @param ctx The context of the invocation.
+ */
+export async function loadArgs(registry, method, ctx) {
+    const args = {};
+    // Load arguments
+    for (const argName of method.getArgOrder()) {
+        const argument = method.arguments[argName];
+        if (!argument) {
+            throw new Error(`could not find argument ${argName}`);
+        }
+        const loadedArg = await loadValue(registry, ctx.fnArgs[argName], argument.type);
+        // If the argument is variadic, we need to load each args independently
+        // so it's correctly propagated when it's sent to the function.
+        // Note: variadic args are always last in the list of args.
+        if (argument.isVariadic) {
+            for (const [i, arg] of (loadedArg ?? []).entries()) {
+                args[`${argName}${i}`] = arg;
+            }
+            continue;
+        }
+        // If the argument is nullable and the loaded arg is undefined with no default value, we set it to null.
+        if (argument.isNullable &&
+            loadedArg === undefined &&
+            !argument.defaultValue) {
+            args[argName] = null;
+            continue;
+        }
+        args[argName] = loadedArg;
+    }
+    return args;
+}
+/**
+ * Load the state of the parent object from the context.
+ *
+ * @param object The object to load the parent state from.
+ * @param ctx The context of the invocation.
+ */
+export async function loadParentState(registry, object, ctx) {
+    const parentState = {};
+    for (const [key, value] of Object.entries(ctx.parentArgs)) {
+        const property = object.properties[key];
+        if (!property) {
+            throw new Error(`could not find parent property ${key}`);
+        }
+        parentState[property.name] = await loadValue(registry, value, property.type);
+    }
+    return parentState;
+}
+/**
+ * This function load the value as a Dagger type.
+ *
+ * Note: The JSON.parse() is required to remove extra quotes
+ */
+export async function loadValue(registry, value, type) {
+    // If value is undefinied, return it directly.
+    if (value === undefined) {
+        return value;
+    }
+    switch (type.kind) {
+        case TypeDefKind.ListKind:
+            return Promise.all(value.map(async (v) => await loadValue(registry, v, type.typeDef)));
+        case TypeDefKind.ObjectKind: {
+            const objectType = type.name;
+            // Workaround to call get any object that has an id
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            if (dag[`load${objectType}FromID`]) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                return dag[`load${objectType}FromID`](value);
+            }
+            // TODO(supports subfields serialization)
+            return registry.buildClass(objectType, value);
+        }
+        // Cannot use `,` to specify multiple matching case so instead we use fallthrough.
+        case TypeDefKind.StringKind:
+        case TypeDefKind.IntegerKind:
+        case TypeDefKind.BooleanKind:
+        case TypeDefKind.VoidKind:
+        case TypeDefKind.ScalarKind:
+        case TypeDefKind.EnumKind:
+            return value;
+        default:
+            throw new Error(`unsupported type ${type.kind}`);
+    }
+}
+/**
+ * Load the object type from the return type of the method.
+ * This covers the case where the return type is an other object of the module.
+ * For example: `msg(): Message` where message is an object of the module.
+ *
+ * @param module  The module to load the object from.
+ * @param object The current object to load the return type from.
+ * @param method The method to load the return type from.
+ */
+export function loadObjectReturnType(module, object, method) {
+    const retType = method.returnType;
+    switch (retType.kind) {
+        case TypeDefKind.ListKind: {
+            // Loop until we find the original object type.
+            // This way we handle the list of list (e.g Object[][][]...[])
+            let listType = retType;
+            while (listType.kind === TypeDefKind.ListKind) {
+                listType = listType.typeDef;
+            }
+            return module.objects[listType.name];
+        }
+        case TypeDefKind.ObjectKind:
+            return module.objects[retType.name];
+        case TypeDefKind.EnumKind:
+            return module.enums[retType.name];
+        default:
+            return object;
+    }
+}
+export async function loadResult(result, module, object) {
+    // Handle IDable objects
+    if (result && typeof result?.id === "function") {
+        result = await result.id();
+    }
+    // Handle arrays
+    if (Array.isArray(result)) {
+        result = await Promise.all(result.map(async (r) => await loadResult(r, module, object)));
+        return result;
+    }
+    // Handle objects
+    if (typeof result === "object" && object instanceof DaggerObject) {
+        const state = {};
+        for (const [key, value] of Object.entries(result)) {
+            const property = Object.values(object.properties).find((p) => p.name === key);
+            if (!property) {
+                throw new Error(`could not find result property ${key}`);
+            }
+            let referencedObject = undefined;
+            // Handle nested objects
+            if (property.type.kind === TypeDefKind.ObjectKind) {
+                referencedObject =
+                    module.objects[property.type.name];
+            }
+            // Handle list of nested objects
+            if (property.type.kind === TypeDefKind.ListKind) {
+                let _property = property.type;
+                // Loop until we find the original type.
+                while (_property.kind === TypeDefKind.ListKind) {
+                    _property = _property.typeDef;
+                }
+                // If the original type is an object, we use it as the referenced object.
+                if (_property.kind === TypeDefKind.ObjectKind) {
+                    referencedObject =
+                        module.objects[_property.name];
+                }
+            }
+            // If there's no referenced object, we use the current object.
+            if (!referencedObject) {
+                referencedObject = object;
+            }
+            state[property.alias ?? property.name] = await loadResult(value, module, referencedObject);
+        }
+        return state;
+    }
+    if (typeof result === "object" && object instanceof DaggerEnum) {
+        return result;
+    }
+    // Handle primitive types
+    return result;
+}

package/dist/entrypoint/register.d.ts

@@ -0,0 +1,7 @@
+import { ModuleID } from "../api/client.gen.js";
+import { DaggerModule } from "../introspector/scanner/abtractions/module.js";
+/**
+ * Register the module files and returns its ID
+ */
+export declare function register(files: string[], module: DaggerModule): Promise<ModuleID>;
+//# sourceMappingURL=register.d.ts.map

package/dist/entrypoint/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../entrypoint/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAGT,MAAM,sBAAsB,CAAA;AAI7B,OAAO,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAA;AAS5E;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,QAAQ,CAAC,CA6DnB"}

package/dist/entrypoint/register.js

@@ -0,0 +1,139 @@
+import { dag, TypeDefKind, } from "../api/client.gen.js";
+/**
+ * Register the module files and returns its ID
+ */
+export async function register(files, module) {
+    // Get a new module that we will fill in with all the types
+    let mod = dag.module_();
+    // Add module description if any.
+    if (module.description) {
+        mod = mod.withDescription(module.description);
+    }
+    // For each class scanned, register its type, method and properties in the module.
+    Object.values(module.objects).forEach((object) => {
+        // Register the class Typedef object in Dagger
+        let typeDef = dag.typeDef().withObject(object.name, {
+            description: object.description,
+        });
+        // Register all functions (methods) to this object
+        Object.values(object.methods).forEach((method) => {
+            typeDef = typeDef.withFunction(addFunction(method));
+        });
+        // Register all fields that belong to this object
+        Object.values(object.properties).forEach((field) => {
+            if (field.isExposed) {
+                typeDef = typeDef.withField(field.alias ?? field.name, addTypeDef(field.type), {
+                    description: field.description,
+                });
+            }
+        });
+        if (object._constructor) {
+            typeDef = typeDef.withConstructor(addConstructor(object._constructor, typeDef));
+        }
+        // Add it to the module object
+        mod = mod.withObject(typeDef);
+    });
+    // Register all enums defined by this modules
+    Object.values(module.enums).forEach((enum_) => {
+        let typeDef = dag.typeDef().withEnum(enum_.name, {
+            description: enum_.description,
+        });
+        Object.values(enum_.values).forEach((value) => {
+            typeDef = typeDef.withEnumValue(value.value, {
+                description: value.description,
+            });
+        });
+        mod = mod.withEnum(typeDef);
+    });
+    // Call ID to actually execute the registration
+    return await mod.id();
+}
+/**
+ * Bind a constructor to the given object.
+ */
+function addConstructor(constructor, owner) {
+    return dag.function_("", owner).with(addArg(constructor.arguments));
+}
+/**
+ * Create a function in the Dagger API.
+ */
+function addFunction(fct) {
+    return dag
+        .function_(fct.alias ?? fct.name, addTypeDef(fct.returnType))
+        .withDescription(fct.description)
+        .with(addArg(fct.arguments));
+}
+/**
+ * Register all arguments in the function.
+ */
+function addArg(args) {
+    return function (fct) {
+        Object.values(args).forEach((arg) => {
+            const opts = {
+                description: arg.description,
+            };
+            let typeDef = addTypeDef(arg.type);
+            if (arg.isOptional) {
+                typeDef = typeDef.withOptional(true);
+            }
+            // Check if both values are used, return an error if so.
+            if (arg.defaultValue && arg.defaultPath) {
+                throw new Error("cannot set both default value and default path from context");
+            }
+            // We do not set the default value if it's not a primitive type, we let TypeScript
+            // resolve the default value during the runtime instead.
+            // If it has a default value but is not primitive, we set the value as optional
+            // to workaround the fact that the API isn't aware of the default value and will
+            // expect it to be set as required input.
+            if (arg.defaultValue) {
+                if (isPrimitiveType(arg.type)) {
+                    opts.defaultValue = arg.defaultValue;
+                }
+                else {
+                    typeDef = typeDef.withOptional(true);
+                }
+            }
+            // If the argument is a contextual argument, it becomes optional.
+            if (arg.defaultPath) {
+                opts.defaultPath = arg.defaultPath;
+            }
+            if (arg.ignore) {
+                opts.ignore = arg.ignore;
+            }
+            fct = fct.withArg(arg.name, typeDef, opts);
+        });
+        return fct;
+    };
+}
+/**
+ * Wrapper around TypeDef to return the right Dagger TypesDef with its options.
+ *
+ * This function only convert the Typedef into correct dagger call
+ * but, it's up to function above with more context to add documentation,
+ * define if it's an optional value or its default's.
+ *
+ * We cannot do it there because the Typedef can come from any source:
+ * a field, a param, a return value etc...
+ */
+function addTypeDef(type) {
+    switch (type.kind) {
+        case TypeDefKind.ScalarKind:
+            return dag.typeDef().withScalar(type.name);
+        case TypeDefKind.ObjectKind:
+            return dag.typeDef().withObject(type.name);
+        case TypeDefKind.ListKind:
+            return dag.typeDef().withListOf(addTypeDef(type.typeDef));
+        case TypeDefKind.VoidKind:
+            return dag.typeDef().withKind(type.kind).withOptional(true);
+        case TypeDefKind.EnumKind:
+            return dag.typeDef().withEnum(type.name);
+        default:
+            return dag.typeDef().withKind(type.kind);
+    }
+}
+function isPrimitiveType(type) {
+    return (type.kind === TypeDefKind.BooleanKind ||
+        type.kind === TypeDefKind.IntegerKind ||
+        type.kind === TypeDefKind.StringKind ||
+        type.kind === TypeDefKind.EnumKind);
+}

package/dist/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/graphql/client.d.ts.map

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

package/dist/graphql/client.js

@@ -0,0 +1,48 @@
+import * as opentelemetry from "@opentelemetry/api";
+import { GraphQLClient } from "graphql-request";
+import fetch from "node-fetch";
+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 {
+        return (await fetch(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/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./api/client.gen.js";
+export * from "./common/errors/index.js";
+export { gql } from "graphql-tag";
+export { GraphQLClient } from "graphql-request";
+export type { CallbackFct } from "./connect.js";
+export { connect, connection, close } from "./connect.js";
+export type { ConnectOpts } from "./connectOpts.js";
+export * from "./introspector/decorators/decorators.js";
+export { entrypoint } from "./entrypoint/entrypoint.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACzD,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,cAAc,yCAAyC,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./api/client.gen.js";
+export * from "./common/errors/index.js";
+export { gql } from "graphql-tag";
+export { GraphQLClient } from "graphql-request";
+export { connect, connection, close } from "./connect.js";
+export * from "./introspector/decorators/decorators.js";
+export { entrypoint } from "./entrypoint/entrypoint.js";

package/dist/introspector/decorators/decorators.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The definition of the `@object` decorator that should be on top of any
+ * class module that must be exposed to the Dagger API.
+ *
+ */
+export declare const object: () => (<T extends import("../registry/registry.js").Class>(constructor: T) => T);
+/**
+ * The definition of @func decorator that should be on top of any
+ * class' method that must be exposed to the Dagger API.
+ *
+ * @param alias The alias to use for the field when exposed on the API.
+ */
+export declare const func: (alias?: string) => ((target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor) => void);
+/**
+ * The definition of @field decorator that should be on top of any
+ * class' property that must be exposed to the Dagger API.
+ *
+ * @deprecated In favor of `@func`
+ * @param alias The alias to use for the field when exposed on the API.
+ */
+export declare const field: (alias?: string) => ((target: object, propertyKey: string) => void);
+/**
+ * The definition of the `@enumType` decorator that should be on top of any
+ * class module that must be exposed to the Dagger API as enumeration.
+ */
+export declare const enumType: () => (<T extends import("../registry/registry.js").Class>(constructor: T) => T);
+/**
+ * Add a `@argument` decorator to an argument of type `Directory` or `File` to load
+ * its contents from the module context directory.
+ *
+ * The context directory is the git repository containing the module.
+ * If there's no git repository, the context directory is the directory containing
+ * the module source code.
+ *
+ * @param opts.defaultPath Only applies to arguments of type File or Directory. If the argument is not set,
+ * load it from the given path in the context directory.
+ * @param opts.ignore Only applies to arguments of type Directory. The ignore patterns are applied to the input directory,
+ * and matching entries are filtered out, in a cache-efficient manner..
+ *
+ * Relative paths are relative to the current source files.
+ * Absolute paths are rooted to the module context directory.
+ */
+export declare const argument: (opts?: import("../registry/registry.js").ArgumentOptions) => ((target: object, propertyKey: string, parameterIndex: number) => void);
+//# sourceMappingURL=decorators.d.ts.map

package/dist/introspector/decorators/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../../introspector/decorators/decorators.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,eAAO,MAAM,MAAM,kFAAkB,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,IAAI,gFAkCksC,CAAC,8BAlCnrC,CAAA;AAEjC;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,qEAAiB,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,QAAQ,kFAAoB,CAAA;AAEzC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,uIAAoB,CAAA"}