@medusajs/workflows-sdk 0.2.0-next-20231124140416

package/dist/utils/composer/create-workflow.d.ts

@@ -0,0 +1,124 @@
+import { LocalWorkflow } from "@medusajs/orchestration";
+import { LoadedModule, MedusaContainer } from "@medusajs/types";
+import { FlowRunOptions, WorkflowResult } from "../../helper";
+import { WorkflowData, WorkflowDataProperties } from "./type";
+/**
+ * An exported workflow, which is the type of a workflow constructed by the {@link createWorkflow} function. The exported workflow can be invoked to create
+ * an executable workflow, optionally within a specified container. So, to execute the workflow, you must invoke the exported workflow, then run the
+ * `run` method of the exported workflow.
+ *
+ * @example
+ * To execute a workflow:
+ *
+ * ```ts
+ * myWorkflow()
+ *   .run({
+ *     input: {
+ *       name: "John"
+ *     }
+ *   })
+ *   .then(({ result }) => {
+ *     console.log(result)
+ *   })
+ * ```
+ *
+ * To specify the container of the workflow, you can pass it as an argument to the call of the exported workflow. This is necessary when executing the workflow
+ * within a Medusa resource such as an API Route or a Subscriber.
+ *
+ * For example:
+ *
+ * ```ts
+ * import type {
+ *   MedusaRequest,
+ *   MedusaResponse
+ * } from "@medusajs/medusa";
+ * import myWorkflow from "../../../workflows/hello-world";
+ *
+ * export async function GET(
+ *   req: MedusaRequest,
+ *   res: MedusaResponse
+ * ) {
+ *   const { result } = await myWorkflow(req.scope)
+ *     .run({
+ *       input: {
+ *         name: req.query.name as string
+ *       }
+ *     })
+ *
+ *   res.send(result)
+ * }
+ * ```
+ */
+type ReturnWorkflow<TData, TResult, THooks extends Record<string, Function>> = {
+    <TDataOverride = undefined, TResultOverride = undefined>(container?: LoadedModule[] | MedusaContainer): Omit<LocalWorkflow, "run"> & {
+        run: (args?: FlowRunOptions<TDataOverride extends undefined ? TData : TDataOverride>) => Promise<WorkflowResult<TResultOverride extends undefined ? TResult : TResultOverride>>;
+    };
+} & THooks;
+/**
+ * This function creates a workflow with the provided name and a constructor function.
+ * The constructor function builds the workflow from steps created by the {@link createStep} function.
+ * The returned workflow is an exported workflow of type {@link ReturnWorkflow}, meaning it's not executed right away. To execute it,
+ * invoke the exported workflow, then run its `run` method.
+ *
+ * @typeParam TData - The type of the input passed to the composer function.
+ * @typeParam TResult - The type of the output returned by the composer function.
+ * @typeParam THooks - The type of hooks defined in the workflow.
+ *
+ * @returns The created workflow. You can later execute the workflow by invoking it, then using its `run` method.
+ *
+ * @example
+ * import { createWorkflow } from "@medusajs/workflows-sdk"
+ * import { MedusaRequest, MedusaResponse, Product } from "@medusajs/medusa"
+ * import {
+ *   createProductStep,
+ *   getProductStep,
+ *   createPricesStep
+ * } from "./steps"
+ *
+ * interface WorkflowInput {
+ *  title: string
+ * }
+ *
+ * const myWorkflow = createWorkflow<
+ *     WorkflowInput,
+ *     Product
+ *   >("my-workflow", (input) => {
+ *    // Everything here will be executed and resolved later
+ *    // during the execution. Including the data access.
+ *
+ *     const product = createProductStep(input)
+ *     const prices = createPricesStep(product)
+ *     return getProductStep(product.id)
+ *   }
+ * )
+ *
+ * export async function GET(
+ *   req: MedusaRequest,
+ *   res: MedusaResponse
+ * ) {
+ *   const { result: product } = await myWorkflow(req.scope)
+ *     .run({
+ *       input: {
+ *         title: "Shirt"
+ *       }
+ *     })
+ *
+ *   res.json({
+ *     product
+ *   })
+ * }
+ */
+export declare function createWorkflow<TData, TResult, THooks extends Record<string, Function> = Record<string, Function>>(
+/**
+ * The name of the workflow.
+ */
+name: string, 
+/**
+ * The constructor function that is executed when the `run` method in {@link ReturnWorkflow} is used.
+ * The function can't be an arrow function or an asynchronus function. It also can't directly manipulate data.
+ * You'll have to use the {@link transform} function if you need to directly manipulate data.
+ */
+composer: (input: WorkflowData<TData>) => void | WorkflowData<TResult> | {
+    [K in keyof TResult]: WorkflowData<TResult[K]> | WorkflowDataProperties<TResult[K]>;
+}): ReturnWorkflow<TData, TResult, THooks>;
+export {};

