@dagger.io/dagger 0.9.8 → 0.9.10

package/dist/entrypoint/entrypoint.js

@@ -14,11 +14,12 @@ 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();
+        const moduleName = await dag.currentModule().name();
         const parentName = await fnCall.parentName();
+        const scanResult = await scan(files, moduleName);
         // Pre allocate the result, we got one in both case.
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let result;

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,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"}
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../entrypoint/invoke.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAY,MAAM,sCAAsC,CAAA;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAY5D,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,CAmDX"}

package/dist/entrypoint/invoke.js

@@ -1,5 +1,6 @@
+import { TypeDefKind } from "../api/client.gen.js";
 import { registry } from "../introspector/registry/registry.js";
-import { loadArgOrder, loadArg, loadArgType, loadPropertyType, loadResult, } from "./load.js";
+import { loadArgOrder, loadArg, loadArgType, loadPropertyType, loadResult, isArgVariadic, loadName, } from "./load.js";
 /**
  * A wrapper around the registry to invoke a function.
  *
@@ -13,15 +14,34 @@ export async function invoke(scanResult, { parentName, fnName, parentArgs, fnArg
     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));
+        const loadedArg = await loadArg(fnArgs[argName], loadArgType(scanResult, parentName, fnName, argName));
+        if (isArgVariadic(scanResult, parentName, fnName, argName)) {
+            // 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.
+            for (const [i, arg] of (loadedArg ?? []).entries()) {
+                args[`${argName}${i}`] = arg;
+            }
+        }
+        else {
+            args[argName] = loadedArg;
+        }
     }
     // Load parent state
     for (const [key, value] of Object.entries(parentArgs)) {
-        parentArgs[key] = await loadArg(value, loadPropertyType(scanResult, parentName, key));
+        parentArgs[loadName(scanResult, parentName, key, "field")] = await loadArg(value, loadPropertyType(scanResult, parentName, key));
     }
-    let result = await registry.getResult(parentName, fnName, parentArgs, args);
+    let result = await registry.getResult(loadName(scanResult, parentName, parentName, "object"), loadName(scanResult, parentName, fnName, "function"), parentArgs, args);
     if (result) {
-        result = await loadResult(result);
+        // Handle alias serialization by getting the return type to load
+        // if the function called isn't a constructor.
+        if (fnName !== "") {
+            const retType = scanResult.classes[parentName].methods[fnName].returnType;
+            if (retType.kind === TypeDefKind.ObjectKind) {
+                parentName = retType.name;
+            }
+        }
+        result = await loadResult(result, scanResult, parentName);
     }
     return result;
 }

package/dist/entrypoint/load.d.ts

@@ -18,6 +18,17 @@ export declare function load(files: string[]): Promise<void>;
  * @returns An array of strings representing the order of arguments.
  */
 export declare function loadArgOrder(scanResult: ScanResult, parentName: string, fnName: string): string[];
+/**
+ * Load the argument for the given function and check if it's variadic.
+ *
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the class.
+ * @param fnName The name of the function.
+ * @param argName The name of the argument.
+ *
+ * @returns True if the argument is variadic, false otherwise.
+ */
+export declare function isArgVariadic(scanResult: ScanResult, parentName: string, fnName: string, argName: string): boolean;
 /**
  * Load the argument type from the scan result.
  *
@@ -37,6 +48,35 @@ export declare function loadArgType(scanResult: ScanResult, parentName: string,
  * @returns the type of the property
  */
 export declare function loadPropertyType(scanResult: ScanResult, parentName: string, propertyName: string): TypeDef<TypeDefKind>;
