@dagger.io/dagger 0.9.3 → 0.9.5

package/dist/connectOpts.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { Writable } from "node:stream";
+/**
+ * ConnectOpts defines option used to connect to an engine.
+ */
+export interface ConnectOpts {
+    /**
+     * Use to overwrite Dagger workdir
+     * @defaultValue process.cwd()
+     */
+    Workdir?: string;
+    /**
+       * Enable logs output
+       * @example
+       * LogOutput
+       * ```ts
+       * connect(async (client: Client) => {
+      const source = await client.host().workdir().id()
+      ...
+      }, {LogOutput: process.stdout})
+       ```
+       */
+    LogOutput?: Writable;
+}
+//# sourceMappingURL=connectOpts.d.ts.map

package/dist/connectOpts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectOpts.d.ts","sourceRoot":"","sources":["../connectOpts.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB;;;;;;;;;;SAUK;IACL,SAAS,CAAC,EAAE,QAAQ,CAAA;CACrB"}

package/dist/connectOpts.js

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

package/dist/context/builder.d.ts

@@ -0,0 +1,9 @@
+import { ConnectOpts } from "../connectOpts.js";
+import { Context } from "./context.js";
+/**
+ * @hidden
+ *
+ * Initialize a default client context from environment.
+ */
+export declare function initDefaultContext(cfg?: ConnectOpts): Promise<Context>;
+//# sourceMappingURL=builder.d.ts.map

package/dist/context/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../context/builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAG/C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,GAAE,WAAgB,GACpB,OAAO,CAAC,OAAO,CAAC,CAiClB"}

package/dist/context/builder.js

@@ -0,0 +1,34 @@
+import { createGQLClient } from "../graphql/client.js";
+import { Bin, CLI_VERSION } from "../provisioning/index.js";
+import { Context } from "./context.js";
+/**
+ * @hidden
+ *
+ * Initialize a default client context from environment.
+ */
+export async function initDefaultContext(cfg = {}) {
+    let ctx = new Context();
+    // Prefer DAGGER_SESSION_PORT if set
+    const daggerSessionPort = process.env["DAGGER_SESSION_PORT"];
+    if (daggerSessionPort) {
+        const sessionToken = process.env["DAGGER_SESSION_TOKEN"];
+        if (!sessionToken) {
+            throw new Error("DAGGER_SESSION_TOKEN must be set when using DAGGER_SESSION_PORT");
+        }
+        if (cfg.Workdir && cfg.Workdir !== "") {
+            throw new Error("cannot configure workdir for existing session (please use --workdir or host.directory with absolute paths instead)");
+        }
+        ctx = new Context({
+            client: createGQLClient(Number(daggerSessionPort), sessionToken),
+        });
+    }
+    else {
+        // Otherwise, prefer _EXPERIMENTAL_DAGGER_CLI_BIN, with fallback behavior of
+        // downloading the CLI and using that as the bin.
+        const cliBin = process.env["_EXPERIMENTAL_DAGGER_CLI_BIN"];
+        const engineConn = new Bin(cliBin, CLI_VERSION);
+        const client = await engineConn.Connect(cfg);
+        ctx = new Context({ client, subProcess: engineConn.subProcess });
+    }
+    return ctx;
+}

package/dist/context/context.d.ts

@@ -0,0 +1,39 @@
+import { ExecaChildProcess } from "execa";
+import { GraphQLClient } from "graphql-request";
+import { ConnectOpts } from "../connectOpts.js";
+interface ContextConfig {
+    client?: GraphQLClient;
+    subProcess?: ExecaChildProcess;
+}
+/**
+ * Context abstracts the connection to the engine.
+ *
+ * It's required to implement the default global SDK.
+ * Its purpose is to store and returns the connection to the graphQL API, if
+ * no connection is set, it can create its own.
+ *
+ * This is also useful for lazy evaluation with the default global client,
+ * this one should only run the engine if it actually executes something.
+ */
+export declare class Context {
+    private _client?;
+    private _subProcess?;
+    constructor(config?: ContextConfig);
+    /**
+     * Returns a GraphQL client connected to the engine.
+     *
+     * If no client is set, it will create one.
+     */
+    connection(cfg?: ConnectOpts): Promise<GraphQLClient>;
+    /**
+     * Close the connection and the engine if this one was started by the node
+     * SDK.
+     */
+    close(): void;
+}
+/**
+ * Expose a default context for the global client
+ */
+export declare const defaultContext: Context;
+export {};
+//# sourceMappingURL=context.d.ts.map

