@dagger.io/dagger 0.0.1-0

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

@@ -0,0 +1,316 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { 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 { DaggerInterface } from "./interface.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 typically a native TypeScript enum declared with the `enum` keyword.
+     * Decorated classes using `@enumType()` are still supported for backward compatibility.
+     *
+     * @example
+     * ```ts
+     * export enum Example {
+     *   A = "a",
+     *   B = "b",
+     * }
+     * ```
+     */
+    enums = {};
+    /**
+     * An interface is declared using the `interface` keyword.
+     *
+     * @example
+     * ```ts
+     * export interface Example {
+     *   foo: (): string
+     *   asyncFoo: (): Promise<string>
+     * }
+     * ```
+     */
+    interfaces = {};
+    description;
+    references = {
+        // Float is a special case, it's an alias of number but it serves to declare a float type
+        // in the Dagger API.
+        // So we auto register it because it will be detected as a referenced type by the introspector.
+        float: { kind: TypeDefKind.FloatKind },
+    };
+    constructor(name, userModule, ast) {
+        this.name = name;
+        this.userModule = userModule;
+        this.ast = ast;
+        const classObjects = this.findClasses();
+        for (const classObject of classObjects) {
+            // This only applies to cloud. If this is the true main object, it is correct
+            // if this is a blueprint, the description will not matter in any situation
+            const mainFileContent = classObject.file.getFullText();
+            this.description = this.getDescription(mainFileContent);
+            const daggerObject = new DaggerObject(classObject.node, this.ast);
+            const objectName = classObject.node.name?.getText() || this.name;
+            this.objects[objectName] = daggerObject;
+            this.references[objectName] = {
+                kind: TypeDefKind.ObjectKind,
+                name: objectName,
+            };
+            this.resolveReferences(daggerObject.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
+     * - interfaces
+     *
+     * If the reference is an object, a class or an interface, 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 interfaceRef = this.ast.findResolvedNodeByName(reference, ts.SyntaxKind.InterfaceDeclaration);
+            if (interfaceRef) {
+                const daggerInterface = new DaggerInterface(interfaceRef.node, this.ast);
+                this.interfaces[daggerInterface.name] = daggerInterface;
+                this.references[daggerInterface.name] = {
+                    kind: TypeDefKind.InterfaceKind,
+                    name: daggerInterface.name,
+                };
+                this.resolveReferences(daggerInterface.getReferences());
+                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)}`);
+    }
+    /**
+     * Find the classes in the AST. Returns only our main class if it exists
+     */
+    findClasses() {
+        const allClassDeclarations = this.ast.findAllDeclarations(ts.SyntaxKind.ClassDeclaration);
+        const allClasses = [];
+        for (const classDecl of allClassDeclarations) {
+            const convertedDecl = classDecl;
+            // Check if the class matches this.name and return only that if so
+            if (convertedDecl.node.name &&
+                convertedDecl.node.name.getText() === this.name) {
+                return [convertedDecl];
+            }
+            // or we return all classes decorated with @object
+            if (this.ast.isNodeDecoratedWith(classDecl.node, OBJECT_DECORATOR)) {
+                allClasses.push(convertedDecl);
+            }
+        }
+        return allClasses;
+    }
+    /**
+     * Recursively propagate references to all objects properties and functions.
+     */
+    propagateReferences() {
+        for (const object of Object.values(this.objects)) {
+            object.propagateReferences(this.references);
+        }
+        for (const interface_ of Object.values(this.interfaces)) {
+            interface_.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,
+            interfaces: this.interfaces,
+        };
+    }
+}

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

@@ -0,0 +1,46 @@
+import ts from "typescript";
+import { AST, Location } from "../typescript_module/index.js";
+import { DaggerConstructor } from "./constructor.js";
+import { DaggerFunctions } from "./function.js";
+import { Locatable } from "./locatable.js";
+import { DaggerObjectBase } from "./objectBase.js";
+import { DaggerProperties } from "./property.js";
+import { References } from "./reference.js";
+/**
+ * Represents an object defined using the `class` keyword.
+ *
+ * The class may contains methods and fields, that may or may not be exposed to the Dagger API.
+ *
+ * @example
+ * ```ts
+ * type MyObject = {
+ *   name: string
+ *   age: number
+ * }
+ * ```
+ */
+export declare class DaggerObject extends Locatable implements DaggerObjectBase {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    deprecated?: string;
+    _constructor: DaggerConstructor | undefined;
+    methods: DaggerFunctions;
+    properties: DaggerProperties;
+    private symbol;
+    kind(): "class" | "object";
+    constructor(node: ts.ClassDeclaration, ast: AST);
+    getLocation(): Location;
+    getReferences(): string[];
+    propagateReferences(references: References): void;
+    toJSON(): {
+        name: string;
+        description: string;
+        deprecated: string | undefined;
+        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,QAAQ,EAAE,MAAM,+BAA+B,CAAA;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEpD,OAAO,EAAkB,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/D,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,gBAAgB,EAAkB,MAAM,eAAe,CAAA;AAChE,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C;;;;;;;;;;;;GAYG;AACH,qBAAa,YAAa,SAAQ,SAAU,YAAW,gBAAgB;IAenE,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAff,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,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;IAyDpB,WAAW,IAAI,QAAQ;IAIvB,aAAa,IAAI,MAAM,EAAE;IAqBzB,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAcjD,MAAM;;;;;;;;CAUd"}

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

@@ -0,0 +1,113 @@
+import ts from "typescript";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST } from "../typescript_module/index.js";
+import { DaggerConstructor } from "./constructor.js";
+import { FUNCTION_DECORATOR, OBJECT_DECORATOR } from "./decorator.js";
+import { DaggerFunction } from "./function.js";
+import { Locatable } from "./locatable.js";
+import { DaggerProperty } from "./property.js";
+/**
+ * Represents an object defined using the `class` keyword.
+ *
+ * The class may contains methods and fields, that may or may not be exposed to the Dagger API.
+ *
+ * @example
+ * ```ts
+ * type MyObject = {
+ *   name: string
+ *   age: number
+ * }
+ * ```
+ */
+export class DaggerObject extends Locatable {
+    node;
+    ast;
+    name;
+    description;
+    deprecated;
+    _constructor = undefined;
+    methods = {};
+    properties = {};
+    symbol;
+    kind() {
+        return "class";
+    }
+    constructor(node, ast) {
+        super(node);
+        this.node = node;
+        this.ast = ast;
+        if (!this.node.name) {
+            throw new IntrospectionError(`could not resolve name of class at ${AST.getNodePosition(node)}.`);
+        }
+        this.name = this.node.name.getText();
+        if (!this.ast.isNodeDecoratedWith(node, OBJECT_DECORATOR)) {
+            throw new IntrospectionError(`class ${this.name} at ${AST.getNodePosition(node)} is used by the module but not exposed with a dagger decorator.`);
+        }
+        const modifiers = ts.getCombinedModifierFlags(this.node);
+        if (!(modifiers & ts.ModifierFlags.Export)) {
+            console.warn(`missing export in class ${this.name} at ${AST.getNodePosition(node)} but it's used by the module.`);
+        }
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        const { description, deprecated } = this.ast.getSymbolDoc(this.symbol);
+        this.description = description;
+        this.deprecated = deprecated;
+        for (const member of this.node.members) {
+            if (ts.isPropertyDeclaration(member)) {
+                const property = new DaggerProperty(member, this.ast);
+                this.properties[property.alias ?? property.name] = property;
+                continue;
+            }
+            if (ts.isConstructorDeclaration(member)) {
+                this._constructor = new DaggerConstructor(member, this.ast);
+                continue;
+            }
+            if (ts.isMethodDeclaration(member) &&
+                this.ast.isNodeDecoratedWith(member, FUNCTION_DECORATOR)) {
+                const daggerFunction = new DaggerFunction(member, this.ast);
+                this.methods[daggerFunction.alias ?? daggerFunction.name] =
+                    daggerFunction;
+                continue;
+            }
+        }
+    }
+    getLocation() {
+        return AST.getNodeLocation(this.node);
+    }
+    getReferences() {
+        const references = [];
+        if (this._constructor) {
+            references.push(...this._constructor.getReferences());
+        }
+        for (const property of Object.values(this.properties)) {
+            const ref = property.getReference();
+            if (ref) {
+                references.push(ref);
+            }
+        }
+        for (const fn of Object.values(this.methods)) {
+            references.push(...fn.getReferences());
+        }
+        return references.filter((v, i, arr) => arr.indexOf(v) === i);
+    }
+    propagateReferences(references) {
+        if (this._constructor) {
+            this._constructor.propagateReferences(references);
+        }
+        for (const property of Object.values(this.properties)) {
+            property.propagateReferences(references);
+        }
+        for (const fn of Object.values(this.methods)) {
+            fn.propagateReferences(references);
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            deprecated: this.deprecated,
+            constructor: this._constructor,
+            methods: this.methods,
+            properties: this.properties,
+        };
+    }
+}

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