package/dist/utils/composer/create-workflow.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkflow = void 0;
+const orchestration_1 = require("@medusajs/orchestration");
+const helper_1 = require("../../helper");
+const helpers_1 = require("./helpers");
+const proxy_1 = require("./helpers/proxy");
+global[helpers_1.SymbolMedusaWorkflowComposerContext] = null;
+/**
+ * This function creates a workflow with the provided name and a constructor function.
+ * The constructor function builds the workflow from steps created by the {@link createStep} function.
+ * The returned workflow is an exported workflow of type {@link ReturnWorkflow}, meaning it's not executed right away. To execute it,
+ * invoke the exported workflow, then run its `run` method.
+ *
+ * @typeParam TData - The type of the input passed to the composer function.
+ * @typeParam TResult - The type of the output returned by the composer function.
+ * @typeParam THooks - The type of hooks defined in the workflow.
+ *
+ * @returns The created workflow. You can later execute the workflow by invoking it, then using its `run` method.
+ *
+ * @example
+ * import { createWorkflow } from "@medusajs/workflows-sdk"
+ * import { MedusaRequest, MedusaResponse, Product } from "@medusajs/medusa"
+ * import {
+ *   createProductStep,
+ *   getProductStep,
+ *   createPricesStep
+ * } from "./steps"
+ *
+ * interface WorkflowInput {
+ *  title: string
+ * }
+ *
+ * const myWorkflow = createWorkflow<
+ *     WorkflowInput,
+ *     Product
+ *   >("my-workflow", (input) => {
+ *    // Everything here will be executed and resolved later
+ *    // during the execution. Including the data access.
+ *
+ *     const product = createProductStep(input)
+ *     const prices = createPricesStep(product)
+ *     return getProductStep(product.id)
+ *   }
+ * )
+ *
+ * export async function GET(
+ *   req: MedusaRequest,
+ *   res: MedusaResponse
+ * ) {
+ *   const { result: product } = await myWorkflow(req.scope)
+ *     .run({
+ *       input: {
+ *         title: "Shirt"
+ *       }
+ *     })
+ *
+ *   res.json({
+ *     product
+ *   })
+ * }
+ */
+function createWorkflow(
+/**
+ * The name of the workflow.
+ */
+name, 
+/**
+ * The constructor function that is executed when the `run` method in {@link ReturnWorkflow} is used.
+ * The function can't be an arrow function or an asynchronus function. It also can't directly manipulate data.
+ * You'll have to use the {@link transform} function if you need to directly manipulate data.
+ */
+composer) {
+    const handlers = new Map();
+    if (orchestration_1.WorkflowManager.getWorkflow(name)) {
+        orchestration_1.WorkflowManager.unregister(name);
+    }
+    orchestration_1.WorkflowManager.register(name, undefined, handlers);
+    const context = {
+        workflowId: name,
+        flow: orchestration_1.WorkflowManager.getTransactionDefinition(name),
+        handlers,
+        hooks_: [],
+        hooksCallback_: {},
+        hookBinder: (name, fn) => {
+            context.hooks_.push(name);
+            return fn(context);
+        },
+        stepBinder: (fn) => {
+            return fn.bind(context)();
+        },
+        parallelizeBinder: (fn) => {
+            return fn.bind(context)();
+        },
+    };
+    global[helpers_1.SymbolMedusaWorkflowComposerContext] = context;
+    const inputPlaceHolder = (0, proxy_1.proxify)({
+        __type: helpers_1.SymbolInputReference,
+        __step__: "",
+    });
+    const returnedStep = composer.apply(context, [inputPlaceHolder]);
+    delete global[helpers_1.SymbolMedusaWorkflowComposerContext];
+    orchestration_1.WorkflowManager.update(name, context.flow, handlers);
+    const workflow = (0, helper_1.exportWorkflow)(name);
+    const mainFlow = (container) => {
+        const workflow_ = workflow(container);
+        const originalRun = workflow_.run;
+        workflow_.run = (async (args) => {
+            args ?? (args = {});
+            args.resultFrom ?? (args.resultFrom = returnedStep?.__type === helpers_1.SymbolWorkflowStep
+                ? returnedStep.__step__
+                : undefined);
+            // Forwards the input to the ref object on composer.apply
+            const workflowResult = (await originalRun(args));
+            workflowResult.result = await (0, helpers_1.resolveValue)(workflowResult.result || returnedStep, workflowResult.transaction.getContext());
+            return workflowResult;
+        });
+        return workflow_;
+    };
+    let shouldRegisterHookHandler = true;
+    for (const hook of context.hooks_) {
+        mainFlow[hook] = (fn) => {
+            var _a;
+            (_a = context.hooksCallback_)[hook] ?? (_a[hook] = []);
+            if (!shouldRegisterHookHandler) {
+                console.warn(`A hook handler has already been registered for the ${hook} hook. The current handler registration will be skipped.`);
+                return;
+            }
+            context.hooksCallback_[hook].push(fn);
+            shouldRegisterHookHandler = false;
+        };
+    }
+    return mainFlow;
+}
+exports.createWorkflow = createWorkflow;
+//# sourceMappingURL=create-workflow.js.map

