@dagger.io/dagger 0.13.3 → 0.13.4

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

@@ -0,0 +1,55 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typeDefs.js";
+export type Properties = {
+    [name: string]: Property;
+};
+/**
+ * Property is an abstraction of a class property.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export declare class Property {
+    private symbol;
+    private checker;
+    private property;
+    private decorator;
+    private _name;
+    private _description;
+    private _alias;
+    private _type;
+    private _isExposed;
+    /**
+     *
+     * @param checker Checker to use to introspect the property.
+     * @param property The property to introspect.
+     *
+     * @throws UnknownDaggerError If the property doesn't have any symbol.
+     */
+    constructor(checker: ts.TypeChecker, property: ts.PropertyDeclaration);
+    get name(): string;
+    get description(): string;
+    /**
+     * Return the alias of the property if it has one.
+     */
+    get alias(): string | undefined;
+    /**
+     * Return the type of the property in a Dagger TypeDef format.
+     */
+    get type(): TypeDef<TypeDefKind>;
+    get isExposed(): boolean;
+    toJSON(): {
+        name: string;
+        description: string;
+        alias: string | undefined;
+        type: TypeDef<TypeDefKind>;
+        isExposed: boolean;
+    };
+    private loadName;
+    private loadDescription;
+    private loadAlias;
+    private loadType;
+    private loadIsExposed;
+}
+//# sourceMappingURL=property.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"property.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/property.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAGxD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAMxC,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAA;CAAE,CAAA;AAErD;;;;;GAKG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAW;IAEzB,OAAO,CAAC,OAAO,CAAgB;IAE/B,OAAO,CAAC,QAAQ,CAAwB;IAExC,OAAO,CAAC,SAAS,CAA0B;IAG3C,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,UAAU,CAAS;IAE3B;;;;;;OAMG;gBACS,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE,CAAC,mBAAmB;IAiCrE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,OAAO,CAAC,WAAW,CAAC,CAE/B;IAED,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,MAAM;;;;;;;IAUN,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,QAAQ;IAgBhB,OAAO,CAAC,aAAa;CAGtB"}

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