package/dist/context/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../context/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAA;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAG/C,UAAU,aAAa;IACrB,MAAM,CAAC,EAAE,aAAa,CAAA;IACtB,UAAU,CAAC,EAAE,iBAAiB,CAAA;CAC/B;AAED;;;;;;;;;GASG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,OAAO,CAAC,CAAe;IAC/B,OAAO,CAAC,WAAW,CAAC,CAAmB;gBAE3B,MAAM,CAAC,EAAE,aAAa;IAKlC;;;;OAIG;IACU,UAAU,CAAC,GAAG,GAAE,WAAgB,GAAG,OAAO,CAAC,aAAa,CAAC;IAUtE;;;OAGG;IACI,KAAK,IAAI,IAAI;CAYrB;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,SAAgB,CAAA"}

package/dist/context/context.js

@@ -0,0 +1,51 @@
+import { initDefaultContext } from "./builder.js";
+/**
+ * Context abstracts the connection to the engine.
+ *
+ * It's required to implement the default global SDK.
+ * Its purpose is to store and returns the connection to the graphQL API, if
+ * no connection is set, it can create its own.
+ *
+ * This is also useful for lazy evaluation with the default global client,
+ * this one should only run the engine if it actually executes something.
+ */
+export class Context {
+    _client;
+    _subProcess;
+    constructor(config) {
+        this._client = config?.client;
+        this._subProcess = config?.subProcess;
+    }
+    /**
+     * Returns a GraphQL client connected to the engine.
+     *
+     * If no client is set, it will create one.
+     */
+    async connection(cfg = {}) {
+        if (!this._client) {
+            const defaultCtx = await initDefaultContext(cfg);
+            this._client = defaultCtx._client;
+            this._subProcess = defaultCtx._subProcess;
+        }
+        return this._client;
+    }
+    /**
+     * Close the connection and the engine if this one was started by the node
+     * SDK.
+     */
+    close() {
+        if (this._subProcess) {
+            this._subProcess.kill("SIGTERM", {
+                // Set a long timeout to give time for any cache exports to pack layers up
+                // which currently has to happen synchronously with the session.
+                forceKillAfterTimeout: 300000, // 5 mins
+            });
+        }
+        // Reset client, so it can restart a new connection if necessary
+        this._client = undefined;
+    }
+}
+/**
+ * Expose a default context for the global client
+ */
+export const defaultContext = new Context();

package/dist/entrypoint/entrypoint.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=entrypoint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoint.d.ts","sourceRoot":"","sources":["../../entrypoint/entrypoint.ts"],"names":[],"mappings":""}

package/dist/entrypoint/entrypoint.js

