@dagger.io/dagger 0.0.1-0

package/dist/src/module/entrypoint/load.js

@@ -0,0 +1,237 @@
+import { dag, TypeDefKind } from "../../api/client.gen.js";
+import { DaggerEnum, DaggerObject, DaggerTypeObject, DaggerEnumClass, } from "../introspector/dagger_module/index.js";
+/**
+ * Import all given typescript files so that trigger their decorators
+ * and register their class and functions inside the Registry.
+ *
+ * @param files List of files to load.
+ */
+export async function load(files) {
+    return await Promise.all(files.map(async (f) => await import(f)));
+}
+/**
+ * Return the object invoked from the module.
+ *
+ * @param module The module to load the object from.
+ * @param parentName The name of the parent object.
+ */
+export function loadInvokedObject(module, parentName) {
+    return module.objects[parentName];
+}
+export function loadInvokedMethod(object, ctx) {
+    if (ctx.fnName === "") {
+        return object._constructor;
+    }
+    return object.methods[ctx.fnName];
+}
+/**
+ * Load the values of the arguments from the context.
+ *
+ * @param method Method to load the arguments from.
+ * @param ctx The context of the invocation.
+ */
+export async function loadArgs(executor, method, ctx) {
+    const args = {};
+    // Load arguments
+    for (const argName of method.getArgsOrder()) {
+        const argument = method.arguments[argName];
+        if (!argument) {
+            throw new Error(`could not find argument ${argName}`);
+        }
+        if (!argument.type) {
+            throw new Error(`could not find type for argument ${argName}`);
+        }
+        const loadedArg = await loadValue(executor, 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;
+            }
+            continue;
+        }
+        // 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 state of the parent object from the context.
+ *
+ * @param object The object to load the parent state from.
+ * @param ctx The context of the invocation.
+ */
+export async function loadParentState(executor, 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}`);
+        }
+        if (!property.type) {
+            throw new Error(`could not find type for parent property ${key}`);
+        }
+        parentState[property.name] = await loadValue(executor, value, property.type);
+    }
+    return parentState;
+}
+/**
+ * This function load the value as a Dagger type.
+ *
+ * Note: The JSON.parse() is required to remove extra quotes
+ */
+export async function loadValue(executor, 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 loadValue(executor, v, type.typeDef)));
+        case TypeDefKind.ObjectKind: {
+            const objectType = type.name;
+            // Workaround to call get any object that has an id
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            if (dag[`load${objectType}FromID`]) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                return dag[`load${objectType}FromID`](value);
+            }
+            return executor.buildClass(objectType, value);
+        }
+        case TypeDefKind.InterfaceKind: {
+            const interfaceType = type.name;
+            return executor.buildInterface(interfaceType, value);
+        }
+        case TypeDefKind.EnumKind: {
+            const enumType = type.name;
+            return executor.buildEnum(enumType, value);
+        }
+        // Cannot use `,` to specify multiple matching case so instead we use fallthrough.
+        case TypeDefKind.StringKind:
+        case TypeDefKind.IntegerKind:
+        case TypeDefKind.BooleanKind:
+        case TypeDefKind.FloatKind:
+        case TypeDefKind.VoidKind:
+        case TypeDefKind.ScalarKind:
+            return value;
+        default:
+            throw new Error(`unsupported type ${type.kind}`);
+    }
+}
+/**
+ * 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 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 function loadObjectReturnType(module, object, method) {
+    const retType = method.returnType;
+    if (!retType) {
+        throw new Error(`could not find return type for ${method.name}`);
+    }
+    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;
+            }
+            if (listType.kind === TypeDefKind.EnumKind) {
+                return module.enums[listType.name];
+            }
+            return module.objects[listType.name];
+        }
+        case TypeDefKind.ObjectKind:
+            return module.objects[retType.name];
+        case TypeDefKind.EnumKind:
+            return module.enums[retType.name];
+        default:
+            return object;
+    }
+}
+export async function loadResult(result, module, object) {
+    // Handle IDable objects
+    if (result && typeof result?.id === "function") {
+        return await result.id();
+    }
+    // Handle arrays
+    if (Array.isArray(result)) {
+        result = await Promise.all(result.map(async (r) => await loadResult(r, module, object)));
+        return result;
+    }
+    // Handle objects
+    if (typeof result === "object" &&
+        (object instanceof DaggerObject || object instanceof DaggerTypeObject)) {
+        const state = {};
+        for (const [key, value] of Object.entries(result)) {
+            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) {
+                throw new Error(`could not find type for result property ${key}`);
+            }
+            let referencedObject = undefined;
+            // Handle nested objects
+            if (property.type.kind === TypeDefKind.ObjectKind) {
+                referencedObject =
+                    module.objects[property.type.name];
+            }
+            // Handle list of nested objects
+            if (property.type.kind === TypeDefKind.ListKind) {
+                let _property = property.type;
+                // Loop until we find the original type.
+                while (_property.kind === TypeDefKind.ListKind) {
+                    _property = _property.typeDef;
+                }
+                // If the original type is an object, we use it as the referenced object.
+                if (_property.kind === TypeDefKind.ObjectKind) {
+                    referencedObject =
+                        module.objects[_property.name];
+                }
+                // If the original type is a enum, we use it as the referenced object.
+                if (_property.kind === TypeDefKind.EnumKind) {
+                    referencedObject =
+                        module.enums[_property.name];
+                }
+            }
+            // Handle enums
+            if (property.type.kind === TypeDefKind.EnumKind) {
+                referencedObject =
+                    module.enums[property.type.name];
+            }
+            // If there's no referenced object, we use the current object.
+            if (!referencedObject) {
+                referencedObject = object;
+            }
+            state[property.alias ?? property.name] = await loadResult(value, module, referencedObject);
+        }
+        return state;
+    }
+    // If it's an enum, we need to resolve the enum member name instead of the value.
+    // A enum value A = "a" will be returned as "a" by the function so we need to
+    // transform it back to "A" to be sent as result to the engine.
+    if (object instanceof DaggerEnum || object instanceof DaggerEnumClass) {
+        const enumMember = Object.entries(object.values).find(([, member]) => member.value === result);
+        // If the enum member is not found, we return the result as is and let the engine handle it.
+        if (!enumMember) {
+            return result;
+        }
+        return enumMember[0];
+    }
+    // Handle primitive types
+    return result;
+}

package/dist/src/module/entrypoint/register.d.ts

@@ -0,0 +1,33 @@
+import { Function_, ModuleID, TypeDef } from "../../api/client.gen.js";
+import { DaggerArguments as Arguments, DaggerConstructor as Constructor, DaggerFunction as Method, DaggerModule, DaggerArgument } from "../introspector/dagger_module/index.js";
+import { DaggerInterfaceFunction } from "../introspector/dagger_module/interfaceFunction.js";
+export declare class Register {
+    private readonly module;
+    constructor(module: DaggerModule);
+    /**
+     * Register the module in the engine and returns its ID
+     */
+    run(): Promise<ModuleID>;
+    /**
+     * Bind a constructor to the given object.
+     */
+    addConstructor(constructor: Constructor, owner: TypeDef): Function_;
+    /**
+     * Create a function in the Dagger API.
+     */
+    addFunction(fct: Method | DaggerInterfaceFunction): Function_;
+    /**
+     * Register all arguments in the function.
+     */
+    addArg(args: Arguments): (fct: Function_) => Function_;
+    /**
+     * Extract the default value from the argument.
+     * - If the argument isn't a primitive type, we can't resolve it so we make it optional and let the runtime
+     *   resolve it on execution.
+     * - If the argument is a primitive type but not an enum, we resolve it directly.
+     * - If the argument is an enum but not registered in the module, it must be a core enum so we keep the value as is.
+     * - If the argument is an enum registered in the module, we resolve the value to the member name.
+     */
+    getDefaultValueFromArg(arg: DaggerArgument): unknown | undefined;
+}
+//# sourceMappingURL=register.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/module/entrypoint/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,QAAQ,EACR,OAAO,EAQR,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,eAAe,IAAI,SAAS,EAC5B,iBAAiB,IAAI,WAAW,EAChC,cAAc,IAAI,MAAM,EACxB,YAAY,EAEZ,cAAc,EACf,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,oDAAoD,CAAA;AAU5F,qBAAa,QAAQ;IACP,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAEjD;;OAEG;IACG,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC;IAyF9B;;OAEG;IACH,cAAc,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,GAAG,SAAS;IAInE;;OAEG;IACH,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,uBAAuB,GAAG,SAAS;IAoC7D;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,CAAC,GAAG,EAAE,SAAS,KAAK,SAAS;IAmDtD;;;;;;;OAOG;IACH,sBAAsB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,GAAG,SAAS;CA4BjE"}

package/dist/src/module/entrypoint/register.js

@@ -0,0 +1,227 @@
+import { dag, TypeDefKind, FunctionCachePolicy, } from "../../api/client.gen.js";
+export class Register {
+    module;
+    constructor(module) {
+        this.module = module;
+    }
+    /**
+     * Register the module in the engine and returns its ID
+     */
+    async run() {
+        // Get a new module that we will fill in with all the types
+        let mod = dag.module_();
+        // Add module description if any.
+        if (this.module.description) {
+            mod = mod.withDescription(this.module.description);
+        }
+        // For each class scanned, register its type, method and properties in the module.
+        Object.values(this.module.objects).forEach((object) => {
+            const objectOpts = {
+                description: object.description,
+                sourceMap: addSourceMap(object),
+                deprecated: object.deprecated,
+            };
+            // Register the class Typedef object in Dagger
+            let typeDef = dag.typeDef().withObject(object.name, objectOpts);
+            // Register all functions (methods) to this object
+            Object.values(object.methods).forEach((method) => {
+                typeDef = typeDef.withFunction(this.addFunction(method));
+            });
+            // Register all fields that belong to this object
+            Object.values(object.properties).forEach((field) => {
+                if (field.isExposed) {
+                    const fieldOpts = {
+                        description: field.description,
+                        sourceMap: addSourceMap(field),
+                        deprecated: field.deprecated,
+                    };
+                    typeDef = typeDef.withField(field.alias ?? field.name, addTypeDef(field.type), fieldOpts);
+                }
+            });
+            if (object._constructor) {
+                typeDef = typeDef.withConstructor(this.addConstructor(object._constructor, typeDef));
+            }
+            // Add it to the module object
+            mod = mod.withObject(typeDef);
+        });
+        // Register all enums defined by this modules
+        Object.values(this.module.enums).forEach((enum_) => {
+            let typeDef = dag.typeDef().withEnum(enum_.name, {
+                description: enum_.description,
+                sourceMap: addSourceMap(enum_),
+            });
+            Object.values(enum_.values).forEach((value) => {
+                const memberOpts = {
+                    value: value.value,
+                    description: value.description,
+                    sourceMap: addSourceMap(value),
+                    deprecated: value.deprecated,
+                };
+                typeDef = typeDef.withEnumMember(value.name, memberOpts);
+            });
+            mod = mod.withEnum(typeDef);
+        });
+        // Register all interfaces defined by this module
+        Object.values(this.module.interfaces).forEach((interface_) => {
+            let typeDef = dag.typeDef().withInterface(interface_.name, {
+                description: interface_.description,
+            });
+            Object.values(interface_.functions).forEach((function_) => {
+                typeDef = typeDef.withFunction(this.addFunction(function_));
+            });
+            mod = mod.withInterface(typeDef);
+        });
+        return await mod.id();
+    }
+    /**
+     * Bind a constructor to the given object.
+     */
+    addConstructor(constructor, owner) {
+        return dag.function_("", owner).with(this.addArg(constructor.arguments));
+    }
+    /**
+     * Create a function in the Dagger API.
+     */
+    addFunction(fct) {
+        let fnDef = dag
+            .function_(fct.alias ?? fct.name, addTypeDef(fct.returnType))
+            .withDescription(fct.description)
+            .withSourceMap(addSourceMap(fct))
+            .with(this.addArg(fct.arguments));
+        switch (fct.cache) {
+            case "never": {
+                fnDef = fnDef.withCachePolicy(FunctionCachePolicy.Never);
+                break;
+            }
+            case "session": {
+                fnDef = fnDef.withCachePolicy(FunctionCachePolicy.PerSession);
+                break;
+            }
+            case "": {
+                break;
+            }
+            default: {
+                const opts = { timeToLive: fct.cache };
+                fnDef = fnDef.withCachePolicy(FunctionCachePolicy.Default, opts);
+            }
+        }
+        if (fct.deprecated !== undefined) {
+            fnDef = fnDef.withDeprecated({ reason: fct.deprecated });
+        }
+        if (fct.isCheck) {
+            fnDef = fnDef.withCheck();
+        }
+        return fnDef;
+    }
+    /**
+     * Register all arguments in the function.
+     */
+    addArg(args) {
+        return (fct) => {
+            Object.values(args).forEach((arg) => {
+                const opts = {
+                    description: arg.description,
+                    sourceMap: addSourceMap(arg),
+                    deprecated: arg.deprecated,
+                };
+                let typeDef = addTypeDef(arg.type);
+                if (arg.isOptional) {
+                    typeDef = typeDef.withOptional(true);
+                }
+                // Check if both values are used, return an error if so.
+                if ([arg.defaultValue, arg.defaultPath].filter((v) => v).length > 1) {
+                    throw new Error("cannot set multiple defaults");
+                }
+                // We do not set the default value if it's not a primitive type, we let TypeScript
+                // resolve the default value during the runtime instead.
+                // If it has a default value but is not primitive, we set the value as optional
+                // to workaround the fact that the API isn't aware of the default value and will
+                // expect it to be set as required input.
+                if (arg.defaultValue !== undefined) {
+                    const defaultValue = this.getDefaultValueFromArg(arg);
+                    if (defaultValue === undefined) {
+                        typeDef = typeDef.withOptional(true);
+                    }
+                    else {
+                        opts.defaultValue = JSON.stringify(defaultValue);
+                    }
+                }
+                // If the argument is a contextual argument, it becomes optional.
+                if (arg.defaultPath) {
+                    opts.defaultPath = arg.defaultPath;
+                }
+                if (arg.ignore) {
+                    opts.ignore = arg.ignore;
+                }
+                fct = fct.withArg(arg.name, typeDef, opts);
+            });
+            return fct;
+        };
+    }
+    /**
+     * Extract the default value from the argument.
+     * - If the argument isn't a primitive type, we can't resolve it so we make it optional and let the runtime
+     *   resolve it on execution.
+     * - If the argument is a primitive type but not an enum, we resolve it directly.
+     * - If the argument is an enum but not registered in the module, it must be a core enum so we keep the value as is.
+     * - If the argument is an enum registered in the module, we resolve the value to the member name.
+     */
+    getDefaultValueFromArg(arg) {
+        if (!isPrimitiveType(arg.type)) {
+            return undefined;
+        }
+        if (arg.type.kind !== TypeDefKind.EnumKind) {
+            return arg.defaultValue;
+        }
+        const enumObj = this.module.enums[arg.type.name];
+        if (!enumObj) {
+            // If the enum isn't found in the module, it may be a core enum so we keep the value
+            return arg.defaultValue;
+        }
+        // If it's a known enum, we need to resolve set the name of the member as default value instead of the actual value
+        const enumMember = Object.entries(enumObj.values).find(([, member]) => member.value === arg.defaultValue);
+        if (!enumMember) {
+            throw new Error(`could not resolve default value '${arg.defaultValue}' for enum ${arg.type.name}`);
+        }
+        return enumMember[0];
+    }
+}
+/**
+ * Wrapper around TypeDef to return the right Dagger TypesDef with its options.
+ *
+ * This function only convert the Typedef into correct dagger call
+ * but, it's up to function above with more context to add documentation,
+ * define if it's an optional value or its default's.
+ *
+ * We cannot do it there because the Typedef can come from any source:
+ * a field, a param, a return value etc...
+ */
+function addTypeDef(type) {
+    switch (type.kind) {
+        case TypeDefKind.ScalarKind:
+            return dag.typeDef().withScalar(type.name);
+        case TypeDefKind.ObjectKind:
+            return dag.typeDef().withObject(type.name);
+        case TypeDefKind.ListKind:
+            return dag.typeDef().withListOf(addTypeDef(type.typeDef));
+        case TypeDefKind.VoidKind:
+            return dag.typeDef().withKind(type.kind).withOptional(true);
+        case TypeDefKind.EnumKind:
+            return dag.typeDef().withEnum(type.name);
+        case TypeDefKind.InterfaceKind:
+            return dag.typeDef().withInterface(type.name);
+        default:
+            return dag.typeDef().withKind(type.kind);
+    }
+}
+function addSourceMap(object) {
+    const { filepath, line, column } = object.getLocation();
+    return dag.sourceMap(filepath, line, column);
+}
+function isPrimitiveType(type) {
+    return (type.kind === TypeDefKind.BooleanKind ||
+        type.kind === TypeDefKind.IntegerKind ||
+        type.kind === TypeDefKind.StringKind ||
+        type.kind === TypeDefKind.FloatKind ||
+        type.kind === TypeDefKind.EnumKind);
+}

package/dist/src/module/executor.d.ts

@@ -0,0 +1,28 @@
+import Module from "node:module";
+import { DaggerModule } from "./introspector/dagger_module/index.js";
+export type State = {
+    [property: string]: any;
+};
+export type Args = Record<string, unknown>;
+export declare class Executor {
+    readonly modules: Module[];
+    private readonly daggerModule;
+    constructor(modules: Module[], daggerModule: DaggerModule);
+    private getExportedObject;
+    buildClass(object: string, state: State): any;
+    /**
+     * Transform a Dagger interface identifier into an implementation of this
+     * interface serves as module call binding to reach the true implementation.
+     */
+    buildInterface(iface: string, id: string): any;
+    /**
+     * Transfer a Dagger enum member name into its implemented value.
+     * An enum value A = "a" will be received as "A" by the entrypoint
+     * but should be transformed into "a" to be sent to the function.
+     * If the enum isn't found in the module, it may be a core enum so we keep the value
+     * as is.
+     */
+    buildEnum(enumName: string, value: string): any;
+    getResult(object: string, method: string, state: State, inputs: Args): Promise<any>;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/src/module/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/module/executor.ts"],"names":[],"mappings":"AAEA,OAAO,MAAM,MAAM,aAAa,CAAA;AAMhC,OAAO,EAAE,YAAY,EAAE,MAAM,uCAAuC,CAAA;AAIpE,MAAM,MAAM,KAAK,GAAG;IAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAA;AAE/C,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAE1C,qBAAa,QAAQ;aAED,OAAO,EAAE,MAAM,EAAE;IACjC,OAAO,CAAC,QAAQ,CAAC,YAAY;gBADb,OAAO,EAAE,MAAM,EAAE,EAChB,YAAY,EAAE,YAAY;IAG7C,OAAO,CAAC,iBAAiB;IAUzB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,GAAG;IAqB7C;;;OAGG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,GAAG;IAiB9C;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG;IAazC,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,IAAI,GACX,OAAO,CAAC,GAAG,CAAC;CAchB"}