@dagger.io/dagger 0.14.0 → 0.15.1

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

@@ -0,0 +1,61 @@
+import ts from "typescript";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST } from "../typescript_module/index.js";
+export class DaggerEnumClassValue {
+    node;
+    ast;
+    name;
+    value;
+    description;
+    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 initializer = this.node.initializer;
+        if (!initializer) {
+            throw new Error("Dagger enum value has no value set");
+        }
+        this.value = this.ast.resolveParameterDefaultValue(initializer);
+    }
+    toJSON() {
+        return {
+            name: this.value,
+            description: this.description,
+        };
+    }
+}
+export class DaggerEnumClass {
+    node;
+    ast;
+    name;
+    description;
+    values = {};
+    symbol;
+    constructor(node, ast) {
+        this.node = node;
+        this.ast = ast;
+        if (!this.node.name) {
+            throw new IntrospectionError(`could not resolve name of enum at ${AST.getNodePosition(node)}.`);
+        }
+        this.name = this.node.name.getText();
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        this.description = this.ast.getDocFromSymbol(this.symbol);
+        const properties = this.node.members;
+        for (const property of properties) {
+            if (ts.isPropertyDeclaration(property)) {
+                const value = new DaggerEnumClassValue(property, 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/function.d.ts

@@ -0,0 +1,35 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typedef.js";
+import { AST } from "../typescript_module/index.js";
+import { DaggerArguments } from "./argument.js";
+import { References } from "./reference.js";
+export type DaggerFunctions = {
+    [name: string]: DaggerFunction;
+};
+export declare class DaggerFunction {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    private _returnTypeRef?;
+    returnType?: TypeDef<TypeDefKind>;
+    alias: string | undefined;
+    arguments: DaggerArguments;
+    private signature;
+    private symbol;
+    constructor(node: ts.MethodDeclaration, ast: AST);
+    private getReturnType;
+    private getAlias;
+    getArgsOrder(): string[];
+    getReferences(): string[];
+    propagateReferences(references: References): void;
+    toJSON(): {
+        name: string;
+        description: string;
+        alias: string | undefined;
+        arguments: DaggerArguments;
+        returnType: TypeDef<TypeDefKind> | undefined;
+    };
+}
+//# sourceMappingURL=function.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/function.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EACL,GAAG,EAGJ,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAkB,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/D,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;IAYvB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAZf,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IAC1B,OAAO,CAAC,cAAc,CAAC,CAAQ;IACxB,UAAU,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,SAAS,EAAE,eAAe,CAAK;IAEtC,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,MAAM,CAAW;gBAGN,IAAI,EAAE,EAAE,CAAC,iBAAiB,EAC1B,GAAG,EAAE,GAAG;IAiB3B,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,QAAQ;IAaT,YAAY,IAAI,MAAM,EAAE;IAIxB,aAAa,IAAI,MAAM,EAAE;IAoBzB,mBAAmB,CAAC,UAAU,EAAE,UAAU;IAuB1C,MAAM;;;;;;;CASd"}

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

@@ -0,0 +1,86 @@
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST, isTypeDefResolved, resolveTypeDef, } from "../typescript_module/index.js";
+import { DaggerArgument } from "./argument.js";
+import { FUNCTION_DECORATOR } from "./decorator.js";
+export class DaggerFunction {
+    node;
+    ast;
+    name;
+    description;
+    _returnTypeRef;
+    returnType;
+    alias;
+    arguments = {};
+    signature;
+    symbol;
+    constructor(node, ast) {
+        this.node = node;
+        this.ast = ast;
+        this.symbol = this.ast.getSymbolOrThrow(node.name);
+        this.signature = this.ast.getSignatureFromFunctionOrThrow(node);
+        this.name = this.node.name.getText();
+        this.description = this.ast.getDocFromSymbol(this.symbol);
+        for (const parameter of this.node.parameters) {
+            this.arguments[parameter.name.getText()] = new DaggerArgument(parameter, this.ast);
+        }
+        this.returnType = this.getReturnType();
+        this.alias = this.getAlias();
+    }
+    getReturnType() {
+        const type = this.signature.getReturnType();
+        const typedef = this.ast.tsTypeToTypeDef(this.node, type);
+        if (typedef === undefined || !isTypeDefResolved(typedef)) {
+            this._returnTypeRef = this.ast.typeToStringType(type);
+        }
+        return typedef;
+    }
+    getAlias() {
+        const alias = this.ast.getDecoratorArgument(this.node, FUNCTION_DECORATOR, "string");
+        if (!alias) {
+            return;
+        }
+        return JSON.parse(alias.replace(/'/g, '"'));
+    }
+    getArgsOrder() {
+        return Object.keys(this.arguments);
+    }
+    getReferences() {
+        const references = [];
+        if (this._returnTypeRef &&
+            (this.returnType === undefined || !isTypeDefResolved(this.returnType))) {
+            references.push(this._returnTypeRef);
+        }
+        for (const argument of Object.values(this.arguments)) {
+            const reference = argument.getReference();
+            if (reference) {
+                references.push(reference);
+            }
+        }
+        return references;
+    }
+    propagateReferences(references) {
+        for (const argument of Object.values(this.arguments)) {
+            argument.propagateReferences(references);
+        }
+        if (!this._returnTypeRef) {
+            return;
+        }
+        if (this.returnType && isTypeDefResolved(this.returnType)) {
+            return;
+        }
+        const typeDef = references[this._returnTypeRef];
+        if (!typeDef) {
+            throw new IntrospectionError(`could not find type reference for ${this._returnTypeRef} at ${AST.getNodePosition(this.node)}.`);
+        }
+        this.returnType = resolveTypeDef(this.returnType, typeDef);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            alias: this.alias,
+            arguments: this.arguments,
+            returnType: this.returnType,
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+export * from "./constructor.js";
+export * from "./argument.js";
+export * from "./enum.js";
+export * from "./enumBase.js";
+export * from "./enumClass.js";
+export * from "./function.js";
+export * from "./module.js";
+export * from "./object.js";
+export * from "./objectBase.js";
+export * from "./reference.js";
+export * from "./typeObject.js";
+export * from "./decorator.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,aAAa,CAAA;AAC3B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA"}

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

@@ -0,0 +1,12 @@
+export * from "./constructor.js";
+export * from "./argument.js";
+export * from "./enum.js";
+export * from "./enumBase.js";
+export * from "./enumClass.js";
+export * from "./function.js";
+export * from "./module.js";
+export * from "./object.js";
+export * from "./objectBase.js";
+export * from "./reference.js";
+export * from "./typeObject.js";
+export * from "./decorator.js";

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

@@ -0,0 +1,110 @@
+import Module from "node:module";
+import { AST } from "../typescript_module/index.js";
+import { DaggerEnumsBase } from "./enumBase.js";
+import { DaggerObjectsBase } from "./objectBase.js";
+/**
+ * DaggerModule represents a TypeScript module with a set of files
+ * with Dagger object conversion and notation.
+ *
+ * It starts from the module entrypoint (the class named the same as the module) and
+ * then recursively resolve every references to other declared identifiers.
+ * After resolution, it propagates all the references to the modules declarations
+ * and finally it generates the final Dagger module representation.
+ */
+export declare class DaggerModule {
+    name: string;
+    private userModule;
+    private ast;
+    /**
+     * An object is either a decorated class or a type alias object.
+     * Type alias objects cannot be decorated so they are resolved if referenced in the module.
+     *
+     * @example
+     * ```ts
+     * @object()
+     * export class MyObject {
+     *  @func()
+     *  public name: string
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * export type Example = {
+     *   name: string
+     * }
+     * ```
+     */
+    objects: DaggerObjectsBase;
+    /**
+     * An enum is either a decorated class or a native enum.
+     * Native enum cannot be decorated so they are resolved if referenced in the module.
+     *
+     * @example
+     * ```ts
+     * @enumType()
+     * export class Example {
+     *   static A: string = "a"
+     *   static B: string = "b"
+     * }
+     * ```
+     *
+     * or
+     *
+     * @example
+     * ```ts
+     * export enum Example {
+     *   A = "a",
+     *   B = "b",
+     * }
+     * ```
+     */
+    enums: DaggerEnumsBase;
+    description: string | undefined;
+    private references;
+    constructor(name: string, userModule: Module[], ast: AST);
+    /**
+     * Find the reference of the module and register it to the module references.
+     *
+     * To do so, we check the user module to find a corresponding symbol (name) for each of
+     * typedef we support.
+     * This only applies for:
+     * - classes
+     * - enums
+     * - scalars
+     *
+     * If the reference is an object or a class, recursively find the references of the object.
+     *
+     * *Note*: If a class is referenced but not exported and not decorated with `@object()`, we throw an error
+     * because we aim to be explicit. (TomChv: Should we change this behaviour?)
+     */
+    private resolveReferences;
+    /**
+     * Resolve type alias to the corresponding TypeDef.
+     * A type might refer to anything typeable in TypeScript but right now we supports:
+     * - `type Example = string`
+     * - `type Example = { prop: string}`
+     * - `type Example = number`
+     * - `type Example = boolean`
+     * - `type Example = void`
+     *
+     * If the reference is an object, we recursively resolve its references.
+     * If the type cannot be resolved or is not supported, we throw an error.
+     */
+    private resolveTypeAlias;
+    /**
+     * Recursively propagate references to all objects properties and functions.
+     */
+    private propagateReferences;
+    /**
+     * Get the top level comment of the file that contains the module entrypoint.
+     */
+    private getDescription;
+    toJSON(): {
+        name: string;
+        description: string | undefined;
+        objects: DaggerObjectsBase;
+        enums: DaggerEnumsBase;
+    };
+}
+//# sourceMappingURL=module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/module.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,aAAa,CAAA;AAKhC,OAAO,EAEL,GAAG,EAGJ,MAAM,+BAA+B,CAAA;AAGtC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAG/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAInD;;;;;;;;GAQG;AACH,qBAAa,YAAY;IAoDd,IAAI,EAAE,MAAM;IACnB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,GAAG;IArDb;;;;;;;;;;;;;;;;;;;OAmBG;IACI,OAAO,EAAE,iBAAiB,CAAK;IAEtC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,KAAK,EAAE,eAAe,CAAK;IAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;IAEtC,OAAO,CAAC,UAAU,CAAiB;gBAG1B,IAAI,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAAE,EACpB,GAAG,EAAE,GAAG;IAkClB;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,iBAAiB;IAmHzB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,gBAAgB;IAsExB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAM3B;;OAEG;IACH,OAAO,CAAC,cAAc;IAgBtB,MAAM;;;;;;CAQP"}

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

@@ -0,0 +1,275 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { findModuleByExportedName, AST, CLIENT_GEN_FILE, } from "../typescript_module/index.js";
+import { ENUM_DECORATOR, OBJECT_DECORATOR } from "./decorator.js";
+import { DaggerEnum } from "./enum.js";
+import { DaggerEnumClass } from "./enumClass.js";
+import { DaggerObject } from "./object.js";
+import { DaggerTypeObject } from "./typeObject.js";
+/**
+ * DaggerModule represents a TypeScript module with a set of files
+ * with Dagger object conversion and notation.
+ *
+ * It starts from the module entrypoint (the class named the same as the module) and
+ * then recursively resolve every references to other declared identifiers.
+ * After resolution, it propagates all the references to the modules declarations
+ * and finally it generates the final Dagger module representation.
+ */
+export class DaggerModule {
+    name;
+    userModule;
+    ast;
+    /**
+     * An object is either a decorated class or a type alias object.
+     * Type alias objects cannot be decorated so they are resolved if referenced in the module.
+     *
+     * @example
+     * ```ts
+     * @object()
+     * export class MyObject {
+     *  @func()
+     *  public name: string
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * export type Example = {
+     *   name: string
+     * }
+     * ```
+     */
+    objects = {};
+    /**
+     * An enum is either a decorated class or a native enum.
+     * Native enum cannot be decorated so they are resolved if referenced in the module.
+     *
+     * @example
+     * ```ts
+     * @enumType()
+     * export class Example {
+     *   static A: string = "a"
+     *   static B: string = "b"
+     * }
+     * ```
+     *
+     * or
+     *
+     * @example
+     * ```ts
+     * export enum Example {
+     *   A = "a",
+     *   B = "b",
+     * }
+     * ```
+     */
+    enums = {};
+    description;
+    references = {};
+    constructor(name, userModule, ast) {
+        this.name = name;
+        this.userModule = userModule;
+        this.ast = ast;
+        const mainModule = findModuleByExportedName(this.name, this.userModule);
+        if (!mainModule) {
+            console.warn(`could not find module entrypoint: class ${this.name} from import. Class should be exported to benefit from all features.`);
+        }
+        const mainObjectNode = this.ast.findResolvedNodeByName(this.name, ts.SyntaxKind.ClassDeclaration);
+        if (!mainObjectNode) {
+            throw new IntrospectionError(`could not find main object ${this.name} in module ${JSON.stringify(mainModule, null, 2) ?? ""} located at ${this.ast.files}`);
+        }
+        const mainFileContent = mainObjectNode.file.getFullText();
+        this.description = this.getDescription(mainFileContent);
+        const mainDaggerObject = new DaggerObject(mainObjectNode.node, this.ast);
+        this.objects[this.name] = mainDaggerObject;
+        this.references[this.name] = {
+            kind: TypeDefKind.ObjectKind,
+            name: this.name,
+        };
+        this.resolveReferences(mainDaggerObject.getReferences());
+        this.propagateReferences();
+    }
+    /**
+     * Find the reference of the module and register it to the module references.
+     *
+     * To do so, we check the user module to find a corresponding symbol (name) for each of
+     * typedef we support.
+     * This only applies for:
+     * - classes
+     * - enums
+     * - scalars
+     *
+     * If the reference is an object or a class, recursively find the references of the object.
+     *
+     * *Note*: If a class is referenced but not exported and not decorated with `@object()`, we throw an error
+     * because we aim to be explicit. (TomChv: Should we change this behaviour?)
+     */
+    resolveReferences(references) {
+        if (references.length === 0) {
+            return;
+        }
+        for (const reference of references) {
+            // If we already know that reference, we don't need to explore it again.
+            if (this.references[reference]) {
+                continue;
+            }
+            const classRef = this.ast.findResolvedNodeByName(reference, ts.SyntaxKind.ClassDeclaration);
+            if (classRef) {
+                if (classRef.file.fileName.endsWith(CLIENT_GEN_FILE)) {
+                    this.references[reference] = {
+                        kind: TypeDefKind.ObjectKind,
+                        name: reference,
+                    };
+                    continue;
+                }
+                if (this.ast.isNodeDecoratedWith(classRef.node, OBJECT_DECORATOR)) {
+                    const daggerObject = new DaggerObject(classRef.node, this.ast);
+                    this.objects[daggerObject.name] = daggerObject;
+                    this.references[daggerObject.name] = {
+                        kind: TypeDefKind.ObjectKind,
+                        name: daggerObject.name,
+                    };
+                    this.resolveReferences(daggerObject.getReferences());
+                    continue;
+                }
+                if (this.ast.isNodeDecoratedWith(classRef.node, ENUM_DECORATOR)) {
+                    const daggerEnum = new DaggerEnumClass(classRef.node, this.ast);
+                    this.enums[daggerEnum.name] = daggerEnum;
+                    this.references[daggerEnum.name] = {
+                        kind: TypeDefKind.EnumKind,
+                        name: daggerEnum.name,
+                    };
+                    // There should be no references in enums.
+                    continue;
+                }
+                throw new IntrospectionError(`class ${reference} in ${AST.getNodePosition(classRef.node)} is used by the module but not exposed with a dagger decorator.`);
+            }
+            const enumRef = this.ast.findResolvedNodeByName(reference, ts.SyntaxKind.EnumDeclaration);
+            if (enumRef) {
+                if (enumRef.file.fileName.endsWith(CLIENT_GEN_FILE)) {
+                    this.references[reference] = {
+                        kind: TypeDefKind.EnumKind,
+                        name: reference,
+                    };
+                    continue;
+                }
+                // Typescript enum declaration cannot be decorated, so we don't check it.
+                const daggerEnum = new DaggerEnum(enumRef.node, this.ast);
+                this.enums[daggerEnum.name] = daggerEnum;
+                this.references[daggerEnum.name] = {
+                    kind: TypeDefKind.EnumKind,
+                    name: daggerEnum.name,
+                };
+                // There should be no reference in enums.
+                continue;
+            }
+            const typeAliasRef = this.ast.findResolvedNodeByName(reference, ts.SyntaxKind.TypeAliasDeclaration);
+            if (typeAliasRef) {
+                // The resolution is to big so we split it in a sub function.
+                this.resolveTypeAlias(reference, typeAliasRef);
+                continue;
+            }
+            // Handle primitives here
+            if (reference === "String") {
+                throw new IntrospectionError(`Use of primitive 'String' type detected, please use 'string' instead.`);
+            }
+            if (reference === "Boolean") {
+                throw new IntrospectionError(`Use of primitive 'Boolean' type detected, please use 'boolean' instead.`);
+            }
+            if (reference === "Number") {
+                throw new IntrospectionError(`Use of primitive 'Number' type detected, please use 'number' instead.`);
+            }
+            throw new IntrospectionError(`could not resolve type reference for ${reference}.`);
+        }
+    }
+    /**
+     * Resolve type alias to the corresponding TypeDef.
+     * A type might refer to anything typeable in TypeScript but right now we supports:
+     * - `type Example = string`
+     * - `type Example = { prop: string}`
+     * - `type Example = number`
+     * - `type Example = boolean`
+     * - `type Example = void`
+     *
+     * If the reference is an object, we recursively resolve its references.
+     * If the type cannot be resolved or is not supported, we throw an error.
+     */
+    resolveTypeAlias(reference, typeAlias) {
+        const type = this.ast.getTypeFromTypeAlias(typeAlias.node);
+        if (type.flags & ts.TypeFlags.String) {
+            this.references[reference] = { kind: TypeDefKind.StringKind };
+            return;
+        }
+        if (type.flags & ts.TypeFlags.Number) {
+            this.references[reference] = { kind: TypeDefKind.IntegerKind };
+            return;
+        }
+        if (type.flags & ts.TypeFlags.Boolean) {
+            this.references[reference] = { kind: TypeDefKind.BooleanKind };
+            return;
+        }
+        if (type.flags & ts.TypeFlags.Void) {
+            this.references[reference] = { kind: TypeDefKind.VoidKind };
+            return;
+        }
+        // Scalar are defined with string intersection such as `type MyScalar = string & { __MyScalar: never }`
+        if (type.flags & ts.TypeFlags.Intersection ||
+            type.flags & ts.TypeFlags.Union) {
+            this.references[reference] = {
+                kind: TypeDefKind.ScalarKind,
+                name: reference,
+            };
+            return;
+        }
+        if (type.flags & ts.TypeFlags.Object) {
+            if (typeAlias.file.fileName.endsWith(CLIENT_GEN_FILE)) {
+                this.references[reference] = {
+                    kind: TypeDefKind.ObjectKind,
+                    name: reference,
+                };
+                return;
+            }
+            const daggerObject = new DaggerTypeObject(typeAlias.node, this.ast);
+            this.objects[daggerObject.name] = daggerObject;
+            this.references[daggerObject.name] = {
+                kind: TypeDefKind.ObjectKind,
+                name: daggerObject.name,
+            };
+            this.resolveReferences(daggerObject.getReferences());
+            return;
+        }
+        throw new IntrospectionError(`could not resolve type reference for ${reference} at ${AST.getNodePosition(typeAlias.node)}`);
+    }
+    /**
+     * Recursively propagate references to all objects properties and functions.
+     */
+    propagateReferences() {
+        for (const object of Object.values(this.objects)) {
+            object.propagateReferences(this.references);
+        }
+    }
+    /**
+     * Get the top level comment of the file that contains the module entrypoint.
+     */
+    getDescription(sourceFileContent) {
+        const regex = /^(?!.*import)[\s]*\/\*\*([\s\S]*?)\*\//;
+        const match = sourceFileContent.match(regex);
+        if (!match) {
+            return undefined;
+        }
+        const comment = match[1]
+            .split("\n")
+            .map((line) => line.replace(/^\s*\*\s?/, ""))
+            .join("\n");
+        return comment.trim();
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            objects: this.objects,
+            enums: this.enums,
+        };
+    }
+}

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

@@ -0,0 +1,29 @@
+import ts from "typescript";
+import { AST } from "../typescript_module/index.js";
+import { DaggerConstructor } from "./constructor.js";
+import { DaggerFunctions } from "./function.js";
+import { DaggerObjectBase } from "./objectBase.js";
+import { DaggerProperties } from "./property.js";
+import { References } from "./reference.js";
+export declare class DaggerObject implements DaggerObjectBase {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    _constructor: DaggerConstructor | undefined;
+    methods: DaggerFunctions;
+    properties: DaggerProperties;
+    private symbol;
+    kind(): "class" | "object";
+    constructor(node: ts.ClassDeclaration, ast: AST);
+    getReferences(): string[];
+    propagateReferences(references: References): void;
+    toJSON(): {
+        name: string;
+        description: string;
+        constructor: DaggerConstructor | undefined;
+        methods: DaggerFunctions;
+        properties: DaggerProperties;
+    };
+}
+//# sourceMappingURL=object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAE,GAAG,EAAE,MAAM,+BAA+B,CAAA;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEpD,OAAO,EAAkB,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAkB,MAAM,eAAe,CAAA;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,qBAAa,YAAa,YAAW,gBAAgB;IAcjD,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAdf,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,iBAAiB,GAAG,SAAS,CAAY;IACvD,OAAO,EAAE,eAAe,CAAK;IAC7B,UAAU,EAAE,gBAAgB,CAAK;IAExC,OAAO,CAAC,MAAM,CAAW;IAEzB,IAAI,IAAI,OAAO,GAAG,QAAQ;gBAKP,IAAI,EAAE,EAAE,CAAC,gBAAgB,EACzB,GAAG,EAAE,GAAG;IAqDpB,aAAa,IAAI,MAAM,EAAE;IAqBzB,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAcjD,MAAM;;;;;;;CASd"}