package/dist/utils/composer/create-workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-workflow.js","sourceRoot":"","sources":["../../../src/utils/composer/create-workflow.ts"],"names":[],"mappings":"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"}

package/dist/utils/composer/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./step-response";
+export * from "./symbol";
+export * from "./resolve-value";

package/dist/utils/composer/helpers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./step-response"), exports);
+__exportStar(require("./symbol"), exports);
+__exportStar(require("./resolve-value"), exports);
+//# sourceMappingURL=index.js.map

package/dist/utils/composer/helpers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/utils/composer/helpers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAA+B;AAC/B,2CAAwB;AACxB,kDAA+B"}

package/dist/utils/composer/helpers/proxy.d.ts

@@ -0,0 +1,2 @@
+import { WorkflowData } from "../type";
+export declare function proxify<T>(obj: WorkflowData<any>): T;

package/dist/utils/composer/helpers/proxy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proxify = void 0;
+const transform_1 = require("../transform");
+const symbol_1 = require("./symbol");
+const resolve_value_1 = require("./resolve-value");
+function proxify(obj) {
+    return new Proxy(obj, {
+        get(target, prop) {
+            if (prop in target) {
+                return target[prop];
+            }
+            return (0, transform_1.transform)(target[prop], async function (input, context) {
+                const { invoke } = context;
+                let output = target.__type === symbol_1.SymbolInputReference ||
+                    target.__type === symbol_1.SymbolWorkflowStepTransformer
+                    ? target
+                    : invoke?.[obj.__step__]?.output;
+                output = await (0, resolve_value_1.resolveValue)(output, context);
+                output = output?.[prop];
+                return output && JSON.parse(JSON.stringify(output));
+            });
+        },
+    });
+}
+exports.proxify = proxify;
+//# sourceMappingURL=proxy.js.map

package/dist/utils/composer/helpers/proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../../../src/utils/composer/helpers/proxy.ts"],"names":[],"mappings":";;;AAAA,4CAAwC;AAExC,qCAA8E;AAC9E,mDAA8C;AAE9C,SAAgB,OAAO,CAAI,GAAsB;IAC/C,OAAO,IAAI,KAAK,CAAC,GAAG,EAAE;QACpB,GAAG,CAAC,MAAW,EAAE,IAAqB;YACpC,IAAI,IAAI,IAAI,MAAM,EAAE;gBAClB,OAAO,MAAM,CAAC,IAAI,CAAC,CAAA;aACpB;YAED,OAAO,IAAA,qBAAS,EAAC,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,WAAW,KAAK,EAAE,OAAO;gBAC3D,MAAM,EAAE,MAAM,EAAE,GAAG,OAAqC,CAAA;gBACxD,IAAI,MAAM,GACR,MAAM,CAAC,MAAM,KAAK,6BAAoB;oBACtC,MAAM,CAAC,MAAM,KAAK,sCAA6B;oBAC7C,CAAC,CAAC,MAAM;oBACR,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;gBAEpC,MAAM,GAAG,MAAM,IAAA,4BAAY,EAAC,MAAM,EAAE,OAAO,CAAC,CAAA;gBAC5C,MAAM,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,CAAA;gBAEvB,OAAO,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAA;YACrD,CAAC,CAAC,CAAA;QACJ,CAAC;KACF,CAAiB,CAAA;AACpB,CAAC;AAtBD,0BAsBC"}

