@dagger.io/dagger 0.0.1-0

package/dist/src/module/introspector/typescript_module/ast.js

@@ -0,0 +1,476 @@
+import * as path from "path";
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { IntrospectionError } from "../../../common/errors/index.js";
+import { isDeclarationOf } from "./declarations.js";
+export const CLIENT_GEN_FILE = "client.gen.ts";
+export class AST {
+    files;
+    userModule;
+    checker;
+    sourceFiles;
+    constructor(files, userModule) {
+        this.files = files;
+        this.userModule = userModule;
+        this.files = files.map((f) => path.resolve(f));
+        const program = ts.createProgram(files, {
+            experimentalDecorators: true,
+            moduleResolution: ts.ModuleResolutionKind.Node10,
+            target: ts.ScriptTarget.ES2022,
+        });
+        this.checker = program.getTypeChecker();
+        this.sourceFiles = program
+            .getSourceFiles()
+            .filter((file) => !file.isDeclarationFile);
+    }
+    findResolvedNodeByName(name, 
+    /**
+     * Optionally look for a specific node kind if we already know
+     * what we're looking for.
+     */
+    kind) {
+        let result;
+        for (const sourceFile of this.sourceFiles) {
+            ts.forEachChild(sourceFile, (node) => {
+                if (result !== undefined)
+                    return;
+                // Skip if it's not from the client gen nor the user module
+                if (!sourceFile.fileName.endsWith(CLIENT_GEN_FILE) &&
+                    !this.files.includes(path.resolve(sourceFile.fileName))) {
+                    return;
+                }
+                if (kind !== undefined && node.kind === kind) {
+                    const isDeclarationValid = isDeclarationOf[kind](node);
+                    if (!isDeclarationValid)
+                        return;
+                    const convertedNode = node;
+                    if (!convertedNode.name || convertedNode.name.getText() !== name) {
+                        return;
+                    }
+                    const symbol = this.checker.getSymbolAtLocation(convertedNode.name);
+                    if (!symbol) {
+                        console.debug(`missing symbol for ${name} at ${sourceFile.fileName}:${node.pos}`);
+                        return;
+                    }
+                    result = {
+                        type: kind,
+                        node: convertedNode,
+                        symbol: symbol,
+                        file: sourceFile,
+                    };
+                }
+            });
+        }
+        return result;
+    }
+    findAllDeclarations(kind) {
+        const results = [];
+        for (const sourceFile of this.sourceFiles) {
+            ts.forEachChild(sourceFile, (node) => {
+                // Skip if it's not from the client gen nor the user module
+                if (!sourceFile.fileName.endsWith(CLIENT_GEN_FILE) &&
+                    !this.files.includes(path.resolve(sourceFile.fileName))) {
+                    return;
+                }
+                if (kind !== undefined && node.kind === kind) {
+                    const isDeclarationValid = isDeclarationOf[kind](node);
+                    if (!isDeclarationValid)
+                        return;
+                    const convertedNode = node;
+                    if (!convertedNode.name) {
+                        return;
+                    }
+                    const symbol = this.checker.getSymbolAtLocation(convertedNode.name);
+                    if (!symbol) {
+                        console.debug(`missing symbol for ${convertedNode.name.getText()} at ${sourceFile.fileName}:${node.pos}`);
+                        return;
+                    }
+                    results.push({
+                        type: kind,
+                        node: convertedNode,
+                        symbol: symbol,
+                        file: sourceFile,
+                    });
+                }
+            });
+        }
+        return results;
+    }
+    getTypeFromTypeAlias(typeAlias) {
+        const symbol = this.getSymbolOrThrow(typeAlias.name);
+        return this.checker.getDeclaredTypeOfSymbol(symbol);
+    }
+    static getNodePosition(node) {
+        const sourceFile = node.getSourceFile();
+        const position = ts.getLineAndCharacterOfPosition(sourceFile, node.getStart());
+        return `${sourceFile.fileName}:${position.line}:${position.character}`;
+    }
+    /**
+     * Returns the location of the node in the source file.
+     *
+     * The filepath is relative to the module root directory.
+     * Ideally, we use the identifier of the node accessible by node.name but fallback
+     * to node itself if it's not available.
+     *
+     * The TypeScript SDK based it's line and column on index 0 but editors starts
+     * at 1 so we always add 1 to fix that difference.
+     */
+    static getNodeLocation(node) {
+        const sourceFile = node.getSourceFile();
+        // Use the identifier of the node if available.
+        const targetNode = node.name ?? node;
+        const position = ts.getLineAndCharacterOfPosition(sourceFile, targetNode.getStart(sourceFile));
+        // sourceFile.fileName is the absolute path to the file, we need to get the relative path
+        // from the module path so we exclude the module path from the given path.
+        // But since root will always start with `/src`, we want to catch the second `src`
+        // inside the module.
+        const pathParts = path.resolve(sourceFile.fileName).split(path.sep);
+        const srcIndex = pathParts.indexOf("src", 2);
+        return {
+            filepath: pathParts.slice(srcIndex).join(path.sep),
+            line: position.line + 1,
+            column: position.character + 1,
+        };
+    }
+    getDocFromSymbol(symbol) {
+        return this.getSymbolDoc(symbol).description;
+    }
+    getSymbolDoc(symbol) {
+        const description = ts
+            .displayPartsToString(symbol.getDocumentationComment(this.checker))
+            .trim();
+        let deprecated;
+        let hasDeprecatedTag = false;
+        for (const tag of symbol.getJsDocTags()) {
+            if (tag.name !== "deprecated")
+                continue;
+            hasDeprecatedTag = true;
+            const text = tag.text?.map((part) => ("text" in part ? part.text : part)).join("") ??
+                "";
+            deprecated = text.trim();
+            break;
+        }
+        if (!hasDeprecatedTag) {
+            return { description };
+        }
+        return {
+            description,
+            deprecated: deprecated ?? "",
+        };
+    }
+    getSymbolOrThrow(node) {
+        const symbol = this.getSymbol(node);
+        if (!symbol) {
+            throw new IntrospectionError(`could not find symbol at ${AST.getNodePosition(node)}`);
+        }
+        return symbol;
+    }
+    getSignatureFromFunctionOrThrow(node) {
+        const signature = this.checker.getSignatureFromDeclaration(node);
+        if (!signature) {
+            throw new IntrospectionError(`could not find signature at ${AST.getNodePosition(node)}`);
+        }
+        return signature;
+    }
+    getSymbol(node) {
+        return this.checker.getSymbolAtLocation(node);
+    }
+    isNodeDecoratedWith(node, daggerDecorator) {
+        const decorators = ts.getDecorators(node);
+        if (!decorators) {
+            return false;
+        }
+        const decorator = decorators.find((d) => d.expression.getText().startsWith(daggerDecorator));
+        if (!decorator) {
+            return false;
+        }
+        if (!ts.isCallExpression(decorator.expression)) {
+            throw new IntrospectionError(`decorator at ${AST.getNodePosition(node)} should be a call expression, please use ${daggerDecorator}() instead.`);
+        }
+        return true;
+    }
+    getDecoratorArgument(node, daggerDecorator, type, position = 0) {
+        const decorators = ts.getDecorators(node);
+        if (!decorators) {
+            return undefined;
+        }
+        const decorator = decorators.find((d) => d.expression.getText().startsWith(daggerDecorator));
+        if (!decorator) {
+            return undefined;
+        }
+        const argument = decorator.expression.arguments[position];
+        if (!argument) {
+            return undefined;
+        }
+        switch (type) {
+            case "string":
+                return argument.getText();
+            case "object":
+                return eval(`(${argument.getText()})`);
+        }
+    }
+    unwrapTypeStringFromPromise(type) {
+        if (type.startsWith("Promise<")) {
+            return type.slice("Promise<".length, -">".length);
+        }
+        if (type.startsWith("Awaited<")) {
+            return type.slice("Awaited<".length, -">".length);
+        }
+        return type;
+    }
+    unwrapTypeStringFromArray(type) {
+        if (type.endsWith("[]")) {
+            return type.replace("[]", "");
+        }
+        if (type.startsWith("Array<")) {
+            return type.slice("Array<".length, -">".length);
+        }
+        return type;
+    }
+    stringTypeToUnwrappedType(type) {
+        type = this.unwrapTypeStringFromPromise(type);
+        // If they are difference, that means we upwrapped the array.
+        const extractedTypeFromArray = this.unwrapTypeStringFromArray(type);
+        if (extractedTypeFromArray !== type) {
+            return this.stringTypeToUnwrappedType(extractedTypeFromArray);
+        }
+        return type;
+    }
+    typeToStringType(type) {
+        const stringType = this.checker.typeToString(type);
+        return this.stringTypeToUnwrappedType(stringType);
+    }
+    tsTypeToTypeDef(node, type) {
+        if (type.flags & ts.TypeFlags.String)
+            return { kind: TypeDefKind.StringKind };
+        if (type.flags & ts.TypeFlags.Number) {
+            // Float will be interpreted as number by the TypeScript compiler so we need to check if the
+            // text is "float" to know if it's a float or an integer.
+            // It can also be interpreted as a reference, but this is handled separately at an upper level.
+            if (node.getText().includes("float")) {
+                return { kind: TypeDefKind.FloatKind };
+            }
+            return { kind: TypeDefKind.IntegerKind };
+        }
+        if (type.flags & ts.TypeFlags.Boolean)
+            return { kind: TypeDefKind.BooleanKind };
+        if (type.flags & ts.TypeFlags.Void)
+            return { kind: TypeDefKind.VoidKind };
+        // If a type has a flag Object, is can basically be anything.
+        // We firstly wants to see if it's a promise or an array so we can unwrap the
+        // actual type.
+        if (type.flags & ts.TypeFlags.Object) {
+            const objectType = type;
+            // If it's a reference, that means it's a generic type like
+            // `Promise<T>` or `number[]` or `Array<T>`.
+            if (objectType.objectFlags & ts.ObjectFlags.Reference) {
+                const typeArguments = this.checker.getTypeArguments(type);
+                switch (typeArguments.length) {
+                    case 0:
+                        // Might change after to support more complex type
+                        break;
+                    case 1: {
+                        const typeArgument = typeArguments[0];
+                        if (type.symbol.getName() === "Promise") {
+                            return this.tsTypeToTypeDef(node, typeArgument);
+                        }
+                        if (type.symbol.getName() === "Array") {
+                            return {
+                                kind: TypeDefKind.ListKind,
+                                typeDef: this.tsTypeToTypeDef(node, typeArgument),
+                            };
+                        }
+                        return undefined;
+                    }
+                    default: {
+                        throw new IntrospectionError(`could not resolve type ${type.symbol.getName()} at ${AST.getNodePosition(node)}, dagger does not support generics with argument yet.`);
+                    }
+                }
+            }
+        }
+    }
+    resolveParameterDefaultValueTypeReference(expression, value) {
+        const type = typeof value;
+        switch (type) {
+            case "string":
+            case "number": // float is also included here
+            case "bigint":
+            case "boolean":
+            case "object":
+                // Value will be jsonified on registration.
+                return value;
+            default:
+                // If we cannot resolve the value, we skip it and let the value be resolved automatically by the runtime
+                return undefined;
+        }
+    }
+    // Try to extract literal values (enum members, string/number/boolean/bigint
+    // literals) directly from the type checker. Returns undefined if the
+    // expression is not a literal.
+    getLiteralValueFromExpression(expression) {
+        const type = this.checker.getTypeAtLocation(expression);
+        if (!type) {
+            return undefined;
+        }
+        const resolveLiteral = (t) => {
+            if (t.flags & ts.TypeFlags.BooleanLiteral) {
+                const intrinsic = t;
+                // Handle boolean value
+                switch (intrinsic.intrinsicName) {
+                    case "true":
+                        return true;
+                    case "false":
+                        return false;
+                }
+            }
+            if (t.flags &
+                (ts.TypeFlags.EnumLiteral |
+                    ts.TypeFlags.StringLiteral |
+                    ts.TypeFlags.NumberLiteral |
+                    ts.TypeFlags.BigIntLiteral)) {
+                const literal = t;
+                if (literal.value !== undefined) {
+                    return literal.value;
+                }
+                // Some literals only expose `intrinsicName`. Example:
+                // const yes = true; function use(flag: boolean = yes) {}
+                // The checker reports `intrinsicName: "true"` without a `value`, so we fallback.
+                const intrinsic = literal;
+                if (intrinsic.intrinsicName !== undefined) {
+                    return intrinsic.intrinsicName;
+                }
+            }
+            return undefined;
+        };
+        if (type.isUnion()) {
+            // Walk union members to surface the literal. Example:
+            // ```ts
+            // const defaults = { proto: NetworkProtocol.Udp }
+            // function use(proto: NetworkProtocol = defaults.proto) {}
+            // ```
+            // The checker reports `defaults.proto` as `NetworkProtocol.Tcp | NetworkProtocol.Udp`,
+            // so we inspect each subtype to recover the actual default value.
+            for (const subtype of type.types) {
+                const literal = resolveLiteral(subtype);
+                if (literal !== undefined) {
+                    return literal;
+                }
+            }
+            return undefined;
+        }
+        return resolveLiteral(type);
+    }
+    warnUnresolvedDefaultValue(expression) {
+        console.warn(`default value '${expression.getText()}' at ${AST.getNodePosition(expression)} cannot be resolved, dagger does not support object or function as default value. 
+          The value will be ignored by the introspection and resolve at the runtime.`);
+    }
+    resolveParameterDefaultValue(expression) {
+        const kind = expression.kind;
+        switch (kind) {
+            case ts.SyntaxKind.StringLiteral:
+                return `${eval(expression.getText())}`;
+            case ts.SyntaxKind.NumericLiteral:
+                return parseInt(expression.getText());
+            case ts.SyntaxKind.TrueKeyword:
+                return true;
+            case ts.SyntaxKind.FalseKeyword:
+                return false;
+            case ts.SyntaxKind.NullKeyword:
+                return null;
+            case ts.SyntaxKind.ArrayLiteralExpression:
+                return eval(expression.getText());
+            case ts.SyntaxKind.Identifier: {
+                const symbol = this.checker.getSymbolAtLocation(expression);
+                if (!symbol) {
+                    throw new IntrospectionError(`could not resolve default value reference to the variable: '${expression.getText()}' from ${AST.getNodePosition(expression)}. Is it exported by the module?`);
+                }
+                // Parse the default value from the variable declaration
+                // ```
+                // export const foo = "A"
+                //
+                // function bar(baz: string = foo) {}
+                // ```
+                const decl = symbol.valueDeclaration ?? symbol.declarations?.[0];
+                if (!decl) {
+                    this.warnUnresolvedDefaultValue(expression);
+                    return undefined;
+                }
+                if (ts.isVariableDeclaration(decl) && decl.initializer) {
+                    return this.resolveParameterDefaultValue(decl.initializer);
+                }
+                // Parse the default value from the enum member
+                // ```
+                // enum Foo {
+                //   A = "a"
+                // }
+                //
+                // function bar(baz: string = Foo.A) {}
+                // ```
+                if (ts.isEnumMember(decl)) {
+                    const val = this.checker.getConstantValue(decl);
+                    if (val !== undefined)
+                        return val;
+                    if (decl.initializer)
+                        return this.resolveParameterDefaultValue(decl.initializer);
+                }
+                // Parse the default value from the import specifier
+                // ```
+                // import { foo } from "bar"
+                //
+                // function bar(baz: string = foo) {}
+                // ```
+                if (ts.isImportSpecifier(decl)) {
+                    const aliased = this.checker.getAliasedSymbol(symbol);
+                    const aliasedDecl = aliased?.valueDeclaration ?? aliased?.declarations?.[0];
+                    if (aliasedDecl &&
+                        ts.isVariableDeclaration(aliasedDecl) &&
+                        aliasedDecl.initializer) {
+                        return this.resolveParameterDefaultValue(aliasedDecl.initializer);
+                    }
+                }
+                // Warn the user if the default value cannot be resolved
+                this.warnUnresolvedDefaultValue(expression);
+                return undefined;
+            }
+            case ts.SyntaxKind.PropertyAccessExpression: {
+                const propertyAccess = expression;
+                // Quick path: TypeScript already computed the literal value.
+                const directConstant = this.checker.getConstantValue(propertyAccess);
+                if (directConstant !== undefined) {
+                    return directConstant;
+                }
+                // Otherwise inspect the enum member backing the property accessor.
+                const nameSymbol = this.checker.getSymbolAtLocation(propertyAccess.name);
+                if (nameSymbol) {
+                    const declarations = nameSymbol.declarations ?? [];
+                    const decls = nameSymbol.valueDeclaration
+                        ? [nameSymbol.valueDeclaration, ...declarations]
+                        : declarations;
+                    for (const decl of decls) {
+                        if (ts.isEnumMember(decl)) {
+                            const val = this.checker.getConstantValue(decl);
+                            if (val !== undefined) {
+                                return val;
+                            }
+                            if (decl.initializer) {
+                                return this.resolveParameterDefaultValue(decl.initializer);
+                            }
+                        }
+                    }
+                }
+                // Fall back to literal type information if available.
+                const literal = this.getLiteralValueFromExpression(propertyAccess);
+                if (literal !== undefined) {
+                    return literal;
+                }
+                // Warn the user if the default value cannot be resolved.
+                this.warnUnresolvedDefaultValue(expression);
+                return undefined;
+            }
+            default: {
+                // Warn the user if the default value cannot be resolved
+                this.warnUnresolvedDefaultValue(expression);
+            }
+        }
+    }
+}

