@dagger.io/dagger 0.10.0 → 0.10.2

package/dist/entrypoint/load.js

@@ -10,198 +10,85 @@ export async function load(files) {
     await Promise.all(files.map(async (f) => await import(f)));
 }
 /**
- * Load the order of arguments for a given function from the scan result.
+ * Return the object invoked from the module.
  *
- * @param scanResult The result of the scan.
- * @param parentName The name of the class.
- * @param fnName The name of the function.
- *
- * @returns An array of strings representing the order of arguments.
- */
-export function loadArgOrder(scanResult, parentName, fnName) {
-    const classTypeDef = scanResult.classes[parentName];
-    if (!classTypeDef) {
-        throw new Error(`could not find class ${parentName}`);
-    }
-    // Call for the constructor
-    if (fnName === "") {
-        return Object.keys(classTypeDef.constructor?.args ?? {});
-    }
-    const methodTypeDef = classTypeDef.methods[fnName];
-    if (!methodTypeDef) {
-        throw new Error(`could not find method ${fnName}`);
-    }
-    return Object.keys(methodTypeDef.args);
-}
-/**
- * Load the argument for the given function and check if it's variadic.
- *
- * @param scanResult The result of the scan.
- * @param parentName The name of the class.
- * @param fnName The name of the function.
- * @param argName The name of the argument.
- *
- * @returns True if the argument is variadic, false otherwise.
- */
-export function isArgVariadic(scanResult, parentName, fnName, argName) {
-    const classTypeDef = scanResult.classes[parentName];
-    if (!classTypeDef) {
-        throw new Error(`could not find class ${parentName}`);
-    }
-    // It's not possible to have variadic arguments in the constructor.
-    if (fnName === "") {
-        return false;
-    }
-    const methodTypeDef = classTypeDef.methods[fnName];
-    if (!methodTypeDef) {
-        throw new Error(`could not find method ${fnName}`);
-    }
-    return methodTypeDef.args[argName].isVariadic;
-}
-/**
- * Load the argument type from the scan result.
- *
- * @param scanResult Result of the scan
- * @param parentName Class called
- * @param fnName Function called
- * @param argName Argument name
- * @returns The type of the argument
+ * @param module The module to load the object from.
+ * @param parentName The name of the parent object.
  */