package/dist/utils/composer/helpers/resolve-value.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare function resolveValue(input: any, transactionContext: any): Promise<any>;

package/dist/utils/composer/helpers/resolve-value.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveValue = void 0;
+const utils_1 = require("@medusajs/utils");
+const symbol_1 = require("./symbol");
+async function resolveProperty(property, transactionContext) {
+    const { invoke: invokeRes } = transactionContext;
+    if (property?.__type === symbol_1.SymbolInputReference) {
+        return transactionContext.payload;
+    }
+    else if (property?.__type === symbol_1.SymbolWorkflowStepTransformer) {
+        return await property.__resolver(transactionContext);
+    }
+    else if (property?.__type === symbol_1.SymbolWorkflowHook) {
+        return await property.__value(transactionContext);
+    }
+    else if (property?.__type === symbol_1.SymbolWorkflowStep) {
+        const output = invokeRes[property.__step__]?.output;
+        if (output?.__type === symbol_1.SymbolWorkflowStepResponse) {
+            return output.output;
+        }
+        return output;
+    }
+    else if (property?.__type === symbol_1.SymbolWorkflowStepResponse) {
+        return property.output;
+    }
+    else {
+        return property;
+    }
+}
+/**
+ * @internal
+ */
+async function resolveValue(input, transactionContext) {
+    const unwrapInput = async (inputTOUnwrap, parentRef) => {
+        if (inputTOUnwrap == null) {
+            return inputTOUnwrap;
+        }
+        if (Array.isArray(inputTOUnwrap)) {
+            return await (0, utils_1.promiseAll)(inputTOUnwrap.map((i) => unwrapInput(i, transactionContext)));
+        }
+        if (typeof inputTOUnwrap !== "object") {
+            return inputTOUnwrap;
+        }
+        for (const key of Object.keys(inputTOUnwrap)) {
+            parentRef[key] = await resolveProperty(inputTOUnwrap[key], transactionContext);
+            if (typeof parentRef[key] === "object") {
+                await unwrapInput(parentRef[key], parentRef[key]);
+            }
+        }
+        return parentRef;
+    };
+    const result = input?.__type
+        ? await resolveProperty(input, transactionContext)
+        : await unwrapInput(input, {});
+    return result && JSON.parse(JSON.stringify(result));
+}
+exports.resolveValue = resolveValue;
+//# sourceMappingURL=resolve-value.js.map

