@dagger.io/dagger 0.13.7 → 0.15.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../../../src/module/entrypoint/invoke.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAIL,YAAY,EAEb,MAAM,wCAAwC,CAAA;AAE/C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAcxC;;;;;;;;GAQG;AACH,wBAAsB,MAAM,CAC1B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,SAAS,gBAwDf"}

package/dist/{entrypoint → src/module/entrypoint}/invoke.js

@@ -1,5 +1,5 @@
-import { FunctionNotFound } from "../common/errors/FunctionNotFound.js";
-import { registry } from "../introspector/registry/registry.js";
+import { FunctionNotFound } from "../../common/errors/index.js";
+import { registry } from "../registry.js";
 import { loadResult, loadInvokedMethod, loadInvokedObject, loadArgs, loadParentState, loadObjectReturnType, } from "./load.js";
 function isConstructor(method) {
     return method.name === "";

package/dist/{entrypoint → src/module/entrypoint}/load.d.ts

@@ -1,13 +1,8 @@
 import Module from "node:module";
-import { TypeDefKind } from "../api/client.gen.js";
-import { Executor } from "../introspector/executor/executor.js";
-import { Args } from "../introspector/executor/executor.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 { TypeDefKind } from "../../api/client.gen.js";
+import { Executor, Args } from "../executor.js";
+import { DaggerConstructor as Constructor, DaggerFunction as Method, DaggerEnumBase, DaggerModule, DaggerObject, DaggerObjectBase } from "../introspector/dagger_module/index.js";
+import { TypeDef } from "../introspector/typedef.js";
 import { InvokeCtx } from "./context.js";
 /**
  * Import all given typescript files so that trigger their decorators
@@ -53,6 +48,6 @@ export declare function loadValue(executor: Executor, value: any, type: TypeDef<
  * @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>;
+export declare function loadObjectReturnType(module: DaggerModule, object: DaggerObject, method: Method): DaggerObjectBase | DaggerEnumBase;
+export declare function loadResult(result: any, module: DaggerModule, object: DaggerObjectBase | DaggerEnumBase): Promise<any>;
 //# sourceMappingURL=load.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../../src/module/entrypoint/load.ts"],"names":[],"mappings":"AACA,OAAO,MAAM,MAAM,aAAa,CAAA;AAEhC,OAAO,EAAO,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EACL,iBAAiB,IAAI,WAAW,EAChC,cAAc,IAAI,MAAM,EAExB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,gBAAgB,EACjB,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExC;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAE7D;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,CA6Cf;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,SAAS,GACb,OAAO,CAAC,IAAI,CAAC,CAiBf;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,CA2Cd;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACb,gBAAgB,GAAG,cAAc,CAwBnC;AAED,wBAAsB,UAAU,CAC9B,MAAM,EAAE,GAAG,EACX,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,gBAAgB,GAAG,cAAc,GACxC,OAAO,CAAC,GAAG,CAAC,CA8Ed"}

package/dist/{entrypoint → src/module/entrypoint}/load.js

@@ -1,6 +1,5 @@
-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 { dag, TypeDefKind } from "../../api/client.gen.js";
+import { DaggerEnum, DaggerObject, } from "../introspector/dagger_module/index.js";
 /**
  * Import all given typescript files so that trigger their decorators
  * and register their class and functions inside the Registry.
@@ -34,11 +33,14 @@ export function loadInvokedMethod(object, ctx) {
 export async function loadArgs(executor, method, ctx) {
     const args = {};
     // Load arguments
-    for (const argName of method.getArgOrder()) {
+    for (const argName of method.getArgsOrder()) {
         const argument = method.arguments[argName];
         if (!argument) {
             throw new Error(`could not find argument ${argName}`);
         }
+        if (!argument.type) {
+            throw new Error(`could not find type for argument ${argName}`);
+        }
         const loadedArg = await loadValue(executor, 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.
@@ -73,6 +75,9 @@ export async function loadParentState(executor, object, ctx) {
         if (!property) {
             throw new Error(`could not find parent property ${key}`);
         }
+        if (!property.type) {
+            throw new Error(`could not find type for parent property ${key}`);
+        }
         parentState[property.name] = await loadValue(executor, value, property.type);
     }
     return parentState;
@@ -100,7 +105,6 @@ export async function loadValue(executor, value, type) {
                 // @ts-ignore
                 return dag[`load${objectType}FromID`](value);
             }
-            // TODO(supports subfields serialization)
             return executor.buildClass(objectType, value);
         }
         // Cannot use `,` to specify multiple matching case so instead we use fallthrough.
@@ -126,6 +130,9 @@ export async function loadValue(executor, value, type) {
  */
 export function loadObjectReturnType(module, object, method) {
     const retType = method.returnType;
+    if (!retType) {
+        throw new Error(`could not find return type for ${method.name}`);
+    }
     switch (retType.kind) {
         case TypeDefKind.ListKind: {
             // Loop until we find the original object type.
@@ -162,6 +169,9 @@ export async function loadResult(result, module, object) {
             if (!property) {
                 throw new Error(`could not find result property ${key}`);
             }
+            if (!property.type) {
+                throw new Error(`could not find type for result property ${key}`);
+            }
             let referencedObject = undefined;
             // Handle nested objects
             if (property.type.kind === TypeDefKind.ObjectKind) {

package/dist/src/module/entrypoint/register.d.ts

@@ -0,0 +1,7 @@
+import { ModuleID } from "../../api/client.gen.js";
+import { DaggerModule } from "../introspector/dagger_module/index.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/src/module/entrypoint/register.d.ts.map

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

package/dist/{entrypoint → src/module/entrypoint}/register.js

@@ -1,4 +1,4 @@
-import { dag, TypeDefKind, } from "../api/client.gen.js";
+import { dag, TypeDefKind, } from "../../api/client.gen.js";
 /**
  * Register the module files and returns its ID
  */
@@ -85,9 +85,9 @@ function addArg(args) {
             // 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 (arg.defaultValue !== undefined) {
                 if (isPrimitiveType(arg.type)) {
-                    opts.defaultValue = arg.defaultValue;
+                    opts.defaultValue = JSON.stringify(arg.defaultValue);
                 }
                 else {
                     typeDef = typeDef.withOptional(true);

package/dist/{introspector/executor → src/module}/executor.d.ts

@@ -1,12 +1,14 @@
 import Module from "node:module";
+import { DaggerModule } from "./introspector/dagger_module/index.js";
 export type State = {
     [property: string]: any;
 };
 export type Args = Record<string, unknown>;
 export declare class Executor {
     readonly modules: Module[];
-    constructor(modules: Module[]);
-    private getObject;
+    private readonly daggerModule;
+    constructor(modules: Module[], daggerModule: DaggerModule);
+    private getExportedObject;
     buildClass(object: string, state: State): any;
     getResult(object: string, method: string, state: State, inputs: Args): Promise<any>;
 }

package/dist/src/module/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/module/executor.ts"],"names":[],"mappings":"AACA,OAAO,MAAM,MAAM,aAAa,CAAA;AAGhC,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAA;AAEpE,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;AAE1C,qBAAa,QAAQ;aAED,OAAO,EAAE,MAAM,EAAE;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY;gBADb,OAAO,EAAE,MAAM,EAAE,EAChB,YAAY,EAAE,YAAY;IAG7C,OAAO,CAAC,iBAAiB;IAUzB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,GAAG;IAuBvC,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,IAAI,GACX,OAAO,CAAC,GAAG,CAAC;CAchB"}

package/dist/src/module/executor.js

@@ -0,0 +1,45 @@
+import { FunctionNotFound } from "../common/errors/index.js";
+export class Executor {
+    modules;
+    daggerModule;
+    constructor(modules, daggerModule) {
+        this.modules = modules;
+        this.daggerModule = daggerModule;
+    }
+    getExportedObject(object) {
+        const key = object;
+        const module = this.modules.find((m) => m[key] !== undefined);
+        if (!module) {
+            throw new FunctionNotFound(`Object ${object} not found`);
+        }
+        return module[key];
+    }
+    buildClass(object, state) {
+        const daggerObject = this.daggerModule.objects[object];
+        if (!daggerObject) {
+            throw new FunctionNotFound(`Object ${object} not found in the introspection`);
+        }
+        switch (daggerObject.kind()) {
+            case "class": {
+                const obj = this.getExportedObject(object);
+                const instanciatedClass = Object.create(obj.prototype);
+                Object.assign(instanciatedClass, state);
+                return instanciatedClass;
+            }
+            case "object": {
+                return state;
+            }
+        }
+    }
+    async getResult(object, method, state, inputs) {
+        const obj = this.getExportedObject(object);
+        if (method === "") {
+            return new obj(...Object.values(inputs));
+        }
+        const builtObj = this.buildClass(object, state);
+        if (!builtObj[method]) {
+            throw new FunctionNotFound(`Method ${method} not found`);
+        }
+        return await builtObj[method](...Object.values(inputs));
+    }
+}

package/dist/src/module/introspector/case_convertor.d.ts

@@ -0,0 +1,2 @@
+export declare function convertToPascalCase(input: string): string;
+//# sourceMappingURL=case_convertor.d.ts.map

package/dist/src/module/introspector/case_convertor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"case_convertor.d.ts","sourceRoot":"","sources":["../../../../src/module/introspector/case_convertor.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAoBzD"}

package/dist/src/module/introspector/case_convertor.js

@@ -0,0 +1,17 @@
+export function convertToPascalCase(input) {
+    const words = input
+        .replace(/[^a-zA-Z0-9]/g, " ") // Replace non-alphanumeric characters with spaces
+        .split(/\s+/)
+        .filter((word) => word.length > 0);
+    if (words.length === 0) {
+        return ""; // No valid words found
+    }
+    // It's an edge case when moduleName is already in PascalCase or camelCase
+    if (words.length === 1) {
+        return words[0].charAt(0).toUpperCase() + words[0].slice(1);
+    }
+    const pascalCase = words
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+    return pascalCase;
+}

package/dist/src/module/introspector/dagger_module/argument.d.ts

@@ -0,0 +1,47 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typedef.js";
+import { AST } from "../typescript_module/index.js";
+import { References } from "./reference.js";
+export type DaggerArguments = {
+    [name: string]: DaggerArgument;
+};
+export declare class DaggerArgument {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    private _typeRef?;
+    type?: TypeDef<TypeDefKind>;
+    isVariadic: boolean;
+    isNullable: boolean;
+    isOptional: boolean;
+    defaultPath?: string;
+    ignore?: string[];
+    defaultValue?: any;
+    private symbol;
+    constructor(node: ts.ParameterDeclaration, ast: AST);
+    /**
+     * Get the type of the parameter.
+     *
+     * If for it's a complex type that cannot be
+     * resolve yet, we save its string representation for further reference.
+     */
+    private getType;
+    private getIsNullable;
+    private getDefaultValue;
+    getReference(): string | undefined;
+    propagateReferences(references: References): void;
+    toJSON(): {
+        name: string;
+        description: string;
+        type: TypeDef<TypeDefKind> | undefined;
+        isVariadic: boolean;
+        isNullable: boolean;
+        isOptional: boolean;
+        defaultValue: any;
+        defaultPath: string | undefined;
+        ignore: string[] | undefined;
+    };
+}
+//# sourceMappingURL=argument.d.ts.map

package/dist/src/module/introspector/dagger_module/argument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/argument.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAGxD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EACL,GAAG,EAGJ,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,MAAM,MAAM,eAAe,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAA;CAAE,CAAA;AAEhE,qBAAa,cAAc;IAevB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAff,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IAC1B,OAAO,CAAC,QAAQ,CAAC,CAAQ;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;IAC3B,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,YAAY,CAAC,EAAE,GAAG,CAAA;IAEzB,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,oBAAoB,EAC7B,GAAG,EAAE,GAAG;IA6B3B;;;;;OAKG;IACH,OAAO,CAAC,OAAO;IAWf,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,eAAe;IAShB,YAAY,IAAI,MAAM,GAAG,SAAS;IAWlC,mBAAmB,CAAC,UAAU,EAAE,UAAU;IAmBjD,MAAM;;;;;;;;;;;CAaP"}

package/dist/src/module/introspector/dagger_module/argument.js

@@ -0,0 +1,109 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import ts from "typescript";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST, isTypeDefResolved, resolveTypeDef, } from "../typescript_module/index.js";
+import { ARGUMENT_DECORATOR } from "./decorator.js";
+export class DaggerArgument {
+    node;
+    ast;
+    name;
+    description;
+    _typeRef;
+    type;
+    isVariadic;
+    isNullable;
+    isOptional;
+    defaultPath;
+    ignore;
+    defaultValue;
+    symbol;
+    constructor(node, ast) {
+        this.node = node;
+        this.ast = ast;
+        this.symbol = this.ast.getSymbolOrThrow(node.name);
+        this.name = this.node.name.getText();
+        this.description = this.ast.getDocFromSymbol(this.symbol);
+        this.defaultValue = this.getDefaultValue();
+        this.isVariadic = this.node.dotDotDotToken !== undefined;
+        this.isNullable = this.getIsNullable();
+        this.isOptional =
+            this.isVariadic || // if arguments has ...
+                (this.defaultValue === undefined && // if argument has a default value that couldn't be resolved.
+                    this.node.initializer !== undefined) ||
+                this.isNullable || // if argument is nullable
+                this.node.questionToken !== undefined; // if argument has ?
+        const decoratorArguments = this.ast.getDecoratorArgument(this.node, ARGUMENT_DECORATOR, "object");
+        if (decoratorArguments) {
+            this.ignore = decoratorArguments.ignore;
+            this.defaultPath = decoratorArguments.defaultPath;
+        }
+        this.type = this.getType();
+    }
+    /**
+     * Get the type of the parameter.
+     *
+     * If for it's a complex type that cannot be
+     * resolve yet, we save its string representation for further reference.
+     */
+    getType() {
+        const type = this.ast.checker.getTypeAtLocation(this.node);
+        const typedef = this.ast.tsTypeToTypeDef(this.node, type);
+        if (typedef === undefined || !isTypeDefResolved(typedef)) {
+            this._typeRef = this.ast.typeToStringType(type);
+        }
+        return typedef;
+    }
+    getIsNullable() {
+        if (!this.node.type) {
+            return false;
+        }
+        if (ts.isUnionTypeNode(this.node.type)) {
+            for (const _type of this.node.type.types) {
+                if (_type.getText() === "null") {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    getDefaultValue() {
+        const initializer = this.node.initializer;
+        if (!initializer) {
+            return undefined;
+        }
+        return this.ast.resolveParameterDefaultValue(initializer);
+    }
+    getReference() {
+        if (this._typeRef &&
+            (this.type === undefined || !isTypeDefResolved(this.type))) {
+            return this._typeRef;
+        }
+        return undefined;
+    }
+    propagateReferences(references) {
+        if (!this._typeRef) {
+            return;
+        }
+        if (this.type && isTypeDefResolved(this.type)) {
+            return;
+        }
+        const typeDef = references[this._typeRef];
+        if (!typeDef) {
+            throw new IntrospectionError(`could not find type reference for ${this._typeRef} at ${AST.getNodePosition(this.node)}.`);
+        }
+        this.type = resolveTypeDef(this.type, typeDef);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            type: this.type,
+            isVariadic: this.isVariadic,
+            isNullable: this.isNullable,
+            isOptional: this.isOptional,
+            defaultValue: this.defaultValue,
+            defaultPath: this.defaultPath,
+            ignore: this.ignore,
+        };
+    }
+}

package/dist/src/module/introspector/dagger_module/constructor.d.ts

@@ -0,0 +1,18 @@
+import ts from "typescript";
+import { AST } from "../typescript_module/index.js";
+import { DaggerArguments } from "./argument.js";
+import { References } from "./reference.js";
+export declare class DaggerConstructor {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    arguments: DaggerArguments;
+    constructor(node: ts.ConstructorDeclaration, ast: AST);
+    getArgsOrder(): string[];
+    getReferences(): string[];
+    propagateReferences(references: References): void;
+    toJSON(): {
+        arguments: DaggerArguments;
+    };
+}
+//# sourceMappingURL=constructor.d.ts.map

package/dist/src/module/introspector/dagger_module/constructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructor.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/constructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,GAAG,EAAE,MAAM,+BAA+B,CAAA;AACnD,OAAO,EAAkB,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,qBAAa,iBAAiB;IAK1B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IALf,IAAI,EAAE,MAAM,CAAK;IACjB,SAAS,EAAE,eAAe,CAAK;gBAGnB,IAAI,EAAE,EAAE,CAAC,sBAAsB,EAC/B,GAAG,EAAE,GAAG;IAYpB,YAAY,IAAI,MAAM,EAAE;IAIxB,aAAa,IAAI,MAAM,EAAE;IAazB,mBAAmB,CAAC,UAAU,EAAE,UAAU;IAMjD,MAAM;;;CAKP"}

package/dist/src/module/introspector/dagger_module/constructor.js

@@ -0,0 +1,38 @@
+import { DaggerArgument } from "./argument.js";
+export class DaggerConstructor {
+    node;
+    ast;
+    name = "";
+    arguments = {};
+    constructor(node, ast) {
+        this.node = node;
+        this.ast = ast;
+        const parameters = this.node.parameters;
+        for (const parameter of parameters) {
+            this.arguments[parameter.name.getText()] = new DaggerArgument(parameter, this.ast);
+        }
+    }
+    getArgsOrder() {
+        return Object.keys(this.arguments);
+    }
+    getReferences() {
+        const references = [];
+        for (const argument of Object.values(this.arguments)) {
+            const ref = argument.getReference();
+            if (ref) {
+                references.push(ref);
+            }
+        }
+        return references;
+    }
+    propagateReferences(references) {
+        for (const argument of Object.values(this.arguments)) {
+            argument.propagateReferences(references);
+        }
+    }
+    toJSON() {
+        return {
+            arguments: this.arguments,
+        };
+    }
+}

package/dist/src/module/introspector/dagger_module/decorator.d.ts

@@ -0,0 +1,7 @@
+export type DaggerDecorators = "object" | "func" | "argument" | "enumType" | "field";
+export declare const OBJECT_DECORATOR: DaggerDecorators;
+export declare const FUNCTION_DECORATOR: DaggerDecorators;
+export declare const FIELD_DECORATOR: DaggerDecorators;
+export declare const ARGUMENT_DECORATOR: DaggerDecorators;
+export declare const ENUM_DECORATOR: DaggerDecorators;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/src/module/introspector/dagger_module/decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorator.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/decorator.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,gBAAgB,GACxB,QAAQ,GACR,MAAM,GACN,UAAU,GACV,UAAU,GACV,OAAO,CAAA;AAEX,eAAO,MAAM,gBAAgB,EAAkB,gBAAgB,CAAA;AAC/D,eAAO,MAAM,kBAAkB,EAAgB,gBAAgB,CAAA;AAC/D,eAAO,MAAM,eAAe,EAAiB,gBAAgB,CAAA;AAC7D,eAAO,MAAM,kBAAkB,EAAoB,gBAAgB,CAAA;AACnE,eAAO,MAAM,cAAc,EAAoB,gBAAgB,CAAA"}

package/dist/src/module/introspector/dagger_module/decorator.js

@@ -0,0 +1,6 @@
+import { argument, func, object, enumType, field } from "../../decorators.js";
+export const OBJECT_DECORATOR = object.name;
+export const FUNCTION_DECORATOR = func.name;
+export const FIELD_DECORATOR = field.name;
+export const ARGUMENT_DECORATOR = argument.name;
+export const ENUM_DECORATOR = enumType.name;

package/dist/src/module/introspector/dagger_module/enum.d.ts

@@ -0,0 +1,37 @@
+import ts from "typescript";
+import { AST } from "../typescript_module/index.js";
+import { DaggerEnumBase, DaggerEnumBaseValue } from "./enumBase.js";
+export type DaggerEnums = {
+    [name: string]: DaggerEnum;
+};
+export type DaggerEnumValues = {
+    [name: string]: DaggerEnumValue;
+};
+export declare class DaggerEnumValue implements DaggerEnumBaseValue {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    value: string;
+    description: string;
+    private symbol;
+    constructor(node: ts.EnumMember, ast: AST);
+    toJSON(): {
+        name: string;
+        description: string;
+    };
+}
+export declare class DaggerEnum implements DaggerEnumBase {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    values: DaggerEnumValues;
+    private symbol;
+    constructor(node: ts.EnumDeclaration, ast: AST);
+    toJSON(): {
+        name: string;
+        description: string;
+        values: DaggerEnumValues;
+    };
+}
+//# sourceMappingURL=enum.d.ts.map

package/dist/src/module/introspector/dagger_module/enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/enum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAE,GAAG,EAAE,MAAM,+BAA+B,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AAEnE,MAAM,MAAM,WAAW,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAA;AACxD,MAAM,MAAM,gBAAgB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;CAAE,CAAA;AAElE,qBAAa,eAAgB,YAAW,mBAAmB;IAQvD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IARf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IAE1B,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,GAAG,EAAE,GAAG;IAgB3B,MAAM;;;;CAMP;AAED,qBAAa,UAAW,YAAW,cAAc;IAQ7C,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IARf,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,gBAAgB,CAAK;IAEpC,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,eAAe,EACxB,GAAG,EAAE,GAAG;IAc3B,MAAM;;;;;CAOP"}

package/dist/src/module/introspector/dagger_module/enum.js

@@ -0,0 +1,55 @@
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST } from "../typescript_module/index.js";
+export class DaggerEnumValue {
+    node;
+    ast;
+    name;
+    value;
+    description;
+    symbol;
+    constructor(node, ast) {
+        this.node = node;
+        this.ast = ast;
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        this.name = this.node.name.getText();
+        this.description = this.ast.getDocFromSymbol(this.symbol);
+        const initializer = this.node.initializer;
+        if (!initializer) {
+            throw new IntrospectionError(`enum ${this.name} at ${AST.getNodePosition(this.node)} has no value set to its member.`);
+        }
+        this.value = this.ast.resolveParameterDefaultValue(initializer);
+    }
+    toJSON() {
+        return {
+            name: this.value,
+            description: this.description,
+        };
+    }
+}
+export class DaggerEnum {
+    node;
+    ast;
+    name;
+    description;
+    values = {};
+    symbol;
+    constructor(node, ast) {
+        this.node = node;
+        this.ast = ast;
+        this.name = this.node.name.getText();
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        this.description = this.ast.getDocFromSymbol(this.symbol);
+        const members = this.node.members;
+        for (const member of members) {
+            const value = new DaggerEnumValue(member, this.ast);
+            this.values[value.name] = value;
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            values: this.values,
+        };
+    }
+}

package/dist/src/module/introspector/dagger_module/enumBase.d.ts

@@ -0,0 +1,17 @@
+export interface DaggerEnumBaseValue {
+    name: string;
+    value: string;
+    description: string;
+}
+export type DaggerEnumBaseValues = {
+    [name: string]: DaggerEnumBaseValue;
+};
+export interface DaggerEnumBase {
+    name: string;
+    description: string;
+    values: DaggerEnumBaseValues;
+}
+export type DaggerEnumsBase = {
+    [name: string]: DaggerEnumBase;
+};
+//# sourceMappingURL=enumBase.d.ts.map

package/dist/src/module/introspector/dagger_module/enumBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumBase.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/enumBase.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,oBAAoB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAAA;CAAE,CAAA;AAE1E,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,oBAAoB,CAAA;CAC7B;AAED,MAAM,MAAM,eAAe,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAA;CAAE,CAAA"}

package/dist/src/module/introspector/dagger_module/enumClass.d.ts

@@ -0,0 +1,37 @@
+import ts from "typescript";
+import { AST } from "../typescript_module/index.js";
+import { DaggerEnumBase, DaggerEnumBaseValue } from "./enumBase.js";
+export type DaggerEnumClasses = {
+    [name: string]: DaggerEnumClass;
+};
+export type DaggerEnumClassValues = {
+    [name: string]: DaggerEnumClassValue;
+};
+export declare class DaggerEnumClassValue implements DaggerEnumBaseValue {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    value: string;
+    description: string;
+    private symbol;
+    constructor(node: ts.PropertyDeclaration, ast: AST);
+    toJSON(): {
+        name: string;
+        description: string;
+    };
+}
+export declare class DaggerEnumClass implements DaggerEnumBase {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    values: DaggerEnumClassValues;
+    private symbol;
+    constructor(node: ts.ClassDeclaration, ast: AST);
+    toJSON(): {
+        name: string;
+        description: string;
+        values: DaggerEnumClassValues;
+    };
+}
+//# sourceMappingURL=enumClass.d.ts.map

package/dist/src/module/introspector/dagger_module/enumClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enumClass.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/enumClass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAE,GAAG,EAAE,MAAM,+BAA+B,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAA;AAEnE,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;CAAE,CAAA;AAEnE,MAAM,MAAM,qBAAqB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,oBAAoB,CAAA;CAAE,CAAA;AAE5E,qBAAa,oBAAqB,YAAW,mBAAmB;IAQ5D,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IARf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IAE1B,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,mBAAmB,EAC5B,GAAG,EAAE,GAAG;IAc3B,MAAM;;;;CAMP;AAED,qBAAa,eAAgB,YAAW,cAAc;IAQlD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IARf,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,qBAAqB,CAAK;IAEzC,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,gBAAgB,EACzB,GAAG,EAAE,GAAG;IAqB3B,MAAM;;;;;CAOP"}