-export function loadArgType(scanResult, parentName, fnName, argName) {
-    const classTypeDef = scanResult.classes[parentName];
-    if (!classTypeDef) {
-        throw new Error(`could not find class ${parentName}`);
-    }
-    // Call for the constructor
-    if (fnName === "") {
-        const argTypeDef = classTypeDef.constructor?.args[argName];
-        if (!argTypeDef) {
-            throw new Error(`could not find argument ${argName} type in constructor`);
-        }
-        return argTypeDef.typeDef;
-    }
-    const methodTypeDef = classTypeDef.methods[fnName];
-    if (!methodTypeDef) {
-        throw new Error(`could not find method ${fnName}`);
-    }
-    const argTypeDef = methodTypeDef.args[argName];
-    if (!argTypeDef) {
-        throw new Error(`could not find argument ${argName} type`);
-    }
-    return argTypeDef.typeDef;
+export function loadInvokedObject(module, parentName) {
+    return module.objects[parentName];
 }
-/**
- * Load the property type from the scan result.
- *
- * @param scanResult Result of the scan
- * @param parentName Class called
- * @param propertyName property of the class
- * @returns the type of the property
- */
-export function loadPropertyType(scanResult, parentName, propertyName) {
-    const classTypeDef = scanResult.classes[parentName];
-    if (!classTypeDef) {
-        throw new Error(`could not find class ${parentName}`);
-    }
-    const propertyTypeDef = classTypeDef.fields[propertyName];
-    if (!propertyTypeDef) {
-        throw new Error(`could not find property ${propertyName} type`);
+export function loadInvokedMethod(object, ctx) {
+    if (ctx.fnName === "") {
+        return object._constructor;
     }
-    return propertyTypeDef.typeDef;
+    return object.methods[ctx.fnName];
 }
 /**
- * Load the true name from the scan result
+ * Load the values of the arguments from the context.
  *
- * @param scanResult Result of the scan
- * @param parentName Class called
- * @param alias exposed name
- * @param kind location of the alias
+ * @param method Method to load the arguments from.
+ * @param ctx The context of the invocation.
  */
-export function loadName(scanResult, parentName, alias, kind) {
-    const classTypeDef = scanResult.classes[parentName];
-    if (!classTypeDef) {
-        throw new Error(`could not find class ${parentName}`);
-    }
-    switch (kind) {
-        case "object": {
-            return classTypeDef.name;
+export async function loadArgs(method, ctx) {
+    const args = {};
+    // Load arguments
+    for (const argName of method.getArgOrder()) {
+        const argument = method.arguments[argName];
+        if (!argument) {
+            throw new Error(`could not find argument ${argName}`);
         }
-        case "function": {
-            // Handle constructor
-            if (alias === "") {
-                return "";
-            }
-            const methodTypeDef = classTypeDef.methods[alias];
-            if (!methodTypeDef) {
-                throw new Error(`could not find method ${alias} type`);
+        const loadedArg = await loadValue(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.
+        // Note: variadic args are always last in the list of args.
+        if (argument.isVariadic) {
+            for (const [i, arg] of (loadedArg ?? []).entries()) {
+                args[`${argName}${i}`] = arg;
             }
-            return methodTypeDef.name;
+            continue;
         }
-        case "field": {
-            const propertyTypeDef = classTypeDef.fields[alias];
-            if (!propertyTypeDef) {
-                throw new Error(`could not find property ${alias}`);
-            }
-            return propertyTypeDef.name;
+        // If the argument is nullable and the loaded arg is undefined with no default value, we set it to null.
+        if (argument.isNullable &&
+            loadedArg === undefined &&
+            !argument.defaultValue) {
+            args[argName] = null;
+            continue;
         }
+        args[argName] = loadedArg;
     }
+    return args;
 }
 /**
- * Load the alias from the true property name.
- * If not found, return the original alias because it's not
- * a registered field.
- *
- * @param scanResult Result of the scan
- * @param parentName Class called
- * @param alias exposed name
- */
-export function loadResultAlias(scanResult, parentName, alias) {
-    const classTypeDef = scanResult.classes[parentName];
-    if (!classTypeDef) {
-        return alias;
-    }
-    const fieldTypeDef = Object.values(classTypeDef.fields).find((field) => field.name === alias);
-    if (!fieldTypeDef) {
-        return alias;
-    }
-    return fieldTypeDef.alias ?? fieldTypeDef.name;
-}
-/**
- * Return the eventual parent name of a field if its return type is a
- * registered object.
- * If not found, return the original parent name.
+ * Load the state of the parent object from the context.
  *
- * @param scanResult The result of the scan.
- * @param parentName Original parent name
- * @param alias The field alias
+ * @param object The object to load the parent state from.
+ * @param ctx The context of the invocation.
  */
-export function loadAliasParentName(scanResult, parentName, alias) {
-    const classTypeDef = scanResult.classes[parentName];
-    if (!classTypeDef) {
-        return parentName;
-    }
-    const fieldTypeDef = Object.values(classTypeDef.fields).find((field) => field.name === alias);
-    if (!fieldTypeDef) {
-        return parentName;
-    }
-    if (fieldTypeDef.typeDef.kind === TypeDefKind.ObjectKind) {
-        return fieldTypeDef.typeDef.name;
+export async function loadParentState(object, ctx) {
+    const parentState = {};
+    for (const [key, value] of Object.entries(ctx.parentArgs)) {
+        const property = object.properties[key];
+        if (!property) {
+            throw new Error(`could not find parent property ${key}`);
+        }
+        parentState[property.name] = await loadValue(value, property.type);
     }
-    return parentName;
+    return parentState;
 }
 /**
- * This function load the argument as a Dagger type.
+ * This function load the value as a Dagger type.
  *
  * Note: The JSON.parse() is required to remove extra quotes
  */
-export async function loadArg(value, type) {
+export async function loadValue(value, type) {
     // If value is undefinied, return it directly.
     if (value === undefined) {
         return value;
     }
     switch (type.kind) {
         case TypeDefKind.ListKind:
-            return Promise.all(value.map(async (v) => await loadArg(v, type.typeDef)));
+            return Promise.all(value.map(async (v) => await loadValue(v, type.typeDef)));
         case TypeDefKind.ObjectKind: {
             const objectType = type.name;
             // Workaround to call get any object that has an id
@@ -215,7 +102,7 @@ export async function loadArg(value, type) {
             // TODO(supports subfields serialization)
             return value;
         }
-        // Cannot use , to specify multiple matching case so instead we use fallthrough.
+        // Cannot use `,` to specify multiple matching case so instead we use fallthrough.
         case TypeDefKind.StringKind:
         case TypeDefKind.IntegerKind:
         case TypeDefKind.BooleanKind:
@@ -226,30 +113,60 @@ export async function loadArg(value, type) {
     }
 }
 /**
- * Load subfields of the result and IDable object.
+ * Load the object type from the return type of the method.
+ * This covers the case where the return type is an other object of the module.
+ * For example: `msg(): Message` where message is an object of the module.
  *
- * @param result The result of the invocation.
- * @param scanResult The result of the scan.
- * @param parentName The name of the parent object.
- * @returns Loaded result.
+ * @param module  The module to load the object from.
+ * @param object The current object to load the return type from.
+ * @param method The method to load the return type from.
  */
-export async function loadResult(result, scanResult, parentName) {
+export function loadObjectReturnType(module, object, method) {
+    const retType = method.returnType;
+    switch (retType.kind) {
+        case TypeDefKind.ListKind: {
+            // Loop until we find the original object type.
+            // This way we handle the list of list (e.g Object[][][]...[])
+            let listType = retType;
+            while (listType.kind === TypeDefKind.ListKind) {
+                listType = listType.typeDef;
+            }
+            return module.objects[listType.name];
+        }
+        case TypeDefKind.ObjectKind:
+            return module.objects[retType.name];
+        default:
+            return object;
+    }
+}
+export async function loadResult(result, module, object) {
     // Handle IDable objects
     if (result && typeof result?.id === "function") {
         result = await result.id();
     }
     // Handle arrays
     if (Array.isArray(result)) {
-        result = await Promise.all(result.map(async (r) => await loadResult(r, scanResult, parentName)));
+        result = await Promise.all(result.map(async (r) => await loadResult(r, module, object)));
         return result;
     }
     // Handle objects
     if (typeof result === "object") {
         const state = {};
         for (const [key, value] of Object.entries(result)) {
-            state[loadResultAlias(scanResult, parentName, key)] = await loadResult(value, scanResult, loadAliasParentName(scanResult, parentName, key));
+            const property = Object.values(object.properties).find((p) => p.name === key);
+            if (!property) {
+                throw new Error(`could not find result property ${key}`);
+            }
+            if (property.type.kind === TypeDefKind.ObjectKind) {
+                const referencedObject = module.objects[property.type.name];
+                if (referencedObject) {
+                    object = referencedObject;
+                }
+            }
+            state[property.alias ?? property.name] = await loadResult(value, module, object);
         }
-        result = state;
+        return state;
     }
+    // Handle primitive types
     return result;
 }

package/dist/entrypoint/register.d.ts

@@ -1,7 +1,7 @@
 import { ModuleID } from "../api/client.gen.js";
-import { ScanResult } from "../introspector/scanner/scan.js";
+import { DaggerModule } from "../introspector/scanner/abtractions/module.js";
 /**
  * Register the module files and returns its ID
  */
-export declare function register(files: string[], scanResult: ScanResult): Promise<ModuleID>;
+export declare function register(files: string[], module: DaggerModule): Promise<ModuleID>;
 //# sourceMappingURL=register.d.ts.map

package/dist/entrypoint/register.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../entrypoint/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAGT,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAU5D;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,QAAQ,CAAC,CA8CnB"}
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../entrypoint/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAGT,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAA;AAU5E;;GAEG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,QAAQ,CAAC,CA8CnB"}

package/dist/entrypoint/register.js

@@ -2,33 +2,33 @@ import { dag, TypeDefKind, } from "../api/client.gen.js";
 /**
  * Register the module files and returns its ID
  */
-export async function register(files, scanResult) {
+export async function register(files, module) {
     // Get a new module that we will fill in with all the types
     let mod = dag.module_();
     // Add module description if any.
-    if (scanResult.module.description) {
-        mod = mod.withDescription(scanResult.module.description);
+    if (module.description) {
+        mod = mod.withDescription(module.description);
     }
     // For each class scanned, register its type, method and properties in the module.
-    Object.values(scanResult.classes).forEach((modClass) => {
+    Object.values(module.objects).forEach((object) => {
         // Register the class Typedef object in Dagger
-        let typeDef = dag.typeDef().withObject(modClass.name, {
-            description: modClass.description,
+        let typeDef = dag.typeDef().withObject(object.name, {
+            description: object.description,
         });
         // Register all functions (methods) to this object
-        Object.values(modClass.methods).forEach((method) => {
-            typeDef = typeDef.withFunction(addFunction(method));
+        Object.values(object.methods).forEach((method) => {
+            typeDef = typeDef.withFunction(addFunction(method.typeDef));
         });
         // Register all fields that belong to this object
-        Object.values(modClass.fields).forEach((field) => {
+        Object.values(object.properties).forEach((field) => {
             if (field.isExposed) {
-                typeDef = typeDef.withField(field.alias ?? field.name, addTypeDef(field.typeDef), {
+                typeDef = typeDef.withField(field.alias ?? field.name, addTypeDef(field.typeDef.typeDef), {
                     description: field.description,
                 });
             }
         });
-        if (modClass.constructor) {
-            typeDef = typeDef.withConstructor(addConstructor(modClass.constructor, typeDef));
+        if (object._constructor) {
+            typeDef = typeDef.withConstructor(addConstructor(object._constructor.typeDef, typeDef));
         }
         // Add it to the module object
         mod = mod.withObject(typeDef);

package/dist/introspector/scanner/abtractions/argument.d.ts

@@ -0,0 +1,75 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { FunctionArgTypeDef, TypeDef } from "../typeDefs.js";
+export type Arguments = {
+    [name: string]: Argument;
+};
+/**
+ * Argument is an abstraction of a function argument.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export declare class Argument {
+    private symbol;
+    private checker;
+    private param;
+    /**
+     * Create a new Argument instance.
+     *
+     * @param checker Checker to use to introspect the type of the argument.
+     * @param param The symbol of the argument to introspect.
+     *
+     * @throws UnknownDaggerError If the symbol doesn't have any declaration.
+     * @throws UnknownDaggerError If the declaration of the symbol isn't a parameter.
+     */
+    constructor(checker: ts.TypeChecker, param: ts.Symbol);
+    get name(): string;
+    get description(): string;
+    /**
+     * Return the type of the argument in a Dagger TypeDef format.
+     */
+    get type(): TypeDef<TypeDefKind>;
+    get defaultValue(): string | undefined;
+    /**
+     * Return true if the parameter is optional.
+     *
+     * A parameter is considered optional if he fits one of the following:
+     * - It has a question token (e.g. `foo?: <type>`).
+     * - It's variadic (e.g. `...foo: <type>[]`).
+     * - It's nullable (e.g. `foo: <type> | null`).
+     */
+    get isOptional(): boolean;
+    /**
+     * Return true if the parameter is nullable.
+     *
+     * A parameter is considered nullable if itstype is a union type with `null`
+     * on the list of types.
+     * Example: `foo: string | null`.
+     */
+    get isNullable(): boolean;
+    get isVariadic(): boolean;
+    get typeDef(): FunctionArgTypeDef;
+    toJSON(): {
+        name: string;
+        description: string;
+        type: TypeDef<TypeDefKind>;
+        isVariadic: boolean;
+        isNullable: boolean;
+        isOptional: boolean;
+        defaultValue: string | undefined;
+    };
+    /**
+     * The TypeScript Compiler API returns the raw default value as it is written
+     * by the user.
+     * However, some notations are not supported by GraphQL so this function
+     * formats the default value to be compatible with the GraphQL syntax.
+     *
+     * Formatting rules:
+     * - Single quote strings are converted to double quote strings.
+     *
+     * @param value The value to format.
+     */
+    private formatDefaultValue;
+}
+//# sourceMappingURL=argument.d.ts.map

package/dist/introspector/scanner/abtractions/argument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/argument.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAI5D,MAAM,MAAM,SAAS,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAA;AAEpD;;;;;GAKG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAW;IAEzB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,KAAK,CAAyB;IAEtC;;;;;;;;OAQG;gBACS,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,KAAK,EAAE,EAAE,CAAC,MAAM;IAuBrD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,CAgB/B;IAED,IAAI,YAAY,IAAI,MAAM,GAAG,SAAS,CAMrC;IAED;;;;;;;OAOG;IACH,IAAI,UAAU,IAAI,OAAO,CAMxB;IAED;;;;;;OAMG;IACH,IAAI,UAAU,IAAI,OAAO,CAcxB;IAED,IAAI,UAAU,IAAI,OAAO,CAExB;IAID,IAAI,OAAO,IAAI,kBAAkB,CAShC;IAED,MAAM;;;;;;;;;IAYN;;;;;;;;;;OAUG;IACH,OAAO,CAAC,kBAAkB;CAU3B"}

package/dist/introspector/scanner/abtractions/argument.js

@@ -0,0 +1,137 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { serializeType } from "../serialize.js";
+import { typeNameToTypedef } from "../utils.js";
+/**
+ * Argument is an abstraction of a function argument.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export class Argument {
+    symbol;
+    checker;
+    param;
+    /**
+     * Create a new Argument instance.
+     *
+     * @param checker Checker to use to introspect the type of the argument.
+     * @param param The symbol of the argument to introspect.
+     *
+     * @throws UnknownDaggerError If the symbol doesn't have any declaration.
+     * @throws UnknownDaggerError If the declaration of the symbol isn't a parameter.
+     */
+    constructor(checker, param) {
+        this.symbol = param;
+        this.checker = checker;
+        const declarations = this.symbol.getDeclarations();
+        if (!declarations || declarations.length < 0) {
+            throw new UnknownDaggerError(`could not find param declarations of symbol ${this.symbol.name}`, {});
+        }
+        const parameterDeclaration = declarations[0];
+        if (!ts.isParameter(parameterDeclaration)) {
+            throw new UnknownDaggerError(`the declaration of symbol ${this.symbol.name} isn't a parameter`, {});
+        }
+        this.param = parameterDeclaration;
+    }
+    get name() {
+        return this.symbol.getName();
+    }
+    get description() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    /**
+     * Return the type of the argument in a Dagger TypeDef format.
+     */
+    get type() {
+        if (!this.symbol.valueDeclaration) {
+            throw new UnknownDaggerError("could not find symbol value declaration", {});
+        }
+        const type = this.checker.getTypeOfSymbolAtLocation(this.symbol, this.symbol.valueDeclaration);
+        const typeName = serializeType(this.checker, type);
+        return typeNameToTypedef(typeName);
+    }
+    get defaultValue() {
+        if (this.param.initializer === undefined) {
+            return undefined;
+        }
+        return this.formatDefaultValue(this.param.initializer.getText());
+    }
+    /**
+     * Return true if the parameter is optional.
+     *
+     * A parameter is considered optional if he fits one of the following:
+     * - It has a question token (e.g. `foo?: <type>`).
+     * - It's variadic (e.g. `...foo: <type>[]`).
+     * - It's nullable (e.g. `foo: <type> | null`).
+     */
+    get isOptional() {
+        return (this.param.questionToken !== undefined ||
+            this.isVariadic ||
+            this.isNullable);
+    }
+    /**
+     * Return true if the parameter is nullable.
+     *
+     * A parameter is considered nullable if itstype is a union type with `null`
+     * on the list of types.
+     * Example: `foo: string | null`.
+     */
+    get isNullable() {
+        if (!this.param.type) {
+            return false;
+        }
+        if (ts.isUnionTypeNode(this.param.type)) {
+            for (const _type of this.param.type.types) {
+                if (_type.getText() === "null") {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    get isVariadic() {
+        return this.param.dotDotDotToken !== undefined;
+    }
+    // TODO(TomChv): replace with `ToJson` method
+    // after the refactor is complete.
+    get typeDef() {
+        return {
+            name: this.name,
+            description: this.description,
+            optional: this.isOptional,
+            defaultValue: this.defaultValue,
+            isVariadic: this.isVariadic,
+            typeDef: this.type,
+        };
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            type: this.type,
+            isVariadic: this.isVariadic,
+            isNullable: this.isNullable,
+            isOptional: this.isOptional,
+            defaultValue: this.defaultValue,
+        };
+    }
+    /**
+     * The TypeScript Compiler API returns the raw default value as it is written
+     * by the user.
+     * However, some notations are not supported by GraphQL so this function
+     * formats the default value to be compatible with the GraphQL syntax.
+     *
+     * Formatting rules:
+     * - Single quote strings are converted to double quote strings.
+     *
+     * @param value The value to format.
+     */
+    formatDefaultValue(value) {
+        const isSingleQuoteString = () => value.startsWith("'") && value.endsWith("'");
+        if (isSingleQuoteString()) {
+            return `"${value.slice(1, value.length - 1)}"`;
+        }
+        return value;
+    }
+}

package/dist/introspector/scanner/abtractions/constructor.d.ts

@@ -0,0 +1,16 @@
+import ts from "typescript";
+import { Arguments } from "./argument.js";
+import { ConstructorTypeDef } from "../typeDefs.js";
+export declare class Constructor {
+    private checker;
+    private declaration;
+    constructor(checker: ts.TypeChecker, declaration: ts.ConstructorDeclaration);
+    get name(): string;
+    get arguments(): Arguments;
+    get typeDef(): ConstructorTypeDef;
+    toJSON(): {
+        args: Arguments;
+    };
+    getArgOrder(): string[];
+}
+//# sourceMappingURL=constructor.d.ts.map

package/dist/introspector/scanner/abtractions/constructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructor.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/constructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAY,SAAS,EAAE,MAAM,eAAe,CAAA;AACnD,OAAO,EAAE,kBAAkB,EAAsB,MAAM,gBAAgB,CAAA;AAEvE,qBAAa,WAAW;IACtB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,WAAW,CAA2B;gBAElC,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,EAAE,CAAC,sBAAsB;IAK3E,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,SAAS,IAAI,SAAS,CAgBzB;IAID,IAAI,OAAO,IAAI,kBAAkB,CAWhC;IAED,MAAM;;;IAMN,WAAW,IAAI,MAAM,EAAE;CAGxB"}

package/dist/introspector/scanner/abtractions/constructor.js

@@ -0,0 +1,42 @@
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { Argument } from "./argument.js";
+export class Constructor {
+    checker;
+    declaration;
+    constructor(checker, declaration) {
+        this.checker = checker;
+        this.declaration = declaration;
+    }
+    get name() {
+        return "";
+    }
+    get arguments() {
+        return this.declaration.parameters.reduce((acc, param) => {
+            const symbol = this.checker.getSymbolAtLocation(param.name);
+            if (!symbol) {
+                throw new UnknownDaggerError(`could not get constructor param: ${param.name.getText()}`, {});
+            }
+            const argument = new Argument(this.checker, symbol);
+            acc[argument.name] = argument;
+            return acc;
+        }, {});
+    }
+    // TODO(TomChv): replace with `ToJson` method
+    // after the refactor is complete.
+    get typeDef() {
+        return {
+            args: Object.entries(this.arguments).reduce((acc, [name, arg]) => {
+                acc[name] = arg.typeDef;
+                return acc;
+            }, {}),
+        };
+    }
+    toJSON() {
+        return {
+            args: this.arguments,
+        };
+    }
+    getArgOrder() {
+        return Object.keys(this.arguments);
+    }
+}