@medusajs/workflows-sdk 0.2.0-next-20231124140416

package/dist/utils/composer/hook.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hook = void 0;
+const helpers_1 = require("./helpers");
+/**
+ *
+ * @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
+ *   })
+ * }
+ */
+function hook(
+/**
+ * The name of the hook. This will be used by the consumer to add a handler method for the hook.
+ */
+name, 
+/**
+ * The data that a handler function receives as a parameter.
+ */
+value) {
+    const hookBinder = global[helpers_1.SymbolMedusaWorkflowComposerContext].hookBinder;
+    return hookBinder(name, function (context) {
+        return {
+            __value: async function (transactionContext) {
+                const executionContext = {
+                    container: transactionContext.container,
+                    metadata: transactionContext.metadata,
+                    context: transactionContext.context,
+                };
+                const allValues = await (0, helpers_1.resolveValue)(value, transactionContext);
+                const stepValue = allValues
+                    ? JSON.parse(JSON.stringify(allValues))
+                    : allValues;
+                let finalResult;
+                const functions = context.hooksCallback_[name];
+                for (let i = 0; i < functions.length; i++) {
+                    const fn = functions[i];
+                    const arg = i === 0 ? stepValue : finalResult;
+                    finalResult = await fn.apply(fn, [arg, executionContext]);
+                }
+                return finalResult;
+            },
+            __type: helpers_1.SymbolWorkflowHook,
+        };
+    });
+}
+exports.hook = hook;
+//# sourceMappingURL=hook.js.map

package/dist/utils/composer/hook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.js","sourceRoot":"","sources":["../../../src/utils/composer/hook.ts"],"names":[],"mappings":";;;AAAA,uCAIkB;AAOlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG;AACH,SAAgB,IAAI;AAClB;;GAEG;AACH,IAAY;AACZ;;GAEG;AACH,KAAU;IAEV,MAAM,UAAU,GACd,MAAM,CAAC,6CAAmC,CAC3C,CAAC,UAAU,CAAA;IAEZ,OAAO,UAAU,CAAC,IAAI,EAAE,UAAU,OAAO;QACvC,OAAO;YACL,OAAO,EAAE,KAAK,WAAW,kBAAkB;gBACzC,MAAM,gBAAgB,GAAyB;oBAC7C,SAAS,EAAE,kBAAkB,CAAC,SAAS;oBACvC,QAAQ,EAAE,kBAAkB,CAAC,QAAQ;oBACrC,OAAO,EAAE,kBAAkB,CAAC,OAAO;iBACpC,CAAA;gBAED,MAAM,SAAS,GAAG,MAAM,IAAA,sBAAY,EAAC,KAAK,EAAE,kBAAkB,CAAC,CAAA;gBAC/D,MAAM,SAAS,GAAG,SAAS;oBACzB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;oBACvC,CAAC,CAAC,SAAS,CAAA;gBAEb,IAAI,WAAW,CAAA;gBACf,MAAM,SAAS,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAA;gBAC9C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;oBACzC,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;oBACvB,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAA;oBAC7C,WAAW,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC,CAAA;iBAC1D;gBACD,OAAO,WAAW,CAAA;YACpB,CAAC;YACD,MAAM,EAAE,4BAAkB;SAC3B,CAAA;IACH,CAAC,CAAC,CAAA;AACJ,CAAC;AAxCD,oBAwCC"}

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

@@ -0,0 +1,9 @@
+export * from "./create-step";
+export * from "./create-workflow";
+export * from "./hook";
+export * from "./parallelize";
+export * from "./helpers/resolve-value";
+export * from "./helpers/symbol";
+export * from "./helpers/step-response";
+export * from "./transform";
+export * from "./type";

package/dist/utils/composer/index.js