@@ -0,0 +1,70 @@
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { dag } from "../api/client.gen.js";
+import { connection } from "../connect.js";
+import { listFiles } from "../introspector/utils/files.js";
+import { invoke } from "./invoke.js";
+import { load, loadArg } from "./load.js";
+import { register } from "./register.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const moduleSrcDirectory = `${__dirname}/../../src/`;
+async function entrypoint() {
+    // Pre list all files of the modules since we need it either for a registration
+    // or an invocation
+    const files = await listFiles(moduleSrcDirectory);
+    // Start a Dagger session to get the call context
+    await connection(async () => {
+        const fnCall = dag.currentFunctionCall();
+        const parentName = await fnCall.parentName();
+        // Pre allocate the result, we got one in both case.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let result;
+        if (parentName === "") {
+            // It's a registration, we register the module and assign the module id
+            // to the result
+            result = await register(files);
+        }
+        else {
+            // Invocation
+            const fnName = await fnCall.name();
+            const parentJson = JSON.parse(await fnCall.parent());
+            const fnArgs = await fnCall.inputArgs();
+            const args = {};
+            const parentArgs = {};
+            for (const arg of fnArgs) {
+                args[await arg.name()] = await loadArg(await arg.value());
+            }
+            if (parentJson) {
+                for (const [key, value] of Object.entries(parentJson)) {
+                    parentArgs[key] = await loadArg(value);
+                }
+            }
+            await load(files);
+            result = await invoke(parentName, fnName, parentArgs, args);
+            // Load ID if it's a Dagger type with an id
+            if (typeof result?.id === "function") {
+                result = await result.id();
+            }
+            // Load its field ID if there are
+            if (typeof result === "object") {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                for (const [key, value] of Object.entries(result)) {
+                    if (value.id && typeof value.id === "function") {
+                        result[key] = await value.id();
+                    }
+                }
+            }
+        }
+        // If result is set, we stringify it
+        if (result !== undefined && result !== null) {
+            result = JSON.stringify(result);
+        }
+        else {
+            result = "null";
+        }
+        // Send the result to Dagger
+        await fnCall.returnValue(result);
+    }, { LogOutput: process.stdout });
+}
+entrypoint();

package/dist/entrypoint/invoke.d.ts

@@ -0,0 +1,11 @@
+import { Args, State } from "../introspector/registry/registry.js";
+/**
+ * A wrapper around the registry to invoke a function.
+ *
+ * @param objectName – The class to look for
+ * @param methodName – The method to call in the class
+ * @param state – The current state of the class
+ * @param inputs – The input to send to the method to call
+ */
+export declare function invoke(objectName: string, methodName: string, state: State, inputs: Args): Promise<any>;
+//# sourceMappingURL=invoke.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../entrypoint/invoke.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,KAAK,EAAE,MAAM,sCAAsC,CAAA;AAE5E;;;;;;;GAOG;AACH,wBAAsB,MAAM,CAC1B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,IAAI,GAEX,OAAO,CAAC,GAAG,CAAC,CAEd"}

package/dist/entrypoint/invoke.js

@@ -0,0 +1,14 @@
+import { registry } from "../introspector/registry/registry.js";
+/**
+ * A wrapper around the registry to invoke a function.
+ *
+ * @param objectName – The class to look for
+ * @param methodName – The method to call in the class
+ * @param state – The current state of the class
+ * @param inputs – The input to send to the method to call
+ */
+export async function invoke(objectName, methodName, state, inputs
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    return await registry.getResult(objectName, methodName, state, inputs);
+}

package/dist/entrypoint/load.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 declare function load(files: string[]): Promise<void>;
+/**
+ * Load argument as Dagger type.
+ *
+ * This function remove the quote from the identifier and checks
+ * if it's a Dagger type, if it is, it loads it according to
+ * its type.
+ */
+export declare function loadArg(value: string): Promise<any>;
+//# sourceMappingURL=load.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../entrypoint/load.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAEzD;AAED;;;;;;GAMG;AAEH,wBAAsB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CA8BzD"}

package/dist/entrypoint/load.js