+/**
+ * Load the true name from the scan result
+ *
+ * @param scanResult Result of the scan
+ * @param parentName Class called
+ * @param alias exposed name
+ * @param kind location of the alias
+ */
+export declare function loadName(scanResult: ScanResult, parentName: string, alias: string, kind: "field" | "function" | "object"): string;
+/**
+ * Load the alias from the true property name.
+ * If not found, return the original alias because it's not
+ * a registered field.
+ *
+ * @param scanResult Result of the scan
+ * @param parentName Class called
+ * @param alias exposed name
+ */
+export declare function loadResultAlias(scanResult: ScanResult, parentName: string, alias: string): string;
+/**
+ * Return the eventual parent name of a field if its return type is a
+ * registered object.
+ * If not found, return the original parent name.
+ *
+ * @param scanResult The result of the scan.
+ * @param parentName Original parent name
+ * @param alias The field alias
+ */
+export declare function loadAliasParentName(scanResult: ScanResult, parentName: string, alias: string): string;
 /**
  * This function load the argument as a Dagger type.
  *
@@ -47,7 +87,9 @@ export declare function loadArg(value: any, type: TypeDef<TypeDefKind>): Promise
  * Load subfields of the result and IDable object.
  *
  * @param result The result of the invocation.
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the parent object.
  * @returns Loaded result.
  */
-export declare function loadResult(result: any): Promise<any>;
+export declare function loadResult(result: any, scanResult: ScanResult, parentName: string): 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":"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"}
+{"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;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,OAAO,CAiBT;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;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CACtB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,OAAO,GAAG,UAAU,GAAG,QAAQ,GACpC,MAAM,CAgCR;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,GACZ,MAAM,CAcR;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,GACZ,MAAM,CAkBR;AAED;;;;GAIG;AACH,wBAAsB,OAAO,CAC3B,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GACzB,OAAO,CAAC,GAAG,CAAC,CAsCd;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,GAAG,EACX,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,GAAG,CAAC,CAgBd"}

package/dist/entrypoint/load.js

@@ -33,6 +33,31 @@ export function loadArgOrder(scanResult, parentName, fnName) {
     }
     return Object.keys(methodTypeDef.args);
 }
+/**
+ * Load the argument for the given function and check if it's variadic.
+ *
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the class.
+ * @param fnName The name of the function.
+ * @param argName The name of the argument.
+ *
+ * @returns True if the argument is variadic, false otherwise.
+ */
+export function isArgVariadic(scanResult, parentName, fnName, argName) {
+    const classTypeDef = scanResult.classes[parentName];
+    if (!classTypeDef) {
+        throw new Error(`could not find class ${parentName}`);
+    }
+    // It's not possible to have variadic arguments in the constructor.
+    if (fnName === "") {
+        return false;
+    }
+    const methodTypeDef = classTypeDef.methods[fnName];
+    if (!methodTypeDef) {
+        throw new Error(`could not find method ${fnName}`);
+    }
+    return methodTypeDef.args[argName].isVariadic;
+}
 /**
  * Load the argument type from the scan result.
  *
@@ -84,6 +109,86 @@ export function loadPropertyType(scanResult, parentName, propertyName) {
     }
     return propertyTypeDef.typeDef;
 }
+/**
+ * Load the true name from the scan result
+ *
+ * @param scanResult Result of the scan
+ * @param parentName Class called
+ * @param alias exposed name
+ * @param kind location of the alias
+ */
+export function loadName(scanResult, parentName, alias, kind) {
+    const classTypeDef = scanResult.classes[parentName];
+    if (!classTypeDef) {
+        throw new Error(`could not find class ${parentName}`);
+    }
+    switch (kind) {
+        case "object": {
+            return classTypeDef.name;
+        }
+        case "function": {
+            // Handle constructor
+            if (alias === "") {
+                return "";
+            }
+            const methodTypeDef = classTypeDef.methods[alias];
+            if (!methodTypeDef) {
+                throw new Error(`could not find method ${alias} type`);
+            }
+            return methodTypeDef.name;
+        }
+        case "field": {
+            const propertyTypeDef = classTypeDef.fields[alias];
+            if (!propertyTypeDef) {
+                throw new Error(`could not find property ${alias}`);
+            }
+            return propertyTypeDef.name;
+        }
+    }
+}
+/**
+ * Load the alias from the true property name.
+ * If not found, return the original alias because it's not
+ * a registered field.
+ *
+ * @param scanResult Result of the scan
+ * @param parentName Class called
+ * @param alias exposed name
+ */
+export function loadResultAlias(scanResult, parentName, alias) {
+    const classTypeDef = scanResult.classes[parentName];
+    if (!classTypeDef) {
+        return alias;
+    }
+    const fieldTypeDef = Object.values(classTypeDef.fields).find((field) => field.name === alias);
+    if (!fieldTypeDef) {
+        return alias;
+    }
+    return fieldTypeDef.alias ?? fieldTypeDef.name;
+}
+/**
+ * Return the eventual parent name of a field if its return type is a
+ * registered object.
+ * If not found, return the original parent name.
+ *
+ * @param scanResult The result of the scan.
+ * @param parentName Original parent name
+ * @param alias The field alias
+ */
+export function loadAliasParentName(scanResult, parentName, alias) {
+    const classTypeDef = scanResult.classes[parentName];
+    if (!classTypeDef) {
+        return parentName;
+    }
+    const fieldTypeDef = Object.values(classTypeDef.fields).find((field) => field.name === alias);
+    if (!fieldTypeDef) {
+        return parentName;
+    }
+    if (fieldTypeDef.typeDef.kind === TypeDefKind.ObjectKind) {
+        return fieldTypeDef.typeDef.name;
+    }
+    return parentName;
+}
 /**
  * This function load the argument as a Dagger type.
  *
@@ -124,15 +229,17 @@ export async function loadArg(value, type) {
  * Load subfields of the result and IDable object.
  *
  * @param result The result of the invocation.
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the parent object.
  * @returns Loaded result.
  */
