@dagger.io/dagger 0.0.1-0

package/dist/src/module/executor.js

@@ -0,0 +1,171 @@
+import { dag, TypeDefKind } from "../api/client.gen.js";
+import { Context } from "../common/context.js";
+import { FunctionNotFound } from "../common/errors/index.js";
+import { Connection } from "../common/graphql/connection.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 module`);
+        }
+        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;
+            }
+        }
+    }
+    /**
+     * Transform a Dagger interface identifier into an implementation of this
+     * interface serves as module call binding to reach the true implementation.
+     */
+    buildInterface(iface, id) {
+        const interfaceObject = this.daggerModule.interfaces[iface];
+        if (!interfaceObject) {
+            throw new Error(`Interface ${iface} not found in the module`);
+        }
+        const ifaceImpl = new InterfaceWrapper(this, this.daggerModule, `${this.daggerModule.name}${iface}`, id, interfaceObject.functions);
+        return ifaceImpl;
+    }
+    /**
+     * Transfer a Dagger enum member name into its implemented value.
+     * An enum value A = "a" will be received as "A" by the entrypoint
+     * but should be transformed into "a" to be sent to the function.
+     * If the enum isn't found in the module, it may be a core enum so we keep the value
+     * as is.
+     */
+    buildEnum(enumName, value) {
+        const enumObject = this.daggerModule.enums[enumName];
+        if (!enumObject) {
+            return value;
+        }
+        if (!enumObject.values[value]) {
+            throw new Error(`Enum ${enumName} does not have member ${value}`);
+        }
+        return enumObject.values[value].value;
+    }
+    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));
+    }
+}
+/**
+ * Interface Wrapper serves as dynaminc module binding so the module can
+ * call function of this interface.
+ * Because the actual interface implementation can come from any external modules,
+ * all resolution are done by API Call.
+ *
+ * @example
+ * ```ts
+ * interface Example {
+ *   foo: () => Promise<string>
+ * }
+ *
+ * class Test {
+ *   @func()
+ *   async callFoo(example: Example): Promise<string> {
+ *     // <- This example argument here is actually the Interface Wrapper, and `foo` will,
+ *     // directly execute the API call to reach the given implementation.
+ *     return example.foo()
+ *   }
+ * }
+ * ```
+ */
+class InterfaceWrapper {
+    executor;
+    module;
+    ifaceName;
+    ifaceId;
+    fcts;
+    _ctx;
+    constructor(executor, module, ifaceName, ifaceId, fcts) {
+        this.executor = executor;
+        this.module = module;
+        this.ifaceName = ifaceName;
+        this.ifaceId = ifaceId;
+        this.fcts = fcts;
+        this._ctx = new Context([], new Connection(dag.getGQLClient()));
+        // Load the interface by its identifier
+        this._ctx = this._ctx.select(`load${ifaceName}FromID`, { id: ifaceId });
+        Object.entries(fcts).forEach(([name, fct]) => {
+            const argKeys = Object.keys(fct.arguments);
+            // Dynamically adding functions of the interface and it's resolvers.
+            // @ts-ignore
+            this[name] = async (...args) => {
+                // Fill up arguments of that function.
+                const argsPayload = {};
+                for (let i = 0; i < argKeys.length; i++) {
+                    if (args[i] !== undefined) {
+                        // @ts-ignore
+                        argsPayload[argKeys[i]] = args[i];
+                    }
+                }
+                this._ctx = this._ctx.select(name, argsPayload);
+                // If the function is returning an IDable, we don't need to execute it
+                // since it will be resolved later.
+                if (fct.returnType.kind === TypeDefKind.InterfaceKind ||
+                    fct.returnType.kind === TypeDefKind.ObjectKind) {
+                    return this;
+                }
+                // If the function is returning a list, we may need to load the sub-objects
+                if (fct.returnType.kind === TypeDefKind.ListKind) {
+                    const listTypeDef = fct.returnType
+                        .typeDef;
+                    // If the list is an object or an interface, then we need to load the sub-objects.
+                    if (listTypeDef.kind === TypeDefKind.ObjectKind ||
+                        listTypeDef.kind === TypeDefKind.InterfaceKind) {
+                        const typedef = listTypeDef;
+                        // Resolves the call to get the list of IDs to load
+                        const ids = await this._ctx
+                            .select("id")
+                            .execute();
+                        // If the return type is an interface defined by that module, we need to load it through
+                        // the interface wrapper
+                        if (this.module.interfaces[typedef.name]) {
+                            return await Promise.all(ids.map(({ id }) => new InterfaceWrapper(this.executor, module, `${this.module.name}${typedef.name}`, id, this.module.interfaces[typedef.name].functions)));
+                        }
+                        // Otherwise, we can just load the objects from the API
+                        return await Promise.all(
+                        // @ts-ignore
+                        ids.map(({ id }) => dag[`load${listTypeDef.name}FromID`](id)));
+                    }
+                }
+                return await this._ctx.execute();
+            };
+        });
+    }
+    /**
+     * ID function to make the interface IDeable when serialized as return value to the
+     * Dagger API.
+     */
+    async id() {
+        const ctx = this._ctx.select("id");
+        return await ctx.execute();
+    }
+}

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,CAiBzD"}

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