@@ -0,0 +1,32 @@
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typedef.js";
+import { DaggerConstructor } from "./constructor.js";
+import { DaggerFunctions } from "./function.js";
+import { Locatable } from "./locatable.js";
+import { References } from "./reference.js";
+export interface DaggerObjectPropertyBase extends Locatable {
+    name: string;
+    description: string;
+    deprecated?: string;
+    alias?: string;
+    isExposed: boolean;
+    type?: TypeDef<TypeDefKind>;
+    propagateReferences(references: References): void;
+}
+export type DaggerObjectPropertiesBase = {
+    [name: string]: DaggerObjectPropertyBase;
+};
+export interface DaggerObjectBase extends Locatable {
+    name: string;
+    description: string;
+    deprecated?: string;
+    _constructor: DaggerConstructor | undefined;
+    methods: DaggerFunctions;
+    properties: DaggerObjectPropertiesBase;
+    kind(): "class" | "object";
+    propagateReferences(references: References): void;
+}
+export type DaggerObjectsBase = {
+    [name: string]: DaggerObjectBase;
+};
+//# sourceMappingURL=objectBase.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"objectBase.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/objectBase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,MAAM,WAAW,wBAAyB,SAAQ,SAAS;IACzD,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;IAE3B,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAA;CAClD;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,CAAC,IAAI,EAAE,MAAM,GAAG,wBAAwB,CAAA;CACzC,CAAA;AAED,MAAM,WAAW,gBAAiB,SAAQ,SAAS;IACjD,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,iBAAiB,GAAG,SAAS,CAAA;IAC3C,OAAO,EAAE,eAAe,CAAA;IACxB,UAAU,EAAE,0BAA0B,CAAA;IAEtC,IAAI,IAAI,OAAO,GAAG,QAAQ,CAAA;IAE1B,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAAA;CAClD;AAED,MAAM,MAAM,iBAAiB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAE,CAAA"}

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

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

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