package/dist/src/module/introspector/typescript_module/declarations.d.ts

@@ -0,0 +1,15 @@
+import ts from "typescript";
+export type DeclarationsMap = {
+    [ts.SyntaxKind.ClassDeclaration]: ts.ClassDeclaration;
+    [ts.SyntaxKind.MethodDeclaration]: ts.MethodDeclaration;
+    [ts.SyntaxKind.PropertyDeclaration]: ts.PropertyDeclaration;
+    [ts.SyntaxKind.FunctionDeclaration]: ts.FunctionDeclaration;
+    [ts.SyntaxKind.EnumDeclaration]: ts.EnumDeclaration;
+    [ts.SyntaxKind.InterfaceDeclaration]: ts.InterfaceDeclaration;
+    [ts.SyntaxKind.TypeAliasDeclaration]: ts.TypeAliasDeclaration;
+};
+export type Declarations<T extends ts.SyntaxKind> = T extends keyof DeclarationsMap ? DeclarationsMap[T] : ts.Node;
+export declare const isDeclarationOf: {
+    [K in keyof DeclarationsMap]: (node: ts.Node) => node is DeclarationsMap[K];
+};
+//# sourceMappingURL=declarations.d.ts.map

package/dist/src/module/introspector/typescript_module/declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/typescript_module/declarations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,MAAM,MAAM,eAAe,GAAG;IAC5B,CAAC,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAA;IACrD,CAAC,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAA;IACvD,CAAC,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAA;IAC3D,CAAC,EAAE,CAAC,UAAU,CAAC,mBAAmB,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAA;IAC3D,CAAC,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE,EAAE,CAAC,eAAe,CAAA;IACnD,CAAC,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAA;IAC7D,CAAC,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE,EAAE,CAAC,oBAAoB,CAAA;CAC9D,CAAA;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,EAAE,CAAC,UAAU,IAC9C,CAAC,SAAS,MAAM,eAAe,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,IAAI,CAAA;AAEhE,eAAO,MAAM,eAAe,EAAE;KAC3B,CAAC,IAAI,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,IAAI,IAAI,eAAe,CAAC,CAAC,CAAC;CAS5E,CAAA"}