@@ -0,0 +1,110 @@
+import ts from "typescript";
+import { UnknownDaggerError } from "../../../common/errors/UnknownDaggerError.js";
+import { field, func } from "../../decorators/decorators.js";
+import { typeToTypedef } from "./typeToTypedef.js";
+const DEPRECATED_PROPERTY_DECORATOR = field.name;
+const PROPERTY_DECORATOR = func.name;
+/**
+ * Property is an abstraction of a class property.
+ *
+ * This aims to simplify and adds clarity to how we analyse the code and using
+ * clear accessor.
+ */
+export class Property {
+    symbol;
+    checker;
+    property;
+    decorator;
+    // Preloaded values.
+    _name;
+    _description;
+    _alias;
+    _type;
+    _isExposed;
+    /**
+     *
+     * @param checker Checker to use to introspect the property.
+     * @param property The property to introspect.
+     *
+     * @throws UnknownDaggerError If the property doesn't have any symbol.
+     */
+    constructor(checker, property) {
+        this.checker = checker;
+        this.property = property;
+        const propertySymbol = checker.getSymbolAtLocation(property.name);
+        if (!propertySymbol) {
+            throw new UnknownDaggerError(`could not get property symbol: ${property.name.getText()}`, {});
+        }
+        this.symbol = propertySymbol;
+        this.decorator = ts.getDecorators(property)?.find((d) => {
+            if (ts.isCallExpression(d.expression)) {
+                return (d.expression.expression.getText() === PROPERTY_DECORATOR ||
+                    d.expression.expression.getText() === DEPRECATED_PROPERTY_DECORATOR);
+            }
+            return false;
+        });
+        // Preload values to optimize introspection
+        this._name = this.loadName();
+        this._description = this.loadDescription();
+        this._alias = this.loadAlias();
+        this._type = this.loadType();
+        this._isExposed = this.loadIsExposed();
+    }
+    get name() {
+        return this._name;
+    }
+    get description() {
+        return this._description;
+    }
+    /**
+     * Return the alias of the property if it has one.
+     */
+    get alias() {
+        return this._alias;
+    }
+    /**
+     * Return the type of the property in a Dagger TypeDef format.
+     */
+    get type() {
+        return this._type;
+    }
+    get isExposed() {
+        return this._isExposed;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            description: this.description,
+            alias: this.alias,
+            type: this.type,
+            isExposed: this.isExposed,
+        };
+    }
+    loadName() {
+        return this.symbol.getName();
+    }
+    loadDescription() {
+        return ts.displayPartsToString(this.symbol.getDocumentationComment(this.checker));
+    }
+    loadAlias() {
+        if (!this.decorator) {
+            return undefined;
+        }
+        const expression = this.decorator.expression;
+        const aliasArg = expression.arguments[0];
+        if (!aliasArg) {
+            return undefined;
+        }
+        return JSON.parse(aliasArg.getText().replace(/'/g, '"'));
+    }
+    loadType() {
+        if (!this.symbol.valueDeclaration) {
+            throw new UnknownDaggerError("could not find symbol value declaration", {});
+        }
+        const type = this.checker.getTypeOfSymbolAtLocation(this.symbol, this.symbol.valueDeclaration);
+        return typeToTypedef(this.checker, type);
+    }
+    loadIsExposed() {
+        return this.decorator !== undefined;
+    }
+}

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

@@ -0,0 +1,8 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { TypeDef } from "../typeDefs.js";
+/**
+ * Convert a type into a Dagger Typedef using dynamic typing.
+ */
+export declare function typeToTypedef(checker: ts.TypeChecker, type: ts.Type): TypeDef<TypeDefKind>;
+//# sourceMappingURL=typeToTypedef.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeToTypedef.d.ts","sourceRoot":"","sources":["../../../../introspector/scanner/abtractions/typeToTypedef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAA;AAGxC;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,EAAE,EAAE,CAAC,IAAI,GACZ,OAAO,CAAC,WAAW,CAAC,CAiGtB"}

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

@@ -0,0 +1,85 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../../api/client.gen.js";
+import { isEnumDecorated } from "./enum.js";
+/**
+ * Convert a type into a Dagger Typedef using dynamic typing.
+ */
+export function typeToTypedef(checker, type) {
+    const symbol = type.getSymbol();
+    const symbolName = symbol?.name;
+    const symbolDeclaration = symbol?.valueDeclaration;
+    if (symbolName === "Promise") {
+        const typeArgs = checker.getTypeArguments(type);
+        if (typeArgs.length > 0) {
+            return typeToTypedef(checker, typeArgs[0]);
+        }
+    }
+    if (symbolName === "Array") {
+        const typeArgs = checker.getTypeArguments(type);
+        if (typeArgs.length === 0) {
+            throw new Error("Generic array not supported");
+        }
+        return {
+            kind: TypeDefKind.ListKind,
+            typeDef: typeToTypedef(checker, typeArgs[0]),
+        };
+    }
+    const strType = checker.typeToString(type);
+    switch (strType) {
+        case "string":
+            return { kind: TypeDefKind.StringKind };
+        case "number":
+            return { kind: TypeDefKind.IntegerKind };
+        case "boolean":
+            return { kind: TypeDefKind.BooleanKind };
+        case "void":
+            return { kind: TypeDefKind.VoidKind };
+        // Intercept primitive types and throw error in this case
+        case "String":
+            throw new Error("Use of primitive String type detected, did you mean string?");
+        case "Number":
+            throw new Error("Use of primitive Number type detected, did you mean number?");
+        case "Boolean":
+            throw new Error("Use of primitive Boolean type detected, did you mean boolean?");
+        default:
+            if (symbolName &&
+                type.isClassOrInterface() &&
+                symbolDeclaration &&
+                ts.isClassDeclaration(symbolDeclaration)) {
+                if (isEnumDecorated(symbolDeclaration)) {
+                    return {
+                        kind: TypeDefKind.EnumKind,
+                        name: symbolName,
+                    };
+                }
+                return {
+                    kind: TypeDefKind.ObjectKind,
+                    name: symbolName,
+                };
+            }
+            if (symbol?.getFlags() !== undefined &&
+                (symbol.getFlags() & ts.SymbolFlags.Enum) !== 0) {
+                return {
+                    kind: TypeDefKind.EnumKind,
+                    name: strType,
+                };
+            }
+            // If it's a union, then it's a scalar type
+            if (type.isUnionOrIntersection()) {
+                return {
+                    kind: TypeDefKind.ScalarKind,
+                    name: strType,
+                };
+            }
+            // If we cannot resolve the symbol, we check for the alias symbol.
+            // This should mostly lead to a failure since external types are not supported by
+            // dagger yet.
+            if (type.aliasSymbol && type.aliasSymbol.flags & ts.TypeFlags.Object) {
+                return {
+                    kind: TypeDefKind.ObjectKind,
+                    name: type.aliasSymbol.escapedName.toString(),
+                };
+            }
+            throw new Error(`Unsupported type ${strType}`);
+    }
+}

package/dist/introspector/scanner/scan.d.ts

@@ -0,0 +1,14 @@
+import { DaggerModule } from "./abtractions/module.js";
+/**
+ * Scan the list of TypeScript File using the TypeScript compiler API.
+ *
+ * This function introspect files and returns metadata of their class and
+ * functions that should be exposed to the Dagger API.
+ *
+ * WARNING(28/11/23): This does NOT include arrow style function.
+ *
+ * @param files List of TypeScript files to introspect.
+ * @param moduleName The name of the module to introspect.
+ */
+export declare function scan(files: string[], moduleName?: string): DaggerModule;
+//# sourceMappingURL=scan.d.ts.map

package/dist/introspector/scanner/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/scan.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAEtD;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,UAAU,SAAK,GAAG,YAAY,CAenE"}

package/dist/introspector/scanner/scan.js

@@ -0,0 +1,26 @@
+import ts from "typescript";
+import { DaggerModule } from "./abtractions/module.js";
+/**
+ * Scan the list of TypeScript File using the TypeScript compiler API.
+ *
+ * This function introspect files and returns metadata of their class and
+ * functions that should be exposed to the Dagger API.
+ *
+ * WARNING(28/11/23): This does NOT include arrow style function.
+ *
+ * @param files List of TypeScript files to introspect.
+ * @param moduleName The name of the module to introspect.
+ */
+export function scan(files, moduleName = "") {
+    if (files.length === 0) {
+        throw new Error("no files to introspect found");
+    }
+    // Interpret the given typescript source files.
+    const program = ts.createProgram(files, { experimentalDecorators: true });
+    const checker = program.getTypeChecker();
+    const module = new DaggerModule(checker, moduleName, program.getSourceFiles());
+    if (Object.keys(module.objects).length === 0) {
+        throw new Error("no objects found in the module");
+    }
+    return module;
+}

package/dist/introspector/scanner/typeDefs.d.ts

@@ -0,0 +1,45 @@
+import { TypeDefKind } from "../../api/client.gen.js";
+/**
+ * Base type of argument, field or return type.
+ */
+export type BaseTypeDef = {
+    kind: TypeDefKind;
+};
+/**
+ * Extends the base type def if it's an object to add its name.
+ */
+export type ObjectTypeDef = BaseTypeDef & {
+    kind: TypeDefKind.ObjectKind;
+    name: string;
+};
+/**
+ * Extends the base type def if it's an enum to add its name.
+ */
+export type EnumTypeDef = BaseTypeDef & {
+    kind: TypeDefKind.EnumKind;
+    name: string;
+};
+/**
+ * Extends the base typedef if it's a scalar to add its name and real type.
+ */
+export type ScalarTypeDef = BaseTypeDef & {
+    kind: TypeDefKind.ScalarKind;
+    name: string;
+};
+/**
+ * Extends the base if it's a list to add its subtype.
+ */
+export type ListTypeDef = BaseTypeDef & {
+    kind: TypeDefKind.ListKind;
+    typeDef: TypeDef<TypeDefKind>;
+};
+/**
+ * A generic TypeDef that will dynamically add necessary properties
+ * depending on its type.
+ *
+ * If it's a type of kind scalar, it transforms the BaseTypeDef into a ScalarTypeDef.
+ * If it's type of kind object, it transforms the BaseTypeDef into an ObjectTypeDef.
+ * If it's a type of kind list, it transforms the BaseTypeDef into a ListTypeDef.
+ */
+export type TypeDef<T extends BaseTypeDef["kind"]> = T extends TypeDefKind.ScalarKind ? ScalarTypeDef : T extends TypeDefKind.ObjectKind ? ObjectTypeDef : T extends TypeDefKind.ListKind ? ListTypeDef : T extends TypeDefKind.EnumKind ? EnumTypeDef : BaseTypeDef;
+//# sourceMappingURL=typeDefs.d.ts.map

package/dist/introspector/scanner/typeDefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeDefs.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/typeDefs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAErD;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,WAAW,CAAA;CAClB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG;IACxC,IAAI,EAAE,WAAW,CAAC,UAAU,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG;IACtC,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG;IACxC,IAAI,EAAE,WAAW,CAAC,UAAU,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG;IACtC,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAA;IAC1B,OAAO,EAAE,OAAO,CAAC,WAAW,CAAC,CAAA;CAC9B,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,WAAW,CAAC,MAAM,CAAC,IAC/C,CAAC,SAAS,WAAW,CAAC,UAAU,GAC5B,aAAa,GACb,CAAC,SAAS,WAAW,CAAC,UAAU,GAC9B,aAAa,GACb,CAAC,SAAS,WAAW,CAAC,QAAQ,GAC5B,WAAW,GACX,CAAC,SAAS,WAAW,CAAC,QAAQ,GAC5B,WAAW,GACX,WAAW,CAAA"}

package/dist/introspector/scanner/typeDefs.js

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

package/dist/introspector/scanner/utils.d.ts

@@ -0,0 +1,22 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../api/client.gen.js";
+import { TypeDef } from "./typeDefs.js";
+/**
+ * Return true if the given class declaration has the decorator @obj() on
+ * top of its declaration.
+ * @param object
+ */
+export declare function isObject(object: ts.ClassDeclaration): boolean;
+export declare function toPascalCase(input: string): string;
+/**
+ * Return true if the given method has the decorator @func() on top
+ * of its declaration.
+ *
+ * @param method The method to check
+ */
+export declare function isFunction(method: ts.MethodDeclaration): boolean;
+/**
+ * Convert a type into a Dagger Typedef using dynamic typing.
+ */
+export declare function typeToTypedef(checker: ts.TypeChecker, type: ts.Type): TypeDef<TypeDefKind>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/introspector/scanner/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../introspector/scanner/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEvC;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,gBAAgB,GAAG,OAAO,CAU7D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAoBlD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,iBAAiB,GAAG,OAAO,CAUhE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,IAAI,EAAE,EAAE,CAAC,IAAI,GACZ,OAAO,CAAC,WAAW,CAAC,CA8DtB"}

package/dist/introspector/scanner/utils.js

@@ -0,0 +1,101 @@
+import ts from "typescript";
+import { TypeDefKind } from "../../api/client.gen.js";
+/**
+ * Return true if the given class declaration has the decorator @obj() on
+ * top of its declaration.
+ * @param object
+ */
+export function isObject(object) {
+    return (ts.getDecorators(object)?.find((d) => {
+        if (ts.isCallExpression(d.expression)) {
+            return d.expression.expression.getText() === "object";
+        }
+        return false;
+    }) !== undefined);
+}
+export function toPascalCase(input) {
+    const words = input
+        .replace(/[^a-zA-Z0-9]/g, " ") // Replace non-alphanumeric characters with spaces
+        .split(/\s+/)
+        .filter((word) => word.length > 0);
+    if (words.length === 0) {
+        return ""; // No valid words found
+    }
+    // It's an edge case when moduleName is already in PascalCase or camelCase
+    if (words.length === 1) {
+        return words[0].charAt(0).toUpperCase() + words[0].slice(1);
+    }
+    const pascalCase = words
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join("");
+    return pascalCase;
+}
+/**
+ * Return true if the given method has the decorator @func() on top
+ * of its declaration.
+ *
+ * @param method The method to check
+ */
+export function isFunction(method) {
+    return (ts.getDecorators(method)?.find((d) => {
+        if (ts.isCallExpression(d.expression)) {
+            return d.expression.expression.getText() === "func";
+        }
+        return false;
+    }) !== undefined);
+}
+/**
+ * Convert a type into a Dagger Typedef using dynamic typing.
+ */
+export function typeToTypedef(checker, type) {
+    if (type.symbol?.name === "Promise") {
+        const typeArgs = checker.getTypeArguments(type);
+        if (typeArgs.length > 0) {
+            return typeToTypedef(checker, typeArgs[0]);
+        }
+    }
+    if (type.symbol?.name === "Array") {
+        const typeArgs = checker.getTypeArguments(type);
+        if (typeArgs.length === 0) {
+            throw new Error("Generic array not supported");
+        }
+        return {
+            kind: TypeDefKind.ListKind,
+            typeDef: typeToTypedef(checker, typeArgs[0]),
+        };
+    }
+    const strType = checker.typeToString(type);
+    switch (strType) {
+        case "string":
+            return { kind: TypeDefKind.StringKind };
+        case "number":
+            return { kind: TypeDefKind.IntegerKind };
+        case "boolean":
+            return { kind: TypeDefKind.BooleanKind };
+        case "void":
+            return { kind: TypeDefKind.VoidKind };
+        // Intercept primitive types and throw error in this case
+        case "String":
+            throw new Error("Use of primitive String type detected, did you mean string?");
+        case "Number":
+            throw new Error("Use of primitive Number type detected, did you mean number?");
+        case "Boolean":
+            throw new Error("Use of primitive Boolean type detected, did you mean boolean?");
+        default:
+            // If it's a class or interface, it's an object
+            if (type.symbol?.name && type.isClassOrInterface()) {
+                return {
+                    kind: TypeDefKind.ObjectKind,
+                    name: strType,
+                };
+            }
+            // If it's a union, then it's a scalar type
+            if (type.isUnionOrIntersection()) {
+                return {
+                    kind: TypeDefKind.ScalarKind,
+                    name: strType,
+                };
+            }
+            throw new Error(`Unsupported type ${strType}`);
+    }
+}

package/dist/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/introspector/utils/files.d.ts.map

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

package/dist/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 [`${dir}/${file}`];
+        }
+        return [];
+    }));
+    return res.reduce((p, c) => [...c, ...p], []);
+}