@@ -0,0 +1,44 @@
+import { dag } from "../api/client.gen.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) {
+    await Promise.all(files.map(async (f) => await import(f)));
+}
+/**
+ * Load argument as Dagger type.
+ *
+ * This function remove the quote from the identifier and checks
+ * if it's a Dagger type, if it is, it loads it according to
+ * its type.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function loadArg(value) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let parsedValue;
+    const isString = () => (value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith(`'`) && value.endsWith(`'`));
+    const isArray = () => value.startsWith("[") && value.endsWith("]");
+    // Apply JSON parse to parse array or string if the value is wrapped into a string or array
+    if (isString() || isArray()) {
+        parsedValue = JSON.parse(value);
+    }
+    else {
+        parsedValue = value;
+    }
+    // If it's a string, it might contain an identifier to load ,or it might be a hidden array
+    if (typeof parsedValue === "string") {
+        const [source] = parsedValue.split(":");
+        const [origin, type] = source.split(".");
+        if (origin === "core") {
+            // Workaround to call get any object that has an id
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            return dag[`load${type}FromID`](parsedValue);
+        }
+    }
+    return parsedValue;
+}

package/dist/entrypoint/register.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../entrypoint/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAGT,MAAM,mBAAmB,CAAA;AAW1B;;GAEG;AACH,wBAAsB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAoCjE"}

package/dist/entrypoint/register.js

@@ -0,0 +1,93 @@
+import { dag, TypeDefKind, } from "../api/client.gen";
+import { scan } from "../introspector/scanner/scan.js";
+/**
+ * Register the module files and returns its ID
+ */
+export async function register(files) {
+    // Scan all files
+    const scanResult = await scan(files);
+    // Get the current module
+    let mod = dag.currentModule();
+    // For each class scanned, register its type, method and properties in the module.
+    scanResult.classes.forEach((modClass) => {
+        // Register the class Typedef object in Dagger
+        let typeDef = dag.typeDef().withObject(modClass.name, {
+            description: modClass.description,
+        });
+        // Register all functions (methods) to this object
+        modClass.methods.forEach((method) => {
+            typeDef = typeDef.withFunction(addFunction(method));
+        });
+        // Register all fields that belong to this object
+        modClass.fields.forEach((field) => {
+            typeDef = typeDef.withField(field.name, addTypeDef(field.typeDef), {
+                description: field.description,
+            });
+        });
+        if (modClass.constructor) {
+            typeDef.withConstructor(addConstructor(modClass.constructor, typeDef));
+        }
+        // Add it to the module object
+        mod = mod.withObject(typeDef);
+    });
+    // Call ID to actually execute the registration
+    return await mod.id();
+}
+/**
+ * Bind a constructor to the given object.
+ */
+function addConstructor(constructor, owner) {
+    return dag.function_("", owner).with(addArg(constructor.args));
+}
+/**
+ * Create a function in the Dagger API.
+ */
+function addFunction(fct) {
+    return dag
+        .function_(fct.name, addTypeDef(fct.returnType))
+        .withDescription(fct.description)
+        .with(addArg(fct.args));
+}
+/**
+ * Register all arguments in the function.
+ */
+function addArg(args) {
+    return function (fct) {
+        args.forEach((arg) => {
+            const opts = {
+                description: arg.description,
+            };
+            if (arg.defaultValue) {
+                opts.defaultValue = arg.defaultValue;
+            }
+            let typeDef = addTypeDef(arg.typeDef);
+            if (arg.optional) {
+                typeDef = typeDef.withOptional(true);
+            }
+            fct = fct.withArg(arg.name, typeDef, opts);
+        });
+        return fct;
+    };
+}
+/**
+ * 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.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);
+        default:
+            return dag.typeDef().withKind(type.kind);
+    }
+}

package/dist/graphql/client.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLClient } from "graphql-request";
+export declare function createGQLClient(port: number, token: string): GraphQLClient;
+//# sourceMappingURL=client.d.ts.map

package/dist/graphql/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../graphql/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,CAM1E"}

package/dist/graphql/client.js

@@ -0,0 +1,8 @@
+import { GraphQLClient } from "graphql-request";
+export function createGQLClient(port, token) {
+    return new GraphQLClient(`http://127.0.0.1:${port}/query`, {
+        headers: {
+            Authorization: "Basic " + Buffer.from(token + ":").toString("base64"),
+        },
+    });
+}

package/dist/index.d.ts

@@ -2,5 +2,7 @@ export * from "./api/client.gen.js";
 export * from "./common/errors/index.js";
 export { gql } from "graphql-tag";
 export { GraphQLClient } from "graphql-request";
-export { connect, ConnectOpts, CallbackFct } from "./connect.js";
+export { connect, CallbackFct, connection, close } from "./connect.js";
+export { ConnectOpts } from "./connectOpts.js";
+export * from "./introspector/decorators/decorators.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACtE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,cAAc,yCAAyC,CAAA"}

package/dist/index.js

@@ -2,4 +2,5 @@ export * from "./api/client.gen.js";
 export * from "./common/errors/index.js";
 export { gql } from "graphql-tag";
 export { GraphQLClient } from "graphql-request";
-export { connect } from "./connect.js";
+export { connect, connection, close } from "./connect.js";
+export * from "./introspector/decorators/decorators.js";

package/dist/introspector/decorators/decorators.d.ts

@@ -0,0 +1,4 @@
+export declare const object: <T extends import("../registry/registry.js").Class>(constructor: T) => T;
+export declare const func: (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+export declare const field: (target: object, propertyKey: string) => void;
+//# sourceMappingURL=decorators.d.ts.map

package/dist/introspector/decorators/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../../introspector/decorators/decorators.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM,0EAAkB,CAAA;AACrC,eAAO,MAAM,IAAI,wFAAgB,CAAA;AACjC,eAAO,MAAM,KAAK,+CAAiB,CAAA"}

package/dist/introspector/decorators/decorators.js

@@ -0,0 +1,7 @@
+/**
+ * Expose the decorator publicly, so they insert data into the global registry.
+ */
+import { registry } from "../registry/registry.js";
+export const object = registry.object;
+export const func = registry.func;
+export const field = registry.field;