package/dist/src/module/introspector/typescript_module/declarations.js

@@ -0,0 +1,10 @@
+import ts from "typescript";
+export const isDeclarationOf = {
+    [ts.SyntaxKind.ClassDeclaration]: ts.isClassDeclaration,
+    [ts.SyntaxKind.MethodDeclaration]: ts.isMethodDeclaration,
+    [ts.SyntaxKind.PropertyDeclaration]: ts.isPropertyDeclaration,
+    [ts.SyntaxKind.FunctionDeclaration]: ts.isFunctionDeclaration,
+    [ts.SyntaxKind.EnumDeclaration]: ts.isEnumDeclaration,
+    [ts.SyntaxKind.InterfaceDeclaration]: ts.isInterfaceDeclaration,
+    [ts.SyntaxKind.TypeAliasDeclaration]: ts.isTypeAliasDeclaration,
+};

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

@@ -0,0 +1,4 @@
+export * from "./ast.js";
+export * from "./typedef_utils.js";
+export * from "./location.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/typescript_module/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,oBAAoB,CAAA;AAClC,cAAc,eAAe,CAAA"}

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

@@ -0,0 +1,3 @@
+export * from "./ast.js";
+export * from "./typedef_utils.js";
+export * from "./location.js";

package/dist/src/module/introspector/typescript_module/location.d.ts