@@ -0,0 +1,36 @@
+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 { DaggerObjectPropertyBase } from "./objectBase.js";
+import { References } from "./reference.js";
+export type DaggerProperties = {
+    [name: string]: DaggerProperty;
+};
+export declare class DaggerProperty extends Locatable implements DaggerObjectPropertyBase {
+    private readonly node;
+    private readonly ast;
+    name: string;
+    description: string;
+    deprecated?: string;
+    alias: string | undefined;
+    isExposed: boolean;
+    private symbol;
+    private _typeRef?;
+    type?: TypeDef<TypeDefKind>;
+    constructor(node: ts.PropertyDeclaration, ast: AST);
+    private getAlias;
+    private getType;
+    getReference(): string | undefined;
+    propagateReferences(references: References): void;
+    toJSON(): {
+        name: string;
+        description: string;
+        deprecated: string | undefined;
+        alias: string | undefined;
+        type: TypeDef<TypeDefKind> | undefined;
+        isExposed: boolean;
+    };
+}
+//# sourceMappingURL=property.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"property.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/property.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;AAEtC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,MAAM,MAAM,gBAAgB,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAA;CAAE,CAAA;AAEjE,qBAAa,cACX,SAAQ,SACR,YAAW,wBAAwB;IAajC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAZf,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,SAAS,EAAE,OAAO,CAAA;IAEzB,OAAO,CAAC,MAAM,CAAW;IACzB,OAAO,CAAC,QAAQ,CAAC,CAAQ;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;gBAGf,IAAI,EAAE,EAAE,CAAC,mBAAmB,EAC5B,GAAG,EAAE,GAAG;IAuB3B,OAAO,CAAC,QAAQ;IAsBhB,OAAO,CAAC,OAAO;IAWR,YAAY,IAAI,MAAM,GAAG,SAAS;IAWlC,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAmBjD,MAAM;;;;;;;;CAUd"}

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