package/dist/provisioning/bin.d.ts

@@ -0,0 +1,77 @@
+import { ResultPromise } from "execa";
+import { GraphQLClient } from "graphql-request";
+import { ConnectOpts, EngineConn } from "./engineconn.js";
+export type ExecaChildProcess = ResultPromise<{
+    stdio: "pipe";
+    reject: true;
+    cleanup: true;
+}>;
+/**
+ * Bin runs an engine session from a specified binary
+ */
+export declare class Bin implements EngineConn {
+    private _subProcess?;
+    private binPath?;
+    private cliVersion?;
+    private readonly cacheDir;
+    private readonly DAGGER_CLI_BIN_PREFIX;
+    constructor(binPath?: string, cliVersion?: string);
+    Addr(): string;
+    get subProcess(): ExecaChildProcess | undefined;
+    Connect(opts: ConnectOpts): Promise<GraphQLClient>;
+    private downloadCLI;
+    /**
+     * Traverse up the directory tree to find the package.json file and return the
+     * SDK version.
+     * @returns the SDK version or "n/a" if the version cannot be found.
+     */
+    private getSDKVersion;
+    /**
+     * runEngineSession execute the engine binary and set up a GraphQL client that
+     * target this engine.
+     */
+    private runEngineSession;
+    private readConnectParams;
+    Close(): Promise<void>;
+    /**
+     * createCacheDir will create a cache directory on user
+     * host to store dagger binary.
+     *
+     * If set, it will use envPaths to determine system's cache directory,
+     * if not, it will use `$HOME/.cache` as base path.
+     * Nothing happens if the directory already exists.
+     */
+    private createCacheDir;
+    /**
+     * buildBinPath create a path to output dagger cli binary.
+     *
+     * It will store it in the cache directory with a name composed
+     * of the base engine session as constant and the engine identifier.
+     */
+    private buildBinPath;
+    /**
+     * buildExePath create a path to output dagger cli binary.
+     */
+    private buildOsExePath;
+    /**
+     * normalizedArch returns the architecture name used by the rest of our SDKs.
+     */
+    private normalizedArch;
+    /**
+     * normalizedOS returns the os name used by the rest of our SDKs.
+     */
+    private normalizedOS;
+    private cliArchiveName;
+    private cliArchiveURL;
+    private cliChecksumURL;
+    private checksumMap;
+    private expectedChecksum;
+    private extractArchive;
+    /**
+     * Generate a unix timestamp in nanosecond
+     */
+    private getRandomId;
+}
+export declare function _overrideCLIURL(url: string): void;
+export declare function _overrideCLIChecksumsURL(url: string): void;
+//# sourceMappingURL=bin.d.ts.map