@@ -0,0 +1,6 @@
+export type Location = {
+    filepath: string;
+    line: number;
+    column: number;
+};
+//# sourceMappingURL=location.d.ts.map

package/dist/src/module/introspector/typescript_module/location.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/typescript_module/location.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf,CAAA"}

package/dist/src/module/introspector/typescript_module/location.js

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

package/dist/src/module/introspector/typescript_module/typedef_utils.d.ts

@@ -0,0 +1,5 @@
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typedef.js";
+export declare function isTypeDefResolved(typeDef: TypeDef<TypeDefKind>): boolean;
+export declare function resolveTypeDef(typeDef: TypeDef<TypeDefKind> | undefined, reference: TypeDef<TypeDefKind>): TypeDef<TypeDefKind>;
+//# sourceMappingURL=typedef_utils.d.ts.map

package/dist/src/module/introspector/typescript_module/typedef_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedef_utils.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/typescript_module/typedef_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAExD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,OAAO,CAgBxE;AAED,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,SAAS,EACzC,SAAS,EAAE,OAAO,CAAC,WAAW,CAAC,GAC9B,OAAO,CAAC,WAAW,CAAC,CAetB"}

package/dist/src/module/introspector/typescript_module/typedef_utils.js

@@ -0,0 +1,26 @@
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { IntrospectionError } from "../../../common/errors/index.js";
+export function isTypeDefResolved(typeDef) {
+    if (typeDef.kind !== TypeDefKind.ListKind) {
+        return true;
+    }
+    const arrayTypeDef = typeDef;
+    if (arrayTypeDef.typeDef === undefined) {
+        return false;
+    }
+    if (arrayTypeDef.typeDef.kind === TypeDefKind.ListKind) {
+        return isTypeDefResolved(arrayTypeDef.typeDef);
+    }
+    return true;
+}
+export function resolveTypeDef(typeDef, reference) {
+    if (typeDef === undefined) {
+        return reference;
+    }
+    if (typeDef.kind === TypeDefKind.ListKind) {
+        const listTypeDef = typeDef;
+        listTypeDef.typeDef = resolveTypeDef(listTypeDef.typeDef, reference);
+        return listTypeDef;
+    }
+    throw new IntrospectionError(`type ${JSON.stringify(typeDef)} has already been resolved, it should not be overwritten ; reference: ${JSON.stringify(reference)}`);
+}

