@dagger.io/dagger 0.9.6 → 0.9.8

package/dist/common/utils.d.ts

@@ -5,6 +5,7 @@ export declare const log: (stack?: string) => {
     noColor: boolean;
     setLevel(level: "error" | "debug" | "info" | "warn" | "disable" | "success"): void;
     createNamedLogger(name: string): any;
+    setLogStream(stream: Stream): any;
     setLevelNoColor(): void;
     setLevelColor(): void;
     isLevelValid(level: "error" | "debug" | "info" | "warn" | "disable" | "success"): boolean;
@@ -18,6 +19,8 @@ export declare const log: (stack?: string) => {
         strikethrough?: boolean | undefined;
     }): string;
     joint(): any;
+    append(...args: any[]): any;
+    reset(): any;
     setDate(callback: Function): void;
     getDate(): string;
     color(ticket: "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white"): any;

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../common/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,WAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACe,CAAA"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../common/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,GAAG,WAAY,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACe,CAAA"}

package/dist/entrypoint/entrypoint.d.ts

@@ -1,2 +1,2 @@
-export {};
+export declare function entrypoint(): Promise<void>;
 //# sourceMappingURL=entrypoint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"entrypoint.d.ts","sourceRoot":"","sources":["../../entrypoint/entrypoint.ts"],"names":[],"mappings":""}
+{"version":3,"file":"entrypoint.d.ts","sourceRoot":"","sources":["../../entrypoint/entrypoint.ts"],"names":[],"mappings":"AAiBA,wBAAsB,UAAU,kBAyD/B"}

package/dist/entrypoint/entrypoint.js