package/dist/introspector/registry/registry.d.ts

@@ -0,0 +1,65 @@
+export type Class = {
+    new (...args: any[]): any;
+};
+export type State = {
+    [property: string]: any;
+};
+export type Args = Record<string, unknown>;
+/**
+ * Registry stores class and method that have the @object decorator.
+ *
+ * This is a convenient way to make possible the invocation of class' function.
+ *
+ * The decorator @object store the class into the Registry, but also all the
+ * users method's name.
+ * It doesn't consider the `@func` or `field` decorators because this is
+ * used by the Dagger API to know what to expose or not.
+ * This might lead to unnecessary data register into the registry, but
+ * we use map as datastructure to optimize the searching process
+ * since we directly look through a key into the `class_` member of
+ * RegistryClass.
+ */
+export declare class Registry {
+    private classes;
+    /**
+     * The definition of the @object decorator that should be on top of any
+     * class module that must be exposed to the Dagger API.
+     *
+     */
+    object: <T extends Class>(constructor: T) => T;
+    /**
+     * The definition of @field decorator that should be on top of any
+     * class' property that must be exposed to the Dagger API.
+     */
+    field: (target: object, propertyKey: string) => void;
+    /**
+     * The definition of @func decorator that should be on top of any
+     * class' method that must be exposed to the Dagger API.
+     */
+    func: (target: object, propertyKey: string | symbol, descriptor: PropertyDescriptor) => void;
+    /**
+     * getResult check for the object and method in the registry and call it
+     * with the given input and state.
+     *
+     * This is the function responsible for any module methods execution.
+     *
+     * @param object The class to look for
+     * @param method The method to call in the class
+     * @param state The current state of the class
+     * @param inputs The input to send to the method to call
+     */
+    getResult(object: string, method: string, state: State, inputs: Args): Promise<any>;
+    /**
+     * Get the order of argument by reading its content and create an array of its argument
+     * We cannot use r[method].prototype because it can be empty depending on the loading.
+     * Note(TomChv): This is a workaround until we find something more accurate.
+     * @param fct
+     * @private
+     */
+    private getArgOrder;
+}
+/**
+ * The default registry used in any module.
+ */
+export declare const registry: Registry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/introspector/registry/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../introspector/registry/registry.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,KAAK,GAAG;IAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAA;CAAE,CAAA;AAGjD,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;AAa1C;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,OAAO,CAAoB;IAEnC;;;;OAIG;IACH,MAAM,yCA4BL;IAED;;;OAGG;IAEH,KAAK,WAAY,MAAM,eAAe,MAAM,UAE3C;IAED;;;OAGG;IACH,IAAI,WAEM,MAAM,eAED,MAAM,GAAG,MAAM,cAEhB,kBAAkB,UAK/B;IAED;;;;;;;;;;OAUG;IACG,SAAS,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,IAAI,GAEX,OAAO,CAAC,GAAG,CAAC;IAwCf;;;;;;OAMG;IAEH,OAAO,CAAC,WAAW;CAWpB;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,UAAiB,CAAA"}