@@ -0,0 +1,82 @@
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { AST, isTypeDefResolved, resolveTypeDef, } from "../typescript_module/index.js";
+import { FIELD_DECORATOR, FUNCTION_DECORATOR } from "./decorator.js";
+import { Locatable } from "./locatable.js";
+export class DaggerProperty extends Locatable {
+    node;
+    ast;
+    name;
+    description;
+    deprecated;
+    alias;
+    isExposed;
+    symbol;
+    _typeRef;
+    type;
+    constructor(node, ast) {
+        super(node);
+        this.node = node;
+        this.ast = ast;
+        if (!this.node.name) {
+            throw new IntrospectionError(`could not resolve name of class at ${AST.getNodePosition(node)}.`);
+        }
+        this.symbol = this.ast.getSymbolOrThrow(this.node.name);
+        this.name = this.node.name.getText();
+        this.isExposed =
+            this.ast.isNodeDecoratedWith(this.node, FUNCTION_DECORATOR) ||
+                this.ast.isNodeDecoratedWith(this.node, FIELD_DECORATOR);
+        const { description, deprecated } = this.ast.getSymbolDoc(this.symbol);
+        this.description = description;
+        this.deprecated = deprecated;
+        this.alias = this.getAlias();
+        this.type = this.getType();
+    }
+    getAlias() {
+        let alias = this.ast.getDecoratorArgument(this.node, FUNCTION_DECORATOR, "string");
+        if (alias) {
+            return JSON.parse(alias.replace(/'/g, '"'));
+        }
+        alias = this.ast.getDecoratorArgument(this.node, FIELD_DECORATOR, "string");
+        if (alias) {
+            return JSON.parse(alias.replace(/'/g, '"'));
+        }
+    }
+    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;
+    }
+    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,
+            alias: this.alias,
+            type: this.type,
+            isExposed: this.isExposed,
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typedef.js";
+export type References = {
+    [name: string]: TypeDef<TypeDefKind>;
+};
+export type ReferencableType = TypeDef<TypeDefKind.ObjectKind> | TypeDef<TypeDefKind.EnumKind> | TypeDef<TypeDefKind.FloatKind> | TypeDef<TypeDefKind.ScalarKind> | TypeDef<TypeDefKind.InterfaceKind>;
+export declare function isKindArray(type: TypeDef<TypeDefKind>): type is TypeDef<TypeDefKind.ListKind>;
+export declare function isKindObject(type: TypeDef<TypeDefKind>): type is TypeDef<TypeDefKind.ObjectKind>;
+export declare function isKindEnum(type: TypeDef<TypeDefKind>): type is TypeDef<TypeDefKind.EnumKind>;
+export declare function isKindScalar(type: TypeDef<TypeDefKind>): type is TypeDef<TypeDefKind.ScalarKind>;
+export declare function isReferencableTypeDef(type: TypeDef<TypeDefKind>): boolean;
+export declare function getTypeDefArrayBaseType(type: TypeDef<TypeDefKind>): TypeDef<TypeDefKind>;
+//# sourceMappingURL=reference.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/dagger_module/reference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;CAAE,CAAA;AAEjE,MAAM,MAAM,gBAAgB,GACxB,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,GAC/B,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,GAC7B,OAAO,CAAC,WAAW,CAAC,SAAS,CAAC,GAC9B,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,GAC/B,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,CAAA;AAEtC,wBAAgB,WAAW,CACzB,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GACzB,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,CAEvC;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GACzB,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAEzC;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GACzB,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,CAEvC;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GACzB,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,CAEzC;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,OAAO,CAazE;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GACzB,OAAO,CAAC,WAAW,CAAC,CAMtB"}