package/dist/provisioning/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../provisioning/bin.ts"],"names":[],"mappings":"AAGA,OAAO,EAAS,aAAa,EAAE,MAAM,OAAO,CAAA;AAE5C,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAgB/C,OAAO,EAAE,WAAW,EAAE,UAAU,EAAiB,MAAM,iBAAiB,CAAA;AAMxE,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC;IAC5C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,IAAI,CAAA;IACZ,OAAO,EAAE,IAAI,CAAA;CACd,CAAC,CAAA;AAEF;;GAEG;AACH,qBAAa,GAAI,YAAW,UAAU;IACpC,OAAO,CAAC,WAAW,CAAC,CAAmB;IAEvC,OAAO,CAAC,OAAO,CAAC,CAAQ;IACxB,OAAO,CAAC,UAAU,CAAC,CAAQ;IAE3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAGxB;IAED,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAW;gBAErC,OAAO,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;IAKjD,IAAI,IAAI,MAAM;IAId,IAAI,UAAU,IAAI,iBAAiB,GAAG,SAAS,CAE9C;IAEK,OAAO,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,aAAa,CAAC;YAgB1C,WAAW;IAkEzB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAqBrB;;;OAGG;YACW,gBAAgB;YA2EhB,iBAAiB;IA6BzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IAItB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,cAAc;IAWtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAStB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,cAAc;YAOR,WAAW;YAkBX,gBAAgB;YAWhB,cAAc;IA4C5B;;OAEG;IACH,OAAO,CAAC,WAAW;CAGpB;AAGD,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEjD;AAGD,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAE1D"}