@@ -0,0 +1,26 @@
+"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("./create-step"), exports);
+__exportStar(require("./create-workflow"), exports);
+__exportStar(require("./hook"), exports);
+__exportStar(require("./parallelize"), exports);
+__exportStar(require("./helpers/resolve-value"), exports);
+__exportStar(require("./helpers/symbol"), exports);
+__exportStar(require("./helpers/step-response"), exports);
+__exportStar(require("./transform"), exports);
+__exportStar(require("./type"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/composer/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gDAA6B;AAC7B,oDAAiC;AACjC,yCAAsB;AACtB,gDAA6B;AAC7B,0DAAuC;AACvC,mDAAgC;AAChC,0DAAuC;AACvC,8CAA2B;AAC3B,yCAAsB"}

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

@@ -0,0 +1,42 @@
+import { WorkflowData } from "./type";
+/**
+ * This function is used to run multiple steps in parallel. The result of each step will be returned as part of the result array.
+ *
+ * @typeParam TResult - The type of the expected result.
+ *
+ * @returns The step results. The results are ordered in the array by the order they're passed in the function's parameter.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   createWorkflow,
+ *   parallelize
+ * } from "@medusajs/workflows-sdk"
+ * import {
+ *   createProductStep,
+ *   getProductStep,
+ *   createPricesStep,
+ *   attachProductToSalesChannelStep
+ * } from "./steps"
+ *
+ * interface WorkflowInput {
+ *   title: string
+ * }
+ *
+ * const myWorkflow = createWorkflow<
+ *   WorkflowInput,
+ *   Product
+ * >("my-workflow", (input) => {
+ *    const product = createProductStep(input)
+ *
+ *    const [prices, productSalesChannel] = parallelize(
+ *      createPricesStep(product),
+ *      attachProductToSalesChannelStep(product)
+ *    )
+ *
+ *    const id = product.id
+ *    return getProductStep(product.id)
+ *  }
+ * )
+ */
+export declare function parallelize<TResult extends WorkflowData[]>(...steps: TResult): TResult;

package/dist/utils/composer/parallelize.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parallelize = void 0;
+const helpers_1 = require("./helpers");
+/**
+ * This function is used to run multiple steps in parallel. The result of each step will be returned as part of the result array.
+ *
+ * @typeParam TResult - The type of the expected result.
+ *
+ * @returns The step results. The results are ordered in the array by the order they're passed in the function's parameter.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   createWorkflow,
+ *   parallelize
+ * } from "@medusajs/workflows-sdk"
+ * import {
+ *   createProductStep,
+ *   getProductStep,
+ *   createPricesStep,
+ *   attachProductToSalesChannelStep
+ * } from "./steps"
+ *
+ * interface WorkflowInput {
+ *   title: string
+ * }
+ *
+ * const myWorkflow = createWorkflow<
+ *   WorkflowInput,
+ *   Product
+ * >("my-workflow", (input) => {
+ *    const product = createProductStep(input)
+ *
+ *    const [prices, productSalesChannel] = parallelize(
+ *      createPricesStep(product),
+ *      attachProductToSalesChannelStep(product)
+ *    )
+ *
+ *    const id = product.id
+ *    return getProductStep(product.id)
+ *  }
+ * )
+ */
+function parallelize(...steps) {
+    if (!global[helpers_1.SymbolMedusaWorkflowComposerContext]) {
+        throw new Error("parallelize must be used inside a createWorkflow definition");
+    }
+    const parallelizeBinder = global[helpers_1.SymbolMedusaWorkflowComposerContext].parallelizeBinder;
+    const resultSteps = steps.map((step) => step);
+    return parallelizeBinder(function () {
+        const stepOntoMerge = steps.shift();
+        this.flow.mergeActions(stepOntoMerge.__step__, ...steps.map((step) => step.__step__));
+        return resultSteps;
+    });
+}
+exports.parallelize = parallelize;
+//# sourceMappingURL=parallelize.js.map

package/dist/utils/composer/parallelize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelize.js","sourceRoot":"","sources":["../../../src/utils/composer/parallelize.ts"],"names":[],"mappings":";;;AACA,uCAA+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,SAAgB,WAAW,CACzB,GAAG,KAAc;IAEjB,IAAI,CAAC,MAAM,CAAC,6CAAmC,CAAC,EAAE;QAChD,MAAM,IAAI,KAAK,CACb,6DAA6D,CAC9D,CAAA;KACF;IAED,MAAM,iBAAiB,GACrB,MAAM,CAAC,6CAAmC,CAC3C,CAAC,iBAAiB,CAAA;IAEnB,MAAM,WAAW,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,CAAA;IAE7C,OAAO,iBAAiB,CAAU;QAGhC,MAAM,aAAa,GAAG,KAAK,CAAC,KAAK,EAAG,CAAA;QACpC,IAAI,CAAC,IAAI,CAAC,YAAY,CACpB,aAAa,CAAC,QAAQ,EACtB,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CACtC,CAAA;QAED,OAAO,WAAiC,CAAA;IAC1C,CAAC,CAAC,CAAA;AACJ,CAAC;AA1BD,kCA0BC"}

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

@@ -0,0 +1,83 @@
+import { StepExecutionContext, WorkflowData } from "./type";
+type Func1<T extends object | WorkflowData, U> = (input: T extends WorkflowData<infer U> ? U : T extends object ? {
+    [K in keyof T]: T[K] extends WorkflowData<infer U> ? U : T[K];
+} : {}, context: StepExecutionContext) => U | Promise<U>;
+type Func<T, U> = (input: T, context: StepExecutionContext) => U | Promise<U>;
+/**
+ *
+ * This function transforms the output of other utility functions.
+ *
+ * For example, if you're using the value(s) of some step(s) as an input to a later step. As you can't directly manipulate data in the  workflow constructor function passed to {@link createWorkflow},
+ * the `transform` function provides access to the runtime value of the step(s) output so that you can manipulate them.
+ *
+ * Another example is if you're using the runtime value of some step(s) as the output of a workflow.
+ *
+ * If you're also retrieving the output of a hook and want to check if its value is set, you must use a workflow to get the runtime value of that hook.
+ *
+ * @returns There's no expected value to be returned by the `transform` function.
+ *
+ * @example
+ * import {
+ *   createWorkflow,
+ *   transform
+ * } from "@medusajs/workflows-sdk"
+ * import { step1, step2 } from "./steps"
+ *
+ * type WorkflowInput = {
+ *   name: string
+ * }
+ *
+ * type WorkflowOutput = {
+ *   message: string
+ * }
+ *
+ * const myWorkflow = createWorkflow<
+ *     WorkflowInput,
+ *     WorkflowOutput
+ *   >
+ *   ("hello-world", (input) => {
+ *     const str1 = step1(input)
+ *     const str2 = step2(input)
+ *
+ *     return transform({
+ *       str1,
+ *       str2
+ *     }, (input) => ({
+ *       message: `${input.str1}${input.str2}`
+ *     }))
+ * })
+ */
+export declare function transform<T extends object | WorkflowData, RFinal>(
+/**
+ * The output(s) of other step functions.
+ */
+values: T, 
+/**
+ * The transform function used to perform action on the runtime values of the provided `values`.
+ */
+...func: [Func1<T, RFinal>]): WorkflowData<RFinal>;
+/**
+ * @internal
+ */
+export declare function transform<T extends object | WorkflowData, RA, RFinal>(values: T, ...func: [Func1<T, RFinal>] | [Func1<T, RA>, Func<RA, RFinal>]): WorkflowData<RFinal>;
+/**
+ * @internal
+ */
+export declare function transform<T extends object | WorkflowData, RA, RB, RFinal>(values: T, ...func: [Func1<T, RFinal>] | [Func1<T, RA>, Func<RA, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RFinal>]): WorkflowData<RFinal>;
+/**
+ * @internal
+ */
+export declare function transform<T extends object | WorkflowData, RA, RB, RC, RFinal>(values: T, ...func: [Func1<T, RFinal>] | [Func1<T, RA>, Func<RA, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RFinal>]): WorkflowData<RFinal>;
+/**
+ * @internal
+ */
+export declare function transform<T extends object | WorkflowData, RA, RB, RC, RD, RFinal>(values: T, ...func: [Func1<T, RFinal>] | [Func1<T, RA>, Func<RA, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RD>, Func<RD, RFinal>]): WorkflowData<RFinal>;
+/**
+ * @internal
+ */
+export declare function transform<T extends object | WorkflowData, RA, RB, RC, RD, RE, RFinal>(values: T, ...func: [Func1<T, RFinal>] | [Func1<T, RA>, Func<RA, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RD>, Func<RD, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RD>, Func<RD, RE>, Func<RE, RFinal>]): WorkflowData<RFinal>;
+/**
+ * @internal
+ */
+export declare function transform<T extends object | WorkflowData, RA, RB, RC, RD, RE, RF, RFinal>(values: T, ...func: [Func1<T, RFinal>] | [Func1<T, RA>, Func<RA, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RD>, Func<RD, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RD>, Func<RD, RE>, Func<RE, RFinal>] | [Func1<T, RA>, Func<RA, RB>, Func<RB, RC>, Func<RC, RD>, Func<RD, RE>, Func<RE, RF>, Func<RF, RFinal>]): WorkflowData<RFinal>;
+export {};

package/dist/utils/composer/transform.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = void 0;
+const helpers_1 = require("./helpers");
+const proxy_1 = require("./helpers/proxy");
+function transform(values, ...functions) {
+    const ret = {
+        __type: helpers_1.SymbolWorkflowStepTransformer,
+        __resolver: undefined,
+    };
+    const returnFn = async function (transactionContext) {
+        const allValues = await (0, helpers_1.resolveValue)(values, transactionContext);
+        const stepValue = allValues
+            ? JSON.parse(JSON.stringify(allValues))
+            : allValues;
+        let finalResult;
+        for (let i = 0; i < functions.length; i++) {
+            const fn = functions[i];
+            const arg = i === 0 ? stepValue : finalResult;
+            finalResult = await fn.apply(fn, [arg, transactionContext]);
+        }
+        return finalResult;
+    };
+    const proxyfiedRet = (0, proxy_1.proxify)(ret);
+    proxyfiedRet.__resolver = returnFn;
+    return proxyfiedRet;
+}
+exports.transform = transform;
+//# sourceMappingURL=transform.js.map

package/dist/utils/composer/transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../../src/utils/composer/transform.ts"],"names":[],"mappings":";;;AAAA,uCAAuE;AAEvE,2CAAyC;AA8JzC,SAAgB,SAAS,CACvB,MAAmB,EACnB,GAAG,SAAqB;IAExB,MAAM,GAAG,GAAG;QACV,MAAM,EAAE,uCAA6B;QACrC,UAAU,EAAE,SAAS;KACtB,CAAA;IAED,MAAM,QAAQ,GAAG,KAAK,WAAW,kBAAkB;QACjD,MAAM,SAAS,GAAG,MAAM,IAAA,sBAAY,EAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;QAChE,MAAM,SAAS,GAAG,SAAS;YACzB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;YACvC,CAAC,CAAC,SAAS,CAAA;QAEb,IAAI,WAAW,CAAA;QACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACzC,MAAM,EAAE,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;YACvB,MAAM,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAA;YAE7C,WAAW,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC,CAAA;SAC5D;QAED,OAAO,WAAW,CAAA;IACpB,CAAC,CAAA;IAED,MAAM,YAAY,GAAG,IAAA,eAAO,EAC1B,GAA8B,CAC/B,CAAA;IACD,YAAY,CAAC,UAAU,GAAG,QAAe,CAAA;IAEzC,OAAO,YAAY,CAAA;AACrB,CAAC;AAhCD,8BAgCC"}

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

@@ -0,0 +1,70 @@
+import { OrchestratorBuilder, TransactionContext as OriginalWorkflowTransactionContext, TransactionPayload, WorkflowHandler } from "@medusajs/orchestration";
+import { Context, MedusaContainer } from "@medusajs/types";
+export type StepFunctionResult<TOutput extends unknown | unknown[] = unknown> = (this: CreateWorkflowComposerContext) => TOutput extends [] ? [
+    ...WorkflowData<{
+        [K in keyof TOutput]: TOutput[number][K];
+    }>[]
+] : WorkflowData<{
+    [K in keyof TOutput]: TOutput[K];
+}>;
+/**
+ * A step function to be used in a workflow.
+ *
+ * @typeParam TInput - The type of the input of the step.
+ * @typeParam TOutput - The type of the output of the step.
+ */
+export type StepFunction<TInput extends object = object, TOutput = unknown> = {
+    (input: {
+        [K in keyof TInput]: WorkflowData<TInput[K]>;
+    }): WorkflowData<{
+        [K in keyof TOutput]: TOutput[K];
+    }>;
+} & WorkflowDataProperties<{
+    [K in keyof TOutput]: TOutput[K];
+}>;
+export type WorkflowDataProperties<T = unknown> = {
+    __type: Symbol;
+    __step__: string;
+};
+/**
+ * This type is used to encapsulate the input or output type of all utils.
+ *
+ * @typeParam T - The type of a step's input or result.
+ */
+export type WorkflowData<T = unknown> = (T extends object ? {
+    [Key in keyof T]: WorkflowData<T[Key]>;
+} : WorkflowDataProperties<T>) & WorkflowDataProperties<T>;
+export type CreateWorkflowComposerContext = {
+    hooks_: string[];
+    hooksCallback_: Record<string, Function[]>;
+    workflowId: string;
+    flow: OrchestratorBuilder;
+    handlers: WorkflowHandler;
+    stepBinder: <TOutput = unknown>(fn: StepFunctionResult) => WorkflowData<TOutput>;
+    hookBinder: <TOutput = unknown>(name: string, fn: Function) => WorkflowData<TOutput>;
+    parallelizeBinder: <TOutput extends WorkflowData[] = WorkflowData[]>(fn: (this: CreateWorkflowComposerContext) => TOutput) => TOutput;
+};
+/**
+ * The step's context.
+ */
+export interface StepExecutionContext {
+    /**
+     * The container used to access resources, such as services, in the step.
+     */
+    container: MedusaContainer;
+    /**
+     * Metadata passed in the input.
+     */
+    metadata: TransactionPayload["metadata"];
+    /**
+     * {@inheritDoc Context}
+     */
+    context: Context;
+}
+export type WorkflowTransactionContext = StepExecutionContext & OriginalWorkflowTransactionContext & {
+    invoke: {
+        [key: string]: {
+            output: any;
+        };
+    };
+};

package/dist/utils/composer/type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=type.js.map

package/dist/utils/composer/type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.js","sourceRoot":"","sources":["../../../src/utils/composer/type.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@medusajs/workflows-sdk",
+  "version": "0.2.0-next-20231124140416",
+  "description": "Set of workflows tooling for Medusa",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/medusajs/medusa",
+    "directory": "packages/workflows"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "Medusa",
+  "license": "MIT",
+  "devDependencies": {
+    "@medusajs/types": "1.11.8-next-20231124140416",
+    "cross-env": "^5.2.1",
+    "jest": "^29.6.3",
+    "rimraf": "^5.0.1",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@medusajs/modules-sdk": "1.12.4-next-20231124140416",
+    "@medusajs/orchestration": "0.5.0-next-20231124140416",
+    "@medusajs/utils": "1.11.1-next-20231124140416",
+    "awilix": "^8.0.1",
+    "ulid": "^2.3.0"
+  },
+  "scripts": {
+    "prepublishOnly": "cross-env NODE_ENV=production tsc --build",
+    "build": "rimraf dist && tsc --build",
+    "watch": "tsc --build --watch",
+    "test": "jest --runInBand --bail --forceExit"
+  }
+}