package/dist/utils/composer/helpers/resolve-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-value.js","sourceRoot":"","sources":["../../../../src/utils/composer/helpers/resolve-value.ts"],"names":[],"mappings":";;;AAAA,2CAA4C;AAC5C,qCAMiB;AAEjB,KAAK,UAAU,eAAe,CAAC,QAAQ,EAAE,kBAAkB;IACzD,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,kBAAkB,CAAA;IAEhD,IAAI,QAAQ,EAAE,MAAM,KAAK,6BAAoB,EAAE;QAC7C,OAAO,kBAAkB,CAAC,OAAO,CAAA;KAClC;SAAM,IAAI,QAAQ,EAAE,MAAM,KAAK,sCAA6B,EAAE;QAC7D,OAAO,MAAM,QAAQ,CAAC,UAAU,CAAC,kBAAkB,CAAC,CAAA;KACrD;SAAM,IAAI,QAAQ,EAAE,MAAM,KAAK,2BAAkB,EAAE;QAClD,OAAO,MAAM,QAAQ,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAA;KAClD;SAAM,IAAI,QAAQ,EAAE,MAAM,KAAK,2BAAkB,EAAE;QAClD,MAAM,MAAM,GAAG,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;QACnD,IAAI,MAAM,EAAE,MAAM,KAAK,mCAA0B,EAAE;YACjD,OAAO,MAAM,CAAC,MAAM,CAAA;SACrB;QAED,OAAO,MAAM,CAAA;KACd;SAAM,IAAI,QAAQ,EAAE,MAAM,KAAK,mCAA0B,EAAE;QAC1D,OAAO,QAAQ,CAAC,MAAM,CAAA;KACvB;SAAM;QACL,OAAO,QAAQ,CAAA;KAChB;AACH,CAAC;AAED;;GAEG;AACI,KAAK,UAAU,YAAY,CAAC,KAAK,EAAE,kBAAkB;IAC1D,MAAM,WAAW,GAAG,KAAK,EACvB,aAAsC,EACtC,SAAc,EACd,EAAE;QACF,IAAI,aAAa,IAAI,IAAI,EAAE;YACzB,OAAO,aAAa,CAAA;SACrB;QAED,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;YAChC,OAAO,MAAM,IAAA,kBAAU,EACrB,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAC7D,CAAA;SACF;QAED,IAAI,OAAO,aAAa,KAAK,QAAQ,EAAE;YACrC,OAAO,aAAa,CAAA;SACrB;QAED,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,EAAE;YAC5C,SAAS,CAAC,GAAG,CAAC,GAAG,MAAM,eAAe,CACpC,aAAa,CAAC,GAAG,CAAC,EAClB,kBAAkB,CACnB,CAAA;YAED,IAAI,OAAO,SAAS,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE;gBACtC,MAAM,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC,CAAA;aAClD;SACF;QAED,OAAO,SAAS,CAAA;IAClB,CAAC,CAAA;IAED,MAAM,MAAM,GAAG,KAAK,EAAE,MAAM;QAC1B,CAAC,CAAC,MAAM,eAAe,CAAC,KAAK,EAAE,kBAAkB,CAAC;QAClD,CAAC,CAAC,MAAM,WAAW,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;IAEhC,OAAO,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAA;AACrD,CAAC;AAtCD,oCAsCC"}

package/dist/utils/composer/helpers/step-response.d.ts

@@ -0,0 +1,48 @@
+/**
+ * This class is used to create the response returned by a step. A step return its data by returning an instance of `StepResponse`.
+ *
+ * @typeParam TOutput - The type of the output of the step.
+ * @typeParam TCompensateInput -
+ * The type of the compensation input. If the step doesn't specify any compensation input, then the type of `TCompensateInput` is the same
+ * as that of `TOutput`.
+ */
+export declare class StepResponse<TOutput, TCompensateInput = TOutput> {
+    #private;
+    /**
+     * The constructor of the StepResponse
+     *
+     * @typeParam TOutput - The type of the output of the step.
+     * @typeParam TCompensateInput -
+     * The type of the compensation input. If the step doesn't specify any compensation input, then the type of `TCompensateInput` is the same
+     * as that of `TOutput`.
+     */
+    constructor(
+    /**
+     * The output of the step.
+     */
+    output: TOutput, 
+    /**
+     * The input to be passed as a parameter to the step's compensation function. If not provided, the `output` will be provided instead.
+     */
+    compensateInput?: TCompensateInput);
+    /**
+     * @internal
+     */
+    get __type(): symbol;
+    /**
+     * @internal
+     */
+    get output(): TOutput;
+    /**
+     * @internal
+     */
+    get compensateInput(): TCompensateInput;
+    /**
+     * @internal
+     */
+    toJSON(): {
+        __type: symbol;
+        output: TOutput;
+        compensateInput: TCompensateInput | undefined;
+    };
+}

package/dist/utils/composer/helpers/step-response.js