@@ -2,17 +2,19 @@ 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, loadArg } from "./load.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/`;
-async function entrypoint() {
+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);
+    const scanResult = await scan(files);
     // Start a Dagger session to get the call context
     await connection(async () => {
         const fnCall = dag.currentFunctionCall();
@@ -23,7 +25,7 @@ async function entrypoint() {
         if (parentName === "") {
             // It's a registration, we register the module and assign the module id
             // to the result
-            result = await register(files);
+            result = await register(files, scanResult);
         }
         else {
             // Invocation
@@ -31,30 +33,17 @@ async function entrypoint() {
             const parentJson = JSON.parse(await fnCall.parent());
             const fnArgs = await fnCall.inputArgs();
             const args = {};
-            const parentArgs = {};
+            const parentArgs = parentJson ?? {};
             for (const arg of fnArgs) {
-                args[await arg.name()] = await loadArg(await arg.value());
-            }
-            if (parentJson) {
-                for (const [key, value] of Object.entries(parentJson)) {
-                    parentArgs[key] = await loadArg(value);
-                }
+                args[await arg.name()] = JSON.parse(await arg.value());
             }
             await load(files);
-            result = await invoke(parentName, fnName, parentArgs, args);
-            // Load ID if it's a Dagger type with an id
-            if (typeof result?.id === "function") {
-                result = await result.id();
-            }
-            // Load its field ID if there are
-            if (typeof result === "object") {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                for (const [key, value] of Object.entries(result)) {
-                    if (value.id && typeof value.id === "function") {
-                        result[key] = await value.id();
-                    }
-                }
-            }
+            result = await invoke(scanResult, {
+                parentName,
+                fnName,
+                parentArgs,
+                fnArgs: args,
+            });
         }
         // If result is set, we stringify it
         if (result !== undefined && result !== null) {
@@ -67,4 +56,3 @@ async function entrypoint() {
         await fnCall.returnValue(result);
     }, { LogOutput: process.stdout });
 }
-entrypoint();

package/dist/entrypoint/invoke.d.ts

@@ -1,11 +1,19 @@
-import { Args, State } from "../introspector/registry/registry.js";
+import { Args } from "../introspector/registry/registry.js";
+import { ScanResult } from "../introspector/scanner/scan.js";
+export type InvokeCtx = {
+    parentName: string;
+    fnName: string;
+    parentArgs: Args;
+    fnArgs: Args;
+};
 /**
  * A wrapper around the registry to invoke a function.
  *
- * @param objectName – The class to look for
- * @param methodName – The method to call in the class
- * @param state – The current state of the class
- * @param inputs – The input to send to the method to call
+ * @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(objectName: string, methodName: string, state: State, inputs: Args): Promise<any>;
+export declare function invoke(scanResult: ScanResult, { parentName, fnName, parentArgs, fnArgs }: InvokeCtx): Promise<any>;
 //# sourceMappingURL=invoke.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../entrypoint/invoke.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,KAAK,EAAE,MAAM,sCAAsC,CAAA;AAE5E;;;;;;;GAOG;AACH,wBAAsB,MAAM,CAC1B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,IAAI,GAEX,OAAO,CAAC,GAAG,CAAC,CAEd"}
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../entrypoint/invoke.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,sCAAsC,CAAA;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAS5D,MAAM,MAAM,SAAS,GAAG;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,IAAI,CAAA;IAChB,MAAM,EAAE,IAAI,CAAA;CACb,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAsB,MAAM,CAC1B,UAAU,EAAE,UAAU,EACtB,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,SAAS,GAEvD,OAAO,CAAC,GAAG,CAAC,CAyBX"}

package/dist/entrypoint/invoke.js

@@ -1,14 +1,27 @@
 import { registry } from "../introspector/registry/registry.js";
+import { loadArgOrder, loadArg, loadArgType, loadPropertyType, loadResult, } from "./load.js";
 /**
  * A wrapper around the registry to invoke a function.
  *
- * @param objectName – The class to look for
- * @param methodName – The method to call in the class
- * @param state – The current state of the class
- * @param inputs – The input to send to the method to call
+ * @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(objectName, methodName, state, inputs
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    return await registry.getResult(objectName, methodName, state, inputs);
+export async function invoke(scanResult, { parentName, fnName, parentArgs, fnArgs }) {
+    const args = {};
+    // Load function arguments in the right order
+    for (const argName of loadArgOrder(scanResult, parentName, fnName)) {
+        args[argName] = await loadArg(fnArgs[argName], loadArgType(scanResult, parentName, fnName, argName));
+    }
+    // Load parent state
+    for (const [key, value] of Object.entries(parentArgs)) {
+        parentArgs[key] = await loadArg(value, loadPropertyType(scanResult, parentName, key));
+    }
+    let result = await registry.getResult(parentName, fnName, parentArgs, args);
+    if (result) {
+        result = await loadResult(result);
+    }
+    return result;
 }

package/dist/entrypoint/load.d.ts

@@ -1,3 +1,6 @@
+import { TypeDefKind } from "../api/client.gen.js";
+import { ScanResult } from "../introspector/scanner/scan.js";
+import { TypeDef } from "../introspector/scanner/typeDefs.js";
 /**
  * Import all given typescript files so that trigger their decorators
  * and register their class and functions inside the Registry.
@@ -6,11 +9,45 @@
  */
 export declare function load(files: string[]): Promise<void>;
 /**
- * Load argument as Dagger type.
+ * Load the order of arguments for a given function from the scan result.
  *
- * This function remove the quote from the identifier and checks
- * if it's a Dagger type, if it is, it loads it according to
- * its type.
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the class.
+ * @param fnName The name of the function.
+ *
+ * @returns An array of strings representing the order of arguments.
+ */
+export declare function loadArgOrder(scanResult: ScanResult, parentName: string, fnName: string): string[];
+/**
+ * Load the argument type from the scan result.
+ *
+ * @param scanResult Result of the scan
+ * @param parentName Class called
+ * @param fnName Function called
+ * @param argName Argument name
+ * @returns The type of the argument
+ */
+export declare function loadArgType(scanResult: ScanResult, parentName: string, fnName: string, argName: string): TypeDef<TypeDefKind>;
+/**
+ * Load the property type from the scan result.
+ *
+ * @param scanResult Result of the scan
+ * @param parentName Class called
+ * @param propertyName property of the class
+ * @returns the type of the property
+ */
+export declare function loadPropertyType(scanResult: ScanResult, parentName: string, propertyName: string): TypeDef<TypeDefKind>;
+/**
+ * This function load the argument as a Dagger type.
+ *
+ * Note: The JSON.parse() is required to remove extra quotes
+ */
+export declare function loadArg(value: any, type: TypeDef<TypeDefKind>): Promise<any>;
+/**
+ * Load subfields of the result and IDable object.
+ *
+ * @param result The result of the invocation.
+ * @returns Loaded result.
  */
-export declare function loadArg(value: string): Promise<any>;
+export declare function loadResult(result: any): Promise<any>;
 //# sourceMappingURL=load.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../entrypoint/load.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzD;AAED;;;;;;GAMG;AAEH,wBAAsB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CA8BzD"}
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../entrypoint/load.ts"],"names":[],"mappings":"AACA,OAAO,EAAO,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAC5D,OAAO,EAAE,OAAO,EAAE,MAAM,qCAAqC,CAAA;AAE7D;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzD;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,GACb,MAAM,EAAE,CAiBV;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,CA2BtB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,WAAW,CAAC,CAYtB;AAED;;;;GAIG;AACH,wBAAsB,OAAO,CAC3B,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GACzB,OAAO,CAAC,GAAG,CAAC,CAsCd;AAED;;;;;GAKG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAY1D"}

package/dist/entrypoint/load.js

@@ -1,4 +1,5 @@
-import { dag } from "../api/client.gen.js";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { dag, TypeDefKind } from "../api/client.gen.js";
 /**
  * Import all given typescript files so that trigger their decorators
  * and register their class and functions inside the Registry.
@@ -9,36 +10,130 @@ export async function load(files) {
     await Promise.all(files.map(async (f) => await import(f)));
 }
 /**
- * Load argument as Dagger type.
+ * Load the order of arguments for a given function from the scan result.
  *
- * This function remove the quote from the identifier and checks
- * if it's a Dagger type, if it is, it loads it according to
- * its type.
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the class.
+ * @param fnName The name of the function.
+ *
+ * @returns An array of strings representing the order of arguments.
+ */
+export function loadArgOrder(scanResult, parentName, fnName) {
+    const classTypeDef = scanResult.classes[parentName];
+    if (!classTypeDef) {
+        throw new Error(`could not find class ${parentName}`);
+    }
+    // Call for the constructor
+    if (fnName === "") {
+        return Object.keys(classTypeDef.constructor?.args ?? {});
+    }
+    const methodTypeDef = classTypeDef.methods[fnName];
+    if (!methodTypeDef) {
+        throw new Error(`could not find method ${fnName}`);
+    }
+    return Object.keys(methodTypeDef.args);
+}
+/**
+ * Load the argument type from the scan result.
+ *
+ * @param scanResult Result of the scan
+ * @param parentName Class called
+ * @param fnName Function called
+ * @param argName Argument name
+ * @returns The type of the argument
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export async function loadArg(value) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let parsedValue;
-    const isString = () => (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith(`'`) && value.endsWith(`'`));
-    const isArray = () => value.startsWith("[") && value.endsWith("]");
-    // Apply JSON parse to parse array or string if the value is wrapped into a string or array
-    if (isString() || isArray()) {
-        parsedValue = JSON.parse(value);
-    }
-    else {
-        parsedValue = value;
-    }
-    // If it's a string, it might contain an identifier to load ,or it might be a hidden array
-    if (typeof parsedValue === "string") {
-        const [source] = parsedValue.split(":");
-        const [origin, type] = source.split(".");
-        if (origin === "core") {
+export function loadArgType(scanResult, parentName, fnName, argName) {
+    const classTypeDef = scanResult.classes[parentName];
+    if (!classTypeDef) {
+        throw new Error(`could not find class ${parentName}`);
+    }
+    // Call for the constructor
+    if (fnName === "") {
+        const argTypeDef = classTypeDef.constructor?.args[argName];
+        if (!argTypeDef) {
+            throw new Error(`could not find argument ${argName} type in constructor`);
+        }
+        return argTypeDef.typeDef;
+    }
+    const methodTypeDef = classTypeDef.methods[fnName];
+    if (!methodTypeDef) {
+        throw new Error(`could not find method ${fnName}`);
+    }
+    const argTypeDef = methodTypeDef.args[argName];
+    if (!argTypeDef) {
+        throw new Error(`could not find argument ${argName} type`);
+    }
+    return argTypeDef.typeDef;
+}
+/**
+ * Load the property type from the scan result.
+ *
+ * @param scanResult Result of the scan
+ * @param parentName Class called
+ * @param propertyName property of the class
+ * @returns the type of the property
+ */
+export function loadPropertyType(scanResult, parentName, propertyName) {
+    const classTypeDef = scanResult.classes[parentName];
+    if (!classTypeDef) {
+        throw new Error(`could not find class ${parentName}`);
+    }
+    const propertyTypeDef = classTypeDef.fields[propertyName];
+    if (!propertyTypeDef) {
+        throw new Error(`could not find property ${propertyName} type`);
+    }
+    return propertyTypeDef.typeDef;
+}
+/**
+ * This function load the argument as a Dagger type.
+ *
+ * Note: The JSON.parse() is required to remove extra quotes
+ */
+export async function loadArg(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 loadArg(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
-            return dag[`load${type}FromID`](parsedValue);
+            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 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:
+            return value;
+        default:
+            throw new Error(`unsupported type ${type.kind}`);
+    }
+}
+/**
+ * Load subfields of the result and IDable object.
+ *
+ * @param result The result of the invocation.
+ * @returns Loaded result.
+ */
+export async function loadResult(result) {
+    if (result && typeof result?.id === "function") {
+        result = await result.id();
+    }
+    if (typeof result === "object") {
+        for (const [key, value] of Object.entries(result)) {
+            result[key] = await loadResult(value);
         }
     }
-    return parsedValue;
+    return result;
 }

package/dist/entrypoint/register.d.ts

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

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

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../entrypoint/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAGT,MAAM,mBAAmB,CAAA;AAW1B;;GAEG;AACH,wBAAsB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAoCjE"}
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../entrypoint/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAGT,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAU5D;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,QAAQ,CAAC,CAqCnB"}

package/dist/entrypoint/register.js

@@ -1,31 +1,30 @@
-import { dag, TypeDefKind, } from "../api/client.gen";
-import { scan } from "../introspector/scanner/scan.js";
+import { dag, TypeDefKind, } from "../api/client.gen.js";
 /**
  * Register the module files and returns its ID
  */
-export async function register(files) {
-    // Scan all files
-    const scanResult = await scan(files);
-    // Get the current module
-    let mod = dag.currentModule();
+export async function register(files, scanResult) {
+    // Get a new module that we will fill in with all the types
+    let mod = dag.module_();
     // For each class scanned, register its type, method and properties in the module.
-    scanResult.classes.forEach((modClass) => {
+    Object.values(scanResult.classes).map((modClass) => {
         // Register the class Typedef object in Dagger
         let typeDef = dag.typeDef().withObject(modClass.name, {
             description: modClass.description,
         });
         // Register all functions (methods) to this object
-        modClass.methods.forEach((method) => {
+        Object.values(modClass.methods).forEach((method) => {
             typeDef = typeDef.withFunction(addFunction(method));
         });
         // Register all fields that belong to this object
-        modClass.fields.forEach((field) => {
-            typeDef = typeDef.withField(field.name, addTypeDef(field.typeDef), {
-                description: field.description,
-            });
+        Object.values(modClass.fields).forEach((field) => {
+            if (field.isExposed) {
+                typeDef = typeDef.withField(field.name, addTypeDef(field.typeDef), {
+                    description: field.description,
+                });
+            }
         });
         if (modClass.constructor) {
-            typeDef.withConstructor(addConstructor(modClass.constructor, typeDef));
+            typeDef = typeDef.withConstructor(addConstructor(modClass.constructor, typeDef));
         }
         // Add it to the module object
         mod = mod.withObject(typeDef);
@@ -53,7 +52,7 @@ function addFunction(fct) {
  */
 function addArg(args) {
     return function (fct) {
-        args.forEach((arg) => {
+        Object.values(args).forEach((arg) => {
             const opts = {
                 description: arg.description,
             };
@@ -81,11 +80,11 @@ function addArg(args) {
  */
 function addTypeDef(type) {
     switch (type.kind) {
-        case TypeDefKind.Objectkind:
+        case TypeDefKind.ObjectKind:
             return dag.typeDef().withObject(type.name);
-        case TypeDefKind.Listkind:
+        case TypeDefKind.ListKind:
             return dag.typeDef().withListOf(addTypeDef(type.typeDef));
-        case TypeDefKind.Voidkind:
+        case TypeDefKind.VoidKind:
             return dag.typeDef().withKind(type.kind).withOptional(true);
         default:
             return dag.typeDef().withKind(type.kind);

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export { GraphQLClient } from "graphql-request";
 export { connect, CallbackFct, connection, close } from "./connect.js";
 export { 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

@@ -1 +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,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,cAAc,yCAAyC,CAAA"}
+{"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,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,cAAc,yCAAyC,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA"}

package/dist/index.js

@@ -4,3 +4,4 @@ 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/registry/registry.d.ts

@@ -1,3 +1,4 @@
+import "reflect-metadata";
 export type Class = {
     new (...args: any[]): any;
 };
@@ -20,7 +21,6 @@ export type Args = Record<string, unknown>;
  * RegistryClass.
  */
 export declare class Registry {
-    private classes;
     /**
      * The definition of the @object decorator that should be on top of any
      * class module that must be exposed to the Dagger API.
@@ -49,14 +49,6 @@ export declare class Registry {
      * @param inputs The input to send to the method to call
      */
     getResult(object: string, method: string, state: State, inputs: Args): Promise<any>;
-    /**
-     * Get the order of argument by reading its content and create an array of its argument
-     * We cannot use r[method].prototype because it can be empty depending on the loading.
-     * Note(TomChv): This is a workaround until we find something more accurate.
-     * @param fct
-     * @private
-     */
-    private getArgOrder;
 }
 /**
  * The default registry used in any module.

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

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../introspector/registry/registry.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,KAAK,GAAG;IAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAA;CAAE,CAAA;AAGjD,MAAM,MAAM,KAAK,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAA;AAE/C,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAa1C;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,OAAO,CAAoB;IAEnC;;;;OAIG;IACH,MAAM,yCA4BL;IAED;;;OAGG;IAEH,KAAK,WAAY,MAAM,eAAe,MAAM,UAE3C;IAED;;;OAGG;IACH,IAAI,WAEM,MAAM,eAED,MAAM,GAAG,MAAM,cAEhB,kBAAkB,UAK/B;IAED;;;;;;;;;;OAUG;IACG,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,IAAI,GAEX,OAAO,CAAC,GAAG,CAAC;IAwCf;;;;;;OAMG;IAEH,OAAO,CAAC,WAAW;CAWpB;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,UAAiB,CAAA"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../introspector/registry/registry.ts"],"names":[],"mappings":"AAGA,OAAO,kBAAkB,CAAA;AAIzB,MAAM,MAAM,KAAK,GAAG;IAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAA;CAAE,CAAA;AAEjD,MAAM,MAAM,KAAK,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAA;AAE/C,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAW1C;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB;;;;OAIG;IACH,MAAM,yCA+BL;IAED;;;OAGG;IACH,KAAK,WAAY,MAAM,eAAe,MAAM,UAE3C;IAED;;;OAGG;IACH,IAAI,WACM,MAAM,eACD,MAAM,GAAG,MAAM,cAChB,kBAAkB,UAK/B;IAED;;;;;;;;;;OAUG;IACG,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,IAAI,GACX,OAAO,CAAC,GAAG,CAAC;CAiChB;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,UAAiB,CAAA"}

package/dist/introspector/registry/registry.js

@@ -1,3 +1,6 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import "reflect-metadata";
 import { UnknownDaggerError } from "../../common/errors/UnknownDaggerError.js";
 /**
  * Registry stores class and method that have the @object decorator.
@@ -14,7 +17,6 @@ import { UnknownDaggerError } from "../../common/errors/UnknownDaggerError.js";
  * RegistryClass.
  */
 export class Registry {
-    classes = {};
     /**
      * The definition of the @object decorator that should be on top of any
      * class module that must be exposed to the Dagger API.
@@ -37,15 +39,13 @@ export class Registry {
             methods.push(...ownMethods);
             proto = Object.getPrototypeOf(proto);
         }
-        // Add this to the registry
-        this.classes[constructor.name] = { class_: constructor, methods };
+        Reflect.defineMetadata(constructor.name, { class_: constructor, methods }, this);
         return constructor;
     };
     /**
      * The definition of @field decorator that should be on top of any
      * class' property that must be exposed to the Dagger API.
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     field = (target, propertyKey) => {
         // A placeholder to declare fields
     };
@@ -53,13 +53,7 @@ export class Registry {
      * The definition of @func decorator that should be on top of any
      * class' method that must be exposed to the Dagger API.
      */
-    func = (
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    target, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    propertyKey, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    descriptor) => {
+    func = (target, propertyKey, descriptor) => {
         // The logic is done in the object constructor since it's not possible to
         // access the class parent's name from a method constructor without calling
         // the method itself
@@ -75,17 +69,15 @@ export class Registry {
      * @param state The current state of the class
      * @param inputs The input to send to the method to call
      */
-    async getResult(object, method, state, inputs
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) {
+    async getResult(object, method, state, inputs) {
         // Retrieve the resolver class from its key
-        const resolver = this.classes[object];
+        const resolver = Reflect.getMetadata(object, this);
         if (!resolver) {
             throw new UnknownDaggerError(`${object} is not register as a resolver`, {});
         }
         // If method is nil, apply the constructor.
         if (method === "") {
-            return new resolver.class_(...this.getArgOrder(resolver.class_).map((arg) => inputs[arg]));
+            return new resolver.class_(...Object.values(inputs));
         }
         // Safety check to make sure the method called exist in the class
         // to avoid the app to crash brutally.
@@ -93,30 +85,11 @@ export class Registry {
             throw new UnknownDaggerError(`${method} is not registered in the resolver ${object}`, {});
         }
         // Instantiate the class
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let r = new resolver.class_();
         // Apply state to the class
         r = Object.assign(r, state);
-        // Order argument following the arg order and picking argument from the inputs map
-        const args = this.getArgOrder(r[method]).map((arg) => inputs[arg]);
         // Execute and return the result
-        return await r[method](...args);
-    }
-    /**
-     * Get the order of argument by reading its content and create an array of its argument
-     * We cannot use r[method].prototype because it can be empty depending on the loading.
-     * Note(TomChv): This is a workaround until we find something more accurate.
-     * @param fct
-     * @private
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    getArgOrder(fct) {
-        const fnStr = fct
-            .toString()
-            .replace(/((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm, "");
-        return (fnStr
-            .slice(fnStr.indexOf("(") + 1, fnStr.indexOf(")"))
-            .match(/\b(\w+)\b(?:(?=\s*[:=?]|,\s*|$))/g) ?? []);
+        return await r[method](...Object.values(inputs));
     }
 }
 /**