@@ -0,0 +1,15 @@
+export function convertToPascalCase(input) {
+    // Handle empty string case
+    if (!input) {
+        return "";
+    }
+    // Split on word boundaries before uppercase letters, numbers, and special characters
+    const words = input
+        .split(/(?=[A-Z0-9])|[^a-zA-Z0-9]|(?<=[a-zA-Z])(?=\d)|(?<=\d)(?=[a-zA-Z])/g)
+        .filter((word) => word.length > 0);
+    // Convert each word to proper case
+    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,50 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typedef.js";
+import { AST } from "../typescript_module/index.js";
+import { Locatable } from "./locatable.js";
+import { References } from "./reference.js";
+export type DaggerArguments = {
+    [name: string]: DaggerArgument;
+};
+export declare class DaggerArgument extends Locatable {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    deprecated?: 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;
+        deprecated: string | undefined;
+        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,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,MAAM,MAAM,eAAe,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAA;CAAE,CAAA;AAEhE,qBAAa,cAAe,SAAQ,SAAS;IAgBzC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAhBf,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,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;IAuC3B;;;;;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;;;;;;;;;;;;CAcP"}

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

@@ -0,0 +1,118 @@
+/* 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";
+import { Locatable } from "./locatable.js";
+export class DaggerArgument extends Locatable {
+    node;
+    ast;
+    name;
+    description;
+    deprecated;
+    _typeRef;
+    type;
+    isVariadic;
+    isNullable;
+    isOptional;
+    defaultPath;
+    ignore;
+    defaultValue;
+    symbol;
+    constructor(node, ast) {
+        super(node);
+        this.node = node;
+        this.ast = ast;
+        this.symbol = this.ast.getSymbolOrThrow(node.name);
+        this.name = this.node.name.getText();
+        const { description, deprecated } = this.ast.getSymbolDoc(this.symbol);
+        this.description = description;
+        this.deprecated = deprecated;
+        this.defaultValue = this.getDefaultValue();
+        this.isVariadic = this.node.dotDotDotToken !== undefined;
+        this.isNullable = this.getIsNullable();
+        this.isOptional =
+            this.isVariadic || // if argument 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 ?
+        if (this.deprecated !== undefined && !this.isOptional) {
+            throw new IntrospectionError(`argument ${this.name} is required and cannot be deprecated at ${AST.getNodePosition(this.node)}.`);
+        }
+        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,
+            deprecated: this.deprecated,
+            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,8 @@
+export type DaggerDecorators = "object" | "func" | "check" | "argument" | "enumType" | "field";
+export declare const OBJECT_DECORATOR: DaggerDecorators;
+export declare const FUNCTION_DECORATOR: DaggerDecorators;
+export declare const CHECK_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":"AASA,MAAM,MAAM,gBAAgB,GACxB,QAAQ,GACR,MAAM,GACN,OAAO,GACP,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,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,7 @@
+import { argument, func, object, enumType, field, check, } from "../../decorators.js";
+export const OBJECT_DECORATOR = object.name;
+export const FUNCTION_DECORATOR = func.name;
+export const CHECK_DECORATOR = check.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,41 @@
+import ts from "typescript";
+import { AST } from "../typescript_module/index.js";
+import { DaggerEnumBase, DaggerEnumBaseValue } from "./enumBase.js";
+import { Locatable } from "./locatable.js";
+export type DaggerEnums = {
+    [name: string]: DaggerEnum;
+};
+export type DaggerEnumValues = {
+    [name: string]: DaggerEnumValue;
+};
+export declare class DaggerEnumValue extends Locatable implements DaggerEnumBaseValue {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    value: string;
+    description: string;
+    deprecated?: string;
+    private symbol;
+    constructor(node: ts.EnumMember, ast: AST);
+    toJSON(): {
+        name: string;
+        value: string;
+        description: string;
+        deprecated: string | undefined;
+    };
+}
+export declare class DaggerEnum extends Locatable 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;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,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,SAAQ,SAAU,YAAW,mBAAmB;IASzE,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IATf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IAE1B,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,GAAG,EAAE,GAAG;IAmB3B,MAAM;;;;;;CAQP;AAED,qBAAa,UAAW,SAAQ,SAAU,YAAW,cAAc;IAQ/D,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;IAgB3B,MAAM;;;;;CAOP"}

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

@@ -0,0 +1,63 @@
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST } from "../typescript_module/index.js";
+import { Locatable } from "./locatable.js";
+export class DaggerEnumValue extends Locatable {
+    node;
+    ast;
+    name;
+    value;
+    description;
+    deprecated;
+    symbol;
+    constructor(node, ast) {
+        super(node);
+        this.node = node;
+        this.ast = ast;
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        this.name = this.node.name.getText();
+        const { description, deprecated } = this.ast.getSymbolDoc(this.symbol);
+        this.description = description;
+        this.deprecated = deprecated;
+        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.name,
+            value: this.value,
+            description: this.description,
+            deprecated: this.deprecated,
+        };
+    }
+}
+export class DaggerEnum extends Locatable {
+    node;
+    ast;
+    name;
+    description;
+    values = {};
+    symbol;
+    constructor(node, ast) {
+        super(node);
+        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,19 @@
+import { Locatable } from "./locatable.js";
+export interface DaggerEnumBaseValue extends Locatable {
+    name: string;
+    value: string;
+    description: string;
+    deprecated?: string;
+}
+export type DaggerEnumBaseValues = {
+    [name: string]: DaggerEnumBaseValue;
+};
+export interface DaggerEnumBase extends Locatable {
+    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,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,MAAM,WAAW,mBAAoB,SAAQ,SAAS;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,MAAM,oBAAoB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,CAAA;CAAE,CAAA;AAE1E,MAAM,WAAW,cAAe,SAAQ,SAAS;IAC/C,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/enumBase.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,41 @@
+import ts from "typescript";
+import { AST } from "../typescript_module/index.js";
+import { DaggerEnumBase, DaggerEnumBaseValue } from "./enumBase.js";
+import { Locatable } from "./locatable.js";
+export type DaggerEnumClasses = {
+    [name: string]: DaggerEnumClass;
+};
+export type DaggerEnumClassValues = {
+    [name: string]: DaggerEnumClassValue;
+};
+export declare class DaggerEnumClassValue extends Locatable implements DaggerEnumBaseValue {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    value: string;
+    description: string;
+    deprecated?: string;
+    private symbol;
+    constructor(node: ts.PropertyDeclaration, ast: AST);
+    toJSON(): {
+        name: string;
+        value: string;
+        description: string;
+        deprecated: string | undefined;
+    };
+}
+export declare class DaggerEnumClass extends Locatable 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;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,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,oBACX,SAAQ,SACR,YAAW,mBAAmB;IAU5B,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IATf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IAE1B,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,mBAAmB,EAC5B,GAAG,EAAE,GAAG;IAiB3B,MAAM;;;;;;CAQP;AAED,qBAAa,eAAgB,SAAQ,SAAU,YAAW,cAAc;IAQpE,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;IAuB3B,MAAM;;;;;CAOP"}