@@ -0,0 +1,80 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _StepResponse___type, _StepResponse_output, _StepResponse_compensateInput;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepResponse = void 0;
+const symbol_1 = require("./symbol");
+/**
+ * This class is used to create the response returned by a step. A step return its data by returning an instance of `StepResponse`.
+ *
+ * @typeParam TOutput - The type of the output of the step.
+ * @typeParam TCompensateInput -
+ * The type of the compensation input. If the step doesn't specify any compensation input, then the type of `TCompensateInput` is the same
+ * as that of `TOutput`.
+ */
+class StepResponse {
+    /**
+     * The constructor of the StepResponse
+     *
+     * @typeParam TOutput - The type of the output of the step.
+     * @typeParam TCompensateInput -
+     * The type of the compensation input. If the step doesn't specify any compensation input, then the type of `TCompensateInput` is the same
+     * as that of `TOutput`.
+     */
+    constructor(
+    /**
+     * The output of the step.
+     */
+    output, 
+    /**
+     * The input to be passed as a parameter to the step's compensation function. If not provided, the `output` will be provided instead.
+     */
+    compensateInput) {
+        _StepResponse___type.set(this, symbol_1.SymbolWorkflowStepResponse);
+        _StepResponse_output.set(this, void 0);
+        _StepResponse_compensateInput.set(this, void 0);
+        __classPrivateFieldSet(this, _StepResponse_output, output, "f");
+        __classPrivateFieldSet(this, _StepResponse_compensateInput, (compensateInput ?? output), "f");
+    }
+    /**
+     * @internal
+     */
+    get __type() {
+        return __classPrivateFieldGet(this, _StepResponse___type, "f");
+    }
+    /**
+     * @internal
+     */
+    get output() {
+        return __classPrivateFieldGet(this, _StepResponse_output, "f");
+    }
+    /**
+     * @internal
+     */
+    get compensateInput() {
+        return __classPrivateFieldGet(this, _StepResponse_compensateInput, "f");
+    }
+    /**
+     * @internal
+     */
+    toJSON() {
+        return {
+            __type: __classPrivateFieldGet(this, _StepResponse___type, "f"),
+            output: __classPrivateFieldGet(this, _StepResponse_output, "f"),
+            compensateInput: __classPrivateFieldGet(this, _StepResponse_compensateInput, "f"),
+        };
+    }
+}
+exports.StepResponse = StepResponse;
+_StepResponse___type = new WeakMap(), _StepResponse_output = new WeakMap(), _StepResponse_compensateInput = new WeakMap();
+//# sourceMappingURL=step-response.js.map

package/dist/utils/composer/helpers/step-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-response.js","sourceRoot":"","sources":["../../../../src/utils/composer/helpers/step-response.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,qCAAqD;AAErD;;;;;;;GAOG;AACH,MAAa,YAAY;IAKvB;;;;;;;OAOG;IACH;IACE;;OAEG;IACH,MAAe;IACf;;OAEG;IACH,eAAkC;QApB3B,+BAAU,mCAA0B,EAAA;QACpC,uCAAgB;QAChB,gDAAmC;QAoB1C,uBAAA,IAAI,wBAAW,MAAM,MAAA,CAAA;QACrB,uBAAA,IAAI,iCAAoB,CAAC,eAAe,IAAI,MAAM,CAAqB,MAAA,CAAA;IACzE,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACR,OAAO,uBAAA,IAAI,4BAAQ,CAAA;IACrB,CAAC;IAED;;OAEG;IACH,IAAI,MAAM;QACR,OAAO,uBAAA,IAAI,4BAAQ,CAAA;IACrB,CAAC;IAED;;OAEG;IACH,IAAI,eAAe;QACjB,OAAO,uBAAA,IAAI,qCAAqC,CAAA;IAClD,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO;YACL,MAAM,EAAE,uBAAA,IAAI,4BAAQ;YACpB,MAAM,EAAE,uBAAA,IAAI,4BAAQ;YACpB,eAAe,EAAE,uBAAA,IAAI,qCAAiB;SACvC,CAAA;IACH,CAAC;CACF;AA1DD,oCA0DC"}

package/dist/utils/composer/helpers/symbol.d.ts

@@ -0,0 +1,8 @@
+export declare const SymbolMedusaWorkflowComposerContext: unique symbol;
+export declare const SymbolInputReference: unique symbol;
+export declare const SymbolWorkflowStep: unique symbol;
+export declare const SymbolWorkflowHook: unique symbol;
+export declare const SymbolWorkflowWorkflowData: unique symbol;
+export declare const SymbolWorkflowStepResponse: unique symbol;
+export declare const SymbolWorkflowStepBind: unique symbol;
+export declare const SymbolWorkflowStepTransformer: unique symbol;

package/dist/utils/composer/helpers/symbol.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SymbolWorkflowStepTransformer = exports.SymbolWorkflowStepBind = exports.SymbolWorkflowStepResponse = exports.SymbolWorkflowWorkflowData = exports.SymbolWorkflowHook = exports.SymbolWorkflowStep = exports.SymbolInputReference = exports.SymbolMedusaWorkflowComposerContext = void 0;
+exports.SymbolMedusaWorkflowComposerContext = Symbol.for("MedusaWorkflowComposerContext");
+exports.SymbolInputReference = Symbol.for("WorkflowInputReference");
+exports.SymbolWorkflowStep = Symbol.for("WorkflowStep");
+exports.SymbolWorkflowHook = Symbol.for("WorkflowHook");
+exports.SymbolWorkflowWorkflowData = Symbol.for("WorkflowWorkflowData");
+exports.SymbolWorkflowStepResponse = Symbol.for("WorkflowStepResponse");
+exports.SymbolWorkflowStepBind = Symbol.for("WorkflowStepBind");
+exports.SymbolWorkflowStepTransformer = Symbol.for("WorkflowStepTransformer");
+//# sourceMappingURL=symbol.js.map