package/dist/src/module/introspector/utils/files.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a list of path of all files in the given directory
+ */
+export declare function listFiles(dir?: string): Promise<string[]>;
+//# sourceMappingURL=files.d.ts.map

package/dist/src/module/introspector/utils/files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files.d.ts","sourceRoot":"","sources":["../../../../../src/module/introspector/utils/files.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,wBAAsB,SAAS,CAAC,GAAG,SAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA0B5D"}

package/dist/src/module/introspector/utils/files.js

@@ -0,0 +1,28 @@
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Extensions supported by the loader.
+ */
+const allowedExtensions = [".ts", ".mts"];
+/**
+ * Returns a list of path of all files in the given directory
+ */
+export async function listFiles(dir = ".") {
+    const res = await Promise.all(fs.readdirSync(dir).map(async (file) => {
+        const filepath = path.join(dir, file);
+        // Ignore node_modules and transpiled typescript
+        if (filepath.includes("node_modules") || filepath.includes("dist")) {
+            return [];
+        }
+        const stat = fs.statSync(filepath);
+        if (stat.isDirectory()) {
+            return await listFiles(filepath);
+        }
+        const ext = path.extname(filepath);
+        if (allowedExtensions.find((allowedExt) => allowedExt === ext)) {
+            return [path.join(dir, file)];
+        }
+        return [];
+    }));
+    return res.reduce((p, c) => [...c, ...p], []);
+}