-export async function loadResult(result) {
+export async function loadResult(result, scanResult, parentName) {
     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);
+            result[loadResultAlias(scanResult, parentName, key)] = await loadResult(value, scanResult, loadAliasParentName(scanResult, parentName, key));
         }
     }
     return result;

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,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"}
+{"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,CA8CnB"}

package/dist/entrypoint/register.js

@@ -5,8 +5,12 @@ import { dag, TypeDefKind, } from "../api/client.gen.js";
 export async function register(files, scanResult) {
     // Get a new module that we will fill in with all the types
     let mod = dag.module_();
+    // Add module description if any.
+    if (scanResult.module.description) {
+        mod = mod.withDescription(scanResult.module.description);
+    }
     // For each class scanned, register its type, method and properties in the module.
-    Object.values(scanResult.classes).map((modClass) => {
+    Object.values(scanResult.classes).forEach((modClass) => {
         // Register the class Typedef object in Dagger
         let typeDef = dag.typeDef().withObject(modClass.name, {
             description: modClass.description,
@@ -18,7 +22,7 @@ export async function register(files, scanResult) {
         // Register all fields that belong to this object
         Object.values(modClass.fields).forEach((field) => {
             if (field.isExposed) {
-                typeDef = typeDef.withField(field.name, addTypeDef(field.typeDef), {
+                typeDef = typeDef.withField(field.alias ?? field.name, addTypeDef(field.typeDef), {
                     description: field.description,
                 });
             }
@@ -43,7 +47,7 @@ function addConstructor(constructor, owner) {
  */
 function addFunction(fct) {
     return dag
-        .function_(fct.name, addTypeDef(fct.returnType))
+        .function_(fct.alias ?? fct.name, addTypeDef(fct.returnType))
         .withDescription(fct.description)
         .with(addArg(fct.args));
 }

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

@@ -1,4 +1,4 @@
-export declare const object: <T extends import("../registry/registry.js").Class>(constructor: T) => T;
-export declare const func: (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
-export declare const field: (target: object, propertyKey: string) => void;
+export declare const object: () => <T extends import("../registry/registry.js").Class>(constructor: T) => T;
+export declare const func: (alias?: string | undefined) => (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+export declare const field: (alias?: string | undefined) => (target: object, propertyKey: string) => void;
 //# sourceMappingURL=decorators.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../../introspector/decorators/decorators.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM,0EAAkB,CAAA;AACrC,eAAO,MAAM,IAAI,wFAAgB,CAAA;AACjC,eAAO,MAAM,KAAK,+CAAiB,CAAA"}
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../../introspector/decorators/decorators.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM,gFAAkB,CAAA;AACrC,eAAO,MAAM,IAAI,wHAAgB,CAAA;AACjC,eAAO,MAAM,KAAK,+EAAiB,CAAA"}

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

@@ -26,17 +26,19 @@ export declare class Registry {
      * class module that must be exposed to the Dagger API.
      *
      */
-    object: <T extends Class>(constructor: T) => T;
+    object: () => <T extends Class>(constructor: T) => T;
     /**
      * The definition of @field decorator that should be on top of any
      * class' property that must be exposed to the Dagger API.
+     *
+     * @param alias The alias to use for the field when exposed on the API.
      */
-    field: (target: object, propertyKey: string) => void;
+    field: (alias?: string) => (target: object, propertyKey: string) => void;
     /**
      * The definition of @func decorator that should be on top of any
      * class' method that must be exposed to the Dagger API.
      */
-    func: (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+    func: (alias?: string) => (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
     /**
      * getResult check for the object and method in the registry and call it
      * with the given input and state.

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,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"}
+{"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;AAU1C;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB;;;;OAIG;IACH,MAAM,+CAML;IAED;;;;;OAKG;IACH,KAAK,WAAY,MAAM,cAAa,MAAM,eAAe,MAAM,KAAK,IAAI,CAIvE;IAED;;;OAGG;IACH,IAAI,WACM,MAAM,cAEN,MAAM,eACD,MAAM,GAAG,MAAM,cAChB,kBAAkB,KAC3B,IAAI,CAUR;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

@@ -22,41 +22,33 @@ export class Registry {
      * class module that must be exposed to the Dagger API.
      *
      */
-    object = (constructor) => {
-        const methods = [];
-        // Create a dummy instance of the constructor to loop through its properties
-        // We only register user's method and ignore TypeScript default method
-        let proto = new constructor();
-        while (proto && proto !== Object.prototype) {
-            const ownMethods = Object.getOwnPropertyNames(proto).filter((name) => {
-                const descriptor = Object.getOwnPropertyDescriptor(proto, name);
-                // Check if the descriptor exist, then if it's a function and finally
-                // if the function is owned by the class.
-                return (descriptor &&
-                    typeof descriptor.value === "function" &&
-                    Object.prototype.hasOwnProperty.call(proto, name));
-            });
-            methods.push(...ownMethods);
-            proto = Object.getPrototypeOf(proto);
-        }
-        Reflect.defineMetadata(constructor.name, { class_: constructor, methods }, this);
-        return constructor;
+    object = () => {
+        return (constructor) => {
+            Reflect.defineMetadata(constructor.name, { class_: constructor }, 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.
+     *
+     * @param alias The alias to use for the field when exposed on the API.
      */
-    field = (target, propertyKey) => {
-        // A placeholder to declare fields
+    field = (alias) => {
+        return (target, propertyKey) => {
+            // A placeholder to declare field in the registry.
+        };
     };
     /**
      * The definition of @func decorator that should be on top of any
      * class' method that must be exposed to the Dagger API.
      */
-    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
+    func = (alias) => {
+        return (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
+        };
     };
     /**
      * getResult check for the object and method in the registry and call it
@@ -79,13 +71,13 @@ export class Registry {
         if (method === "") {
             return new resolver.class_(...Object.values(inputs));
         }
+        // Instantiate the class without calling the constructor
+        let r = Object.create(resolver.class_.prototype);
         // Safety check to make sure the method called exist in the class
         // to avoid the app to crash brutally.
-        if (!resolver.methods.find((m) => m === method)) {
+        if (!r[method]) {
             throw new UnknownDaggerError(`${method} is not registered in the resolver ${object}`, {});
         }
-        // Instantiate the class
-        let r = new resolver.class_();
         // Apply state to the class
         r = Object.assign(r, state);
         // Execute and return the result

package/dist/introspector/scanner/metadata.d.ts

@@ -12,6 +12,7 @@ export type SymbolMetadata = {
 export type ParamMetadata = SymbolMetadata & {
     optional: boolean;
     defaultValue?: string;
+    isVariadic: boolean;
 };
 /**
  * Metadata of a function's signature.

package/dist/introspector/scanner/metadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/metadata.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG;IAC3C,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA"}
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/metadata.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,cAAc,GAAG;IAC3C,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,aAAa,EAAE,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA"}

package/dist/introspector/scanner/scan.d.ts

@@ -1,5 +1,8 @@
 import { ClassTypeDef, FunctionTypedef } from "./typeDefs.js";
 export type ScanResult = {
+    module: {
+        description?: string;
+    };
     classes: {
         [name: string]: ClassTypeDef;
     };
@@ -16,6 +19,7 @@ export type ScanResult = {
  * WARNING(28/11/23): This does NOT include arrow style function.
  *
  * @param files List of TypeScript files to introspect.
+ * @param moduleName The name of the module to introspect.
  */
-export declare function scan(files: string[]): ScanResult;
+export declare function scan(files: string[], moduleName?: string): ScanResult;
 //# sourceMappingURL=scan.d.ts.map

package/dist/introspector/scanner/scan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/scan.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EAIZ,eAAe,EAChB,MAAM,eAAe,CAAA;AAStB,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;KAAE,CAAA;IACzC,SAAS,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;KAAE,CAAA;CAC/C,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,UAAU,CA+BhD"}
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/scan.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,YAAY,EAIZ,eAAe,EAChB,MAAM,eAAe,CAAA;AAWtB,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE;QACN,WAAW,CAAC,EAAE,MAAM,CAAA;KACrB,CAAA;IACD,OAAO,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAA;KAAE,CAAA;IACzC,SAAS,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;KAAE,CAAA;CAC/C,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,SAAK,GAAG,UAAU,CAoCjE"}

package/dist/introspector/scanner/scan.js

@@ -1,7 +1,7 @@
 import ts from "typescript";
 import { UnknownDaggerError } from "../../common/errors/UnknownDaggerError.js";
 import { serializeSignature, serializeSymbol } from "./serialize.js";
-import { isFunction, isObject, isOptional, isPublicProperty, typeNameToTypedef, } from "./utils.js";
+import { getAlias, isFunction, isMainObject, isObject, isOptional, isPublicProperty, typeNameToTypedef, } from "./utils.js";
 /**
  * Scan the list of TypeScript File using the TypeScript compiler API.
  *
@@ -11,8 +11,9 @@ import { isFunction, isObject, isOptional, isPublicProperty, typeNameToTypedef,
  * WARNING(28/11/23): This does NOT include arrow style function.
  *
  * @param files List of TypeScript files to introspect.
+ * @param moduleName The name of the module to introspect.
  */
-export function scan(files) {
+export function scan(files, moduleName = "") {
     if (files.length === 0) {
         throw new UnknownDaggerError("no files to introspect found", {});
     }
@@ -20,6 +21,7 @@ export function scan(files) {
     const program = ts.createProgram(files, { experimentalDecorators: true });
     const checker = program.getTypeChecker();
     const metadata = {
+        module: {},
         classes: {},
         functions: {},
     };
@@ -32,6 +34,9 @@ export function scan(files) {
             // Handle class
             if (ts.isClassDeclaration(node) && isObject(node)) {
                 const classTypeDef = introspectClass(checker, node);
+                if (isMainObject(classTypeDef.name, moduleName)) {
+                    metadata.module.description = introspectTopLevelComment(file);
+                }
                 metadata.classes[classTypeDef.name] = classTypeDef;
             }
         });
@@ -78,12 +83,12 @@ function introspectClass(checker, node) {
         // Handle method from the class.
         if (ts.isMethodDeclaration(member) && isFunction(member)) {
             const fctTypeDef = introspectMethod(checker, member);
-            metadata.methods[fctTypeDef.name] = fctTypeDef;
+            metadata.methods[fctTypeDef.alias ?? fctTypeDef.name] = fctTypeDef;
         }
         // Handle public properties from the class.
         if (ts.isPropertyDeclaration(member)) {
             const fieldTypeDef = introspectProperty(checker, member);
-            metadata.fields[fieldTypeDef.name] = fieldTypeDef;
+            metadata.fields[fieldTypeDef.alias ?? fieldTypeDef.name] = fieldTypeDef;
         }
     });
     return metadata;
@@ -105,6 +110,7 @@ function introspectProperty(checker, property) {
     return {
         name,
         description,
+        alias: getAlias(property, "field"),
         typeDef: typeNameToTypedef(typeName),
         isExposed: isPublicProperty(property),
     };
@@ -126,6 +132,7 @@ function introspectConstructor(checker, constructor) {
             typeDef: typeNameToTypedef(typeName),
             optional,
             defaultValue,
+            isVariadic: false,
         };
         return acc;
     }, {});
@@ -154,16 +161,42 @@ function introspectMethod(checker, method) {
     return {
         name: methodMetadata.name,
         description: methodMetadata.description,
-        args: methodSignature.params.reduce((acc, { name, typeName, description, optional, defaultValue }) => {
+        alias: getAlias(method, "func"),
+        args: methodSignature.params.reduce((acc, { name, typeName, description, optional, defaultValue, isVariadic }) => {
             acc[name] = {
                 name,
                 typeDef: typeNameToTypedef(typeName),
                 description,
                 optional,
                 defaultValue,
+                isVariadic,
             };
             return acc;
         }, {}),
         returnType: typeNameToTypedef(methodSignature.returnType),
     };
 }
+/**
+ * Return the content of the top level comment of the given file.
+ *
+ * @param file The file to introspect.
+ */
+function introspectTopLevelComment(file) {
+    const firstStatement = file.statements[0];
+    if (!firstStatement) {
+        return undefined;
+    }
+    const commentRanges = ts.getLeadingCommentRanges(file.getFullText(), firstStatement.pos);
+    if (!commentRanges || commentRanges.length === 0) {
+        return undefined;
+    }
+    const commentRange = commentRanges[0];
+    const comment = file
+        .getFullText()
+        .substring(commentRange.pos, commentRange.end)
+        .split("\n")
+        .slice(1, -1) // Remove start and ending comments characters `/** */`
+        .map((line) => line.replace("*", "").trim()) // Remove leading * and spaces
+        .join("\n");
+    return comment;
+}

package/dist/introspector/scanner/serialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGjE;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,SAAS,EAAE,EAAE,CAAC,SAAS,GACtB,iBAAiB,CAanB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,MAAM,EAAE,EAAE,CAAC,MAAM,GAChB,cAAc,GAAG;IAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAA;CAAE,CAkBpC;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAS5E"}
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/serialize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAGjE;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,SAAS,EAAE,EAAE,CAAC,SAAS,GACtB,iBAAiB,CAmBnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,MAAM,EAAE,EAAE,CAAC,MAAM,GAChB,cAAc,GAAG;IAAE,IAAI,EAAE,EAAE,CAAC,IAAI,CAAA;CAAE,CAkBpC;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAS5E"}

package/dist/introspector/scanner/serialize.js

@@ -1,6 +1,6 @@
 import ts from "typescript";
 import { UnknownDaggerError } from "../../common/errors/UnknownDaggerError.js";
-import { isOptional } from "./utils.js";
+import { isOptional, isVariadic } from "./utils.js";
 /**
  * Convert the function signature from the compiler API into a lighter data type.
  *
@@ -12,11 +12,17 @@ import { isOptional } from "./utils.js";
 export function serializeSignature(checker, signature) {
     return {
         params: signature.parameters.map((param) => {
-            const { optional, defaultValue } = isOptional(param);
+            // eslint-disable-next-line prefer-const
+            let { optional, defaultValue } = isOptional(param);
+            const variadic = isVariadic(param);
+            if (variadic) {
+                optional = true;
+            }
             return {
                 ...serializeSymbol(checker, param),
                 optional,
                 defaultValue,
+                isVariadic: variadic,
             };
         }),
         returnType: serializeType(checker, signature.getReturnType()),

package/dist/introspector/scanner/typeDefs.d.ts

@@ -32,6 +32,7 @@ export type TypeDef<T extends BaseTypeDef["kind"]> = T extends TypeDefKind.Objec
  */
 export type FieldTypeDef = {
     name: string;
+    alias?: string;
     description: string;
     typeDef: TypeDef<TypeDefKind>;
     isExposed: boolean;
@@ -44,6 +45,7 @@ export type FunctionArg = {
     description: string;
     optional: boolean;
     defaultValue?: string;
+    isVariadic: boolean;
     typeDef: TypeDef<TypeDefKind>;
 };
 /**
@@ -52,6 +54,7 @@ export type FunctionArg = {
 export type FunctionTypedef = {
     name: string;
     description: string;
+    alias?: string;
     args: {
         [name: string]: FunctionArg;
     };