package/dist/utils/composer/helpers/symbol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol.js","sourceRoot":"","sources":["../../../../src/utils/composer/helpers/symbol.ts"],"names":[],"mappings":";;;AAAa,QAAA,mCAAmC,GAAG,MAAM,CAAC,GAAG,CAC3D,+BAA+B,CAChC,CAAA;AACY,QAAA,oBAAoB,GAAG,MAAM,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAA;AAC3D,QAAA,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;AAC/C,QAAA,kBAAkB,GAAG,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;AAC/C,QAAA,0BAA0B,GAAG,MAAM,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAA;AAC/D,QAAA,0BAA0B,GAAG,MAAM,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAA;AAC/D,QAAA,sBAAsB,GAAG,MAAM,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAA;AACvD,QAAA,6BAA6B,GAAG,MAAM,CAAC,GAAG,CACrD,yBAAyB,CAC1B,CAAA"}

package/dist/utils/composer/hook.d.ts

@@ -0,0 +1,94 @@
+import { WorkflowData } from "./type";
+/**
+ *
+ * @ignore
+ *
+ * This function allows you to add hooks in your workflow that provide access to some data. Then, consumers of that workflow can add a handler function that performs
+ * an action with the provided data or modify it.
+ *
+ * For example, in a "create product" workflow, you may add a hook after the product is created, providing access to the created product.
+ * Then, developers using that workflow can hook into that point to access the product, modify its attributes, then return the updated product.
+ *
+ * @typeParam TOutput - The expected output of the hook's handler function.
+ * @returns The output of handler functions of this hook. If there are no handler functions, the output is `undefined`.
+ *
+ * @example
+ * import {
+ *   createWorkflow,
+ *   StepExecutionContext,
+ *   hook,
+ *   transform
+ * } from "@medusajs/workflows-sdk"
+ * import {
+ *   createProductStep,
+ *   getProductStep,
+ *   createPricesStep
+ * } from "./steps"
+ * import {
+ *   MedusaRequest,
+ *   MedusaResponse,
+ *   Product, ProductService
+ * } from "@medusajs/medusa"
+ *
+ * interface WorkflowInput {
+ *  title: string
+ * }
+ *
+ * const myWorkflow = createWorkflow<
+ *   WorkflowInput,
+ *   Product
+ * >("my-workflow",
+ *   function (input) {
+ *     const product = createProductStep(input)
+ *
+ *     const hookProduct = hook<Product>("createdProductHook", product)
+ *
+ *     const newProduct = transform({
+ *       product,
+ *       hookProduct
+ *     }, (input) => {
+ *       return input.hookProduct || input.product
+ *     })
+ *
+ *     const prices = createPricesStep(newProduct)
+ *
+ *     return getProductStep(product.id)
+ *   }
+ * )
+ *
+ * myWorkflow.createdProductHook(
+ *   async (product, context: StepExecutionContext) => {
+ *     const productService: ProductService = context.container.resolve("productService")
+ *
+ *     const updatedProduct = await productService.update(product.id, {
+ *       description: "a cool shirt"
+ *     })
+ *
+ *     return updatedProduct
+ * })
+ *
+ * export async function POST(
+ *   req: MedusaRequest,
+ *   res: MedusaResponse
+ * ) {
+ *   const { result: product } = await myWorkflow(req.scope)
+ *   .run({
+ *     input: {
+ *       title: req.body.title
+ *     }
+ *   })
+ *
+ *   res.json({
+ *     product
+ *   })
+ * }
+ */
+export declare function hook<TOutput>(
+/**
+ * The name of the hook. This will be used by the consumer to add a handler method for the hook.
+ */
+name: string, 
+/**
+ * The data that a handler function receives as a parameter.
+ */
+value: any): WorkflowData<TOutput>;