@medusajs/workflow-engine-inmemory 0.0.2-next-20240124093206

package/dist/services/index.js

@@ -0,0 +1,19 @@
+"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("./workflow-execution"), exports);
+__exportStar(require("./workflow-orchestrator"), exports);
+__exportStar(require("./workflows-module"), exports);

package/dist/services/workflow-execution.d.ts

@@ -0,0 +1,16 @@
+import { DAL } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
+import { WorkflowExecution } from "../models";
+type InjectedDependencies = {
+    workflowExecutionRepository: DAL.RepositoryService;
+};
+declare const WorkflowExecutionService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {}, {
+    list?: any;
+    listAndCount?: any;
+}>;
+export declare class WorkflowExecutionService<TEntity extends WorkflowExecution = WorkflowExecution> extends WorkflowExecutionService_base<TEntity> {
+    protected workflowExecutionRepository_: DAL.RepositoryService<TEntity>;
+    constructor({ workflowExecutionRepository }: InjectedDependencies);
+}
+export {};
+//# sourceMappingURL=workflow-execution.d.ts.map

package/dist/services/workflow-execution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-execution.d.ts","sourceRoot":"","sources":["../../src/services/workflow-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAA;AACrC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAE3C,KAAK,oBAAoB,GAAG;IAC1B,2BAA2B,EAAE,GAAG,CAAC,iBAAiB,CAAA;CACnD,CAAA;;;;;AAED,qBAAa,wBAAwB,CACnC,OAAO,SAAS,iBAAiB,GAAG,iBAAiB,CACrD,SAAQ,8BAER,OAAO,CAAC;IACR,SAAS,CAAC,4BAA4B,EAAE,GAAG,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAA;gBAE1D,EAAE,2BAA2B,EAAE,EAAE,oBAAoB;CAKlE"}

package/dist/services/workflow-execution.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowExecutionService = void 0;
+const utils_1 = require("@medusajs/utils");
+const _models_1 = require("../models");
+class WorkflowExecutionService extends utils_1.ModulesSdkUtils.abstractServiceFactory(_models_1.WorkflowExecution) {
+    constructor({ workflowExecutionRepository }) {
+        // @ts-ignore
+        super(...arguments);
+        this.workflowExecutionRepository_ = workflowExecutionRepository;
+    }
+}
+exports.WorkflowExecutionService = WorkflowExecutionService;

package/dist/services/workflow-orchestrator.d.ts

@@ -0,0 +1,66 @@
+import { DistributedTransaction, DistributedTransactionEvents, TransactionStep } from "@medusajs/orchestration";
+import { ContainerLike, Context } from "@medusajs/types";
+import { type FlowRunOptions, ReturnWorkflow } from "@medusajs/workflows-sdk";
+import { InMemoryDistributedTransactionStorage } from "../utils";
+export type WorkflowOrchestratorRunOptions<T> = FlowRunOptions<T> & {
+    transactionId?: string;
+    container?: ContainerLike;
+};
+type RegisterStepSuccessOptions<T> = Omit<WorkflowOrchestratorRunOptions<T>, "transactionId" | "input">;
+type IdempotencyKeyParts = {
+    workflowId: string;
+    transactionId: string;
+    stepId: string;
+    action: "invoke" | "compensate";
+};
+type NotifyOptions = {
+    eventType: keyof DistributedTransactionEvents;
+    workflowId: string;
+    transactionId?: string;
+    step?: TransactionStep;
+    response?: unknown;
+    result?: unknown;
+    errors?: unknown[];
+};
+type SubscriberHandler = {
+    (input: NotifyOptions): void;
+} & {
+    _id?: string;
+};
+type SubscribeOptions = {
+    workflowId: string;
+    transactionId?: string;
+    subscriber: SubscriberHandler;
+    subscriberId?: string;
+};
+type UnsubscribeOptions = {
+    workflowId: string;
+    transactionId?: string;
+    subscriberOrId: string | SubscriberHandler;
+};
+export declare class WorkflowOrchestratorService {
+    private subscribers;
+    constructor({ inMemoryDistributedTransactionStorage, }: {
+        inMemoryDistributedTransactionStorage: InMemoryDistributedTransactionStorage;
+        workflowOrchestratorService: WorkflowOrchestratorService;
+    });
+    run<T = unknown>(workflowIdOrWorkflow: string | ReturnWorkflow<any, any, any>, options?: WorkflowOrchestratorRunOptions<T>, sharedContext?: Context): Promise<any>;
+    getRunningTransaction(workflowId: string, transactionId: string, options?: WorkflowOrchestratorRunOptions<undefined>, sharedContext?: Context): Promise<DistributedTransaction>;
+    setStepSuccess<T = unknown>({ idempotencyKey, stepResponse, options, }: {
+        idempotencyKey: string | IdempotencyKeyParts;
+        stepResponse: unknown;
+        options?: RegisterStepSuccessOptions<T>;
+    }, sharedContext?: Context): Promise<any>;
+    setStepFailure<T = unknown>({ idempotencyKey, stepResponse, options, }: {
+        idempotencyKey: string | IdempotencyKeyParts;
+        stepResponse: unknown;
+        options?: RegisterStepSuccessOptions<T>;
+    }, sharedContext?: Context): Promise<any>;
+    subscribe({ workflowId, transactionId, subscriber, subscriberId }: SubscribeOptions, sharedContext?: Context): void;
+    unsubscribe({ workflowId, transactionId, subscriberOrId }: UnsubscribeOptions, sharedContext?: Context): void;
+    private notify;
+    private buildWorkflowEvents;
+    private buildIdempotencyKeyAndParts;
+}
+export {};
+//# sourceMappingURL=workflow-orchestrator.d.ts.map

package/dist/services/workflow-orchestrator.d.ts.map

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

package/dist/services/workflow-orchestrator.js

@@ -0,0 +1,352 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowOrchestratorService = void 0;
+const orchestration_1 = require("@medusajs/orchestration");
+const utils_1 = require("@medusajs/utils");
+const workflows_sdk_1 = require("@medusajs/workflows-sdk");
+const ulid_1 = require("ulid");
+const AnySubscriber = "any";
+class WorkflowOrchestratorService {
+    constructor({ inMemoryDistributedTransactionStorage, }) {
+        this.subscribers = new Map();
+        inMemoryDistributedTransactionStorage.setWorkflowOrchestratorService(this);
+        orchestration_1.DistributedTransaction.setStorage(inMemoryDistributedTransactionStorage);
+    }
+    async run(workflowIdOrWorkflow, options, sharedContext = {}) {
+        let { input, context, transactionId, resultFrom, throwOnError, events: eventHandlers, container, } = options ?? {};
+        const workflowId = (0, utils_1.isString)(workflowIdOrWorkflow)
+            ? workflowIdOrWorkflow
+            : workflowIdOrWorkflow.getName();
+        if (!workflowId) {
+            throw new Error("Workflow ID is required");
+        }
+        context ?? (context = {});
+        context.transactionId ?? (context.transactionId = transactionId ?? (0, ulid_1.ulid)());
+        const events = this.buildWorkflowEvents({
+            customEventHandlers: eventHandlers,
+            workflowId,
+            transactionId: context.transactionId,
+        });
+        const exportedWorkflow = workflows_sdk_1.MedusaWorkflow.getWorkflow(workflowId);
+        if (!exportedWorkflow) {
+            throw new Error(`Workflow with id "${workflowId}" not found.`);
+        }
+        const flow = exportedWorkflow(container);
+        const ret = await flow.run({
+            input,
+            throwOnError,
+            resultFrom,
+            context,
+            events,
+        });
+        // TODO: temporary
+        const acknowledgement = {
+            transactionId: context.transactionId,
+            workflowId: workflowId,
+        };
+        if (ret.transaction.hasFinished()) {
+            const { result, errors } = ret;
+            this.notify({
+                eventType: "onFinish",
+                workflowId,
+                transactionId: context.transactionId,
+                result,
+                errors,
+            });
+        }
+        return { acknowledgement, ...ret };
+    }
+    async getRunningTransaction(workflowId, transactionId, options, sharedContext = {}) {
+        let { context, container } = options ?? {};
+        if (!workflowId) {
+            throw new Error("Workflow ID is required");
+        }
+        if (!transactionId) {
+            throw new Error("TransactionId ID is required");
+        }
+        context ?? (context = {});
+        context.transactionId ?? (context.transactionId = transactionId);
+        const exportedWorkflow = workflows_sdk_1.MedusaWorkflow.getWorkflow(workflowId);
+        if (!exportedWorkflow) {
+            throw new Error(`Workflow with id "${workflowId}" not found.`);
+        }
+        const flow = exportedWorkflow(container);
+        const transaction = await flow.getRunningTransaction(transactionId, context);
+        return transaction;
+    }
+    async setStepSuccess({ idempotencyKey, stepResponse, options, }, sharedContext = {}) {
+        const { context, throwOnError, resultFrom, container, events: eventHandlers, } = options ?? {};
+        const [idempotencyKey_, { workflowId, transactionId }] = this.buildIdempotencyKeyAndParts(idempotencyKey);
+        const exportedWorkflow = workflows_sdk_1.MedusaWorkflow.getWorkflow(workflowId);
+        if (!exportedWorkflow) {
+            throw new Error(`Workflow with id "${workflowId}" not found.`);
+        }
+        const flow = exportedWorkflow(container);
+        const events = this.buildWorkflowEvents({
+            customEventHandlers: eventHandlers,
+            transactionId,
+            workflowId,
+        });
+        const ret = await flow.registerStepSuccess({
+            idempotencyKey: idempotencyKey_,
+            context,
+            resultFrom,
+            throwOnError,
+            events,
+            response: stepResponse,
+        });
+        if (ret.transaction.hasFinished()) {
+            const { result, errors } = ret;
+            this.notify({
+                eventType: "onFinish",
+                workflowId,
+                transactionId,
+                result,
+                errors,
+            });
+        }
+        return ret;
+    }
+    async setStepFailure({ idempotencyKey, stepResponse, options, }, sharedContext = {}) {
+        const { context, throwOnError, resultFrom, container, events: eventHandlers, } = options ?? {};
+        const [idempotencyKey_, { workflowId, transactionId }] = this.buildIdempotencyKeyAndParts(idempotencyKey);
+        const exportedWorkflow = workflows_sdk_1.MedusaWorkflow.getWorkflow(workflowId);
+        if (!exportedWorkflow) {
+            throw new Error(`Workflow with id "${workflowId}" not found.`);
+        }
+        const flow = exportedWorkflow(container);
+        const events = this.buildWorkflowEvents({
+            customEventHandlers: eventHandlers,
+            transactionId,
+            workflowId,
+        });
+        const ret = await flow.registerStepFailure({
+            idempotencyKey: idempotencyKey_,
+            context,
+            resultFrom,
+            throwOnError,
+            events,
+            response: stepResponse,
+        });
+        if (ret.transaction.hasFinished()) {
+            const { result, errors } = ret;
+            this.notify({
+                eventType: "onFinish",
+                workflowId,
+                transactionId,
+                result,
+                errors,
+            });
+        }
+        return ret;
+    }
+    subscribe({ workflowId, transactionId, subscriber, subscriberId }, sharedContext = {}) {
+        subscriber._id = subscriberId;
+        const subscribers = this.subscribers.get(workflowId) ?? new Map();
+        const handlerIndex = (handlers) => {
+            return handlers.indexOf((s) => s === subscriber || s._id === subscriberId);
+        };
+        if (transactionId) {
+            const transactionSubscribers = subscribers.get(transactionId) ?? [];
+            const subscriberIndex = handlerIndex(transactionSubscribers);
+            if (subscriberIndex !== -1) {
+                transactionSubscribers.slice(subscriberIndex, 1);
+            }
+            transactionSubscribers.push(subscriber);
+            subscribers.set(transactionId, transactionSubscribers);
+            this.subscribers.set(workflowId, subscribers);
+            return;
+        }
+        const workflowSubscribers = subscribers.get(AnySubscriber) ?? [];
+        const subscriberIndex = handlerIndex(workflowSubscribers);
+        if (subscriberIndex !== -1) {
+            workflowSubscribers.slice(subscriberIndex, 1);
+        }
+        workflowSubscribers.push(subscriber);
+        subscribers.set(AnySubscriber, workflowSubscribers);
+        this.subscribers.set(workflowId, subscribers);
+    }
+    unsubscribe({ workflowId, transactionId, subscriberOrId }, sharedContext = {}) {
+        const subscribers = this.subscribers.get(workflowId) ?? new Map();
+        const filterSubscribers = (handlers) => {
+            return handlers.filter((handler) => {
+                return handler._id
+                    ? handler._id !== subscriberOrId
+                    : handler !== subscriberOrId;
+            });
+        };
+        if (transactionId) {
+            const transactionSubscribers = subscribers.get(transactionId) ?? [];
+            const newTransactionSubscribers = filterSubscribers(transactionSubscribers);
+            subscribers.set(transactionId, newTransactionSubscribers);
+            this.subscribers.set(workflowId, subscribers);
+            return;
+        }
+        const workflowSubscribers = subscribers.get(AnySubscriber) ?? [];
+        const newWorkflowSubscribers = filterSubscribers(workflowSubscribers);
+        subscribers.set(AnySubscriber, newWorkflowSubscribers);
+        this.subscribers.set(workflowId, subscribers);
+    }
+    notify(options) {
+        const { eventType, workflowId, transactionId, errors, result, step, response, } = options;
+        const subscribers = this.subscribers.get(workflowId) ?? new Map();
+        const notifySubscribers = (handlers) => {
+            handlers.forEach((handler) => {
+                handler({
+                    eventType,
+                    workflowId,
+                    transactionId,
+                    step,
+                    response,
+                    result,
+                    errors,
+                });
+            });
+        };
+        if (transactionId) {
+            const transactionSubscribers = subscribers.get(transactionId) ?? [];
+            notifySubscribers(transactionSubscribers);
+        }
+        const workflowSubscribers = subscribers.get(AnySubscriber) ?? [];
+        notifySubscribers(workflowSubscribers);
+    }
+    buildWorkflowEvents({ customEventHandlers, workflowId, transactionId, }) {
+        const notify = ({ eventType, step, result, response, errors, }) => {
+            this.notify({
+                workflowId,
+                transactionId,
+                eventType,
+                response,
+                step,
+                result,
+                errors,
+            });
+        };
+        return {
+            onTimeout: ({ transaction }) => {
+                customEventHandlers?.onTimeout?.({ transaction });
+                notify({ eventType: "onTimeout" });
+            },
+            onBegin: ({ transaction }) => {
+                customEventHandlers?.onBegin?.({ transaction });
+                notify({ eventType: "onBegin" });
+            },
+            onResume: ({ transaction }) => {
+                customEventHandlers?.onResume?.({ transaction });
+                notify({ eventType: "onResume" });
+            },
+            onCompensateBegin: ({ transaction }) => {
+                customEventHandlers?.onCompensateBegin?.({ transaction });
+                notify({ eventType: "onCompensateBegin" });
+            },
+            onFinish: ({ transaction, result, errors }) => {
+                // TODO: unsubscribe transaction handlers on finish
+                customEventHandlers?.onFinish?.({ transaction, result, errors });
+            },
+            onStepBegin: ({ step, transaction }) => {
+                customEventHandlers?.onStepBegin?.({ step, transaction });
+                notify({ eventType: "onStepBegin", step });
+            },
+            onStepSuccess: ({ step, transaction }) => {
+                const response = transaction.getContext().invoke[step.id];
+                customEventHandlers?.onStepSuccess?.({ step, transaction, response });
+                notify({ eventType: "onStepSuccess", step, response });
+            },
+            onStepFailure: ({ step, transaction }) => {
+                const errors = transaction.getErrors(orchestration_1.TransactionHandlerType.INVOKE)[step.id];
+                customEventHandlers?.onStepFailure?.({ step, transaction, errors });
+                notify({ eventType: "onStepFailure", step, errors });
+            },
+            onCompensateStepSuccess: ({ step, transaction }) => {
+                const response = transaction.getContext().compensate[step.id];
+                customEventHandlers?.onStepSuccess?.({ step, transaction, response });
+                notify({ eventType: "onCompensateStepSuccess", step, response });
+            },
+            onCompensateStepFailure: ({ step, transaction }) => {
+                const errors = transaction.getErrors(orchestration_1.TransactionHandlerType.COMPENSATE)[step.id];
+                customEventHandlers?.onStepFailure?.({ step, transaction, errors });
+                notify({ eventType: "onCompensateStepFailure", step, errors });
+            },
+        };
+    }
+    buildIdempotencyKeyAndParts(idempotencyKey) {
+        const parts = {
+            workflowId: "",
+            transactionId: "",
+            stepId: "",
+            action: "invoke",
+        };
+        let idempotencyKey_ = idempotencyKey;
+        const setParts = (workflowId, transactionId, stepId, action) => {
+            parts.workflowId = workflowId;
+            parts.transactionId = transactionId;
+            parts.stepId = stepId;
+            parts.action = action;
+        };
+        if (!(0, utils_1.isString)(idempotencyKey)) {
+            const { workflowId, transactionId, stepId, action } = idempotencyKey;
+            idempotencyKey_ = [workflowId, transactionId, stepId, action].join(":");
+            setParts(workflowId, transactionId, stepId, action);
+        }
+        else {
+            const [workflowId, transactionId, stepId, action] = idempotencyKey_.split(":");
+            setParts(workflowId, transactionId, stepId, action);
+        }
+        return [idempotencyKey_, parts];
+    }
+}
+exports.WorkflowOrchestratorService = WorkflowOrchestratorService;
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowOrchestratorService.prototype, "run", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(3, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowOrchestratorService.prototype, "getRunningTransaction", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowOrchestratorService.prototype, "setStepSuccess", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowOrchestratorService.prototype, "setStepFailure", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], WorkflowOrchestratorService.prototype, "subscribe", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], WorkflowOrchestratorService.prototype, "unsubscribe", null);

package/dist/services/workflows-module.d.ts

@@ -0,0 +1,43 @@
+import { Context, DAL, FindConfig, InternalModuleDeclaration, ModuleJoinerConfig } from "@medusajs/types";
+import type { ReturnWorkflow, UnwrapWorkflowInputDataType, WorkflowOrchestratorTypes } from "@medusajs/workflows-sdk";
+import { WorkflowExecutionService, WorkflowOrchestratorService } from ".";
+type InjectedDependencies = {
+    baseRepository: DAL.RepositoryService;
+    workflowExecutionService: WorkflowExecutionService;
+    workflowOrchestratorService: WorkflowOrchestratorService;
+};
+export declare class WorkflowsModuleService implements WorkflowOrchestratorTypes.IWorkflowsModuleService {
+    protected readonly moduleDeclaration: InternalModuleDeclaration;
+    protected baseRepository_: DAL.RepositoryService;
+    protected workflowExecutionService_: WorkflowExecutionService;
+    protected workflowOrchestratorService_: WorkflowOrchestratorService;
+    constructor({ baseRepository, workflowExecutionService, workflowOrchestratorService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    __joinerConfig(): ModuleJoinerConfig;
+    listWorkflowExecution(filters?: WorkflowOrchestratorTypes.FilterableWorkflowExecutionProps, config?: FindConfig<WorkflowOrchestratorTypes.WorkflowExecutionDTO>, sharedContext?: Context): Promise<WorkflowOrchestratorTypes.WorkflowExecutionDTO[]>;
+    listAndCountWorkflowExecution(filters?: WorkflowOrchestratorTypes.FilterableWorkflowExecutionProps, config?: FindConfig<WorkflowOrchestratorTypes.WorkflowExecutionDTO>, sharedContext?: Context): Promise<[WorkflowOrchestratorTypes.WorkflowExecutionDTO[], number]>;
+    run<TWorkflow extends string | ReturnWorkflow<any, any, any>>(workflowIdOrWorkflow: TWorkflow, options?: WorkflowOrchestratorTypes.WorkflowOrchestratorRunDTO<TWorkflow extends ReturnWorkflow<any, any, any> ? UnwrapWorkflowInputDataType<TWorkflow> : unknown>, context?: Context): Promise<any>;
+    getRunningTransaction(workflowId: string, transactionId: string, context?: Context): Promise<import("@medusajs/orchestration").DistributedTransaction>;
+    setStepSuccess({ idempotencyKey, stepResponse, options, }: {
+        idempotencyKey: string | object;
+        stepResponse: unknown;
+        options?: Record<string, any>;
+    }, context?: Context): Promise<any>;
+    setStepFailure({ idempotencyKey, stepResponse, options, }: {
+        idempotencyKey: string | object;
+        stepResponse: unknown;
+        options?: Record<string, any>;
+    }, context?: Context): Promise<any>;
+    subscribe(args: {
+        workflowId: string;
+        transactionId?: string;
+        subscriber: Function;
+        subscriberId?: string;
+    }, context?: Context): Promise<void>;
+    unsubscribe(args: {
+        workflowId: string;
+        transactionId?: string;
+        subscriberOrId: string | Function;
+    }, context?: Context): Promise<void>;
+}
+export {};
+//# sourceMappingURL=workflows-module.d.ts.map

package/dist/services/workflows-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows-module.d.ts","sourceRoot":"","sources":["../../src/services/workflows-module.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,GAAG,EACH,UAAU,EACV,yBAAyB,EACzB,kBAAkB,EACnB,MAAM,iBAAiB,CAAA;AAOxB,OAAO,KAAK,EACV,cAAc,EACd,2BAA2B,EAC3B,yBAAyB,EAC1B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,wBAAwB,EACxB,2BAA2B,EAC5B,MAAM,WAAW,CAAA;AAGlB,KAAK,oBAAoB,GAAG;IAC1B,cAAc,EAAE,GAAG,CAAC,iBAAiB,CAAA;IACrC,wBAAwB,EAAE,wBAAwB,CAAA;IAClD,2BAA2B,EAAE,2BAA2B,CAAA;CACzD,CAAA;AAED,qBAAa,sBACX,YAAW,yBAAyB,CAAC,uBAAuB;IAY1D,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,yBAAyB;IAVjE,SAAS,CAAC,eAAe,EAAE,GAAG,CAAC,iBAAiB,CAAA;IAChD,SAAS,CAAC,yBAAyB,EAAE,wBAAwB,CAAA;IAC7D,SAAS,CAAC,4BAA4B,EAAE,2BAA2B,CAAA;gBAGjE,EACE,cAAc,EACd,wBAAwB,EACxB,2BAA2B,GAC5B,EAAE,oBAAoB,EACJ,iBAAiB,EAAE,yBAAyB;IAOjE,cAAc,IAAI,kBAAkB;IAK9B,qBAAqB,CACzB,OAAO,GAAE,yBAAyB,CAAC,gCAAqC,EACxE,MAAM,GAAE,UAAU,CAAC,yBAAyB,CAAC,oBAAoB,CAAM,EACtD,aAAa,GAAE,OAAY,GAC3C,OAAO,CAAC,yBAAyB,CAAC,oBAAoB,EAAE,CAAC;IAetD,6BAA6B,CACjC,OAAO,GAAE,yBAAyB,CAAC,gCAAqC,EACxE,MAAM,GAAE,UAAU,CAAC,yBAAyB,CAAC,oBAAoB,CAAM,EACtD,aAAa,GAAE,OAAY,GAC3C,OAAO,CAAC,CAAC,yBAAyB,CAAC,oBAAoB,EAAE,EAAE,MAAM,CAAC,CAAC;IAmBhE,GAAG,CAAC,SAAS,SAAS,MAAM,GAAG,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,EAChE,oBAAoB,EAAE,SAAS,EAC/B,OAAO,GAAE,yBAAyB,CAAC,0BAA0B,CAC3D,SAAS,SAAS,cAAc,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,GAC3C,2BAA2B,CAAC,SAAS,CAAC,GACtC,OAAO,CACP,EACW,OAAO,GAAE,OAAY;IAYlC,qBAAqB,CACzB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACJ,OAAO,GAAE,OAAY;IAUlC,cAAc,CAClB,EACE,cAAc,EACd,YAAY,EACZ,OAAO,GACR,EAAE;QACD,cAAc,EAAE,MAAM,GAAG,MAAM,CAAA;QAC/B,YAAY,EAAE,OAAO,CAAA;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAC9B,EACgB,OAAO,GAAE,OAAY;IAalC,cAAc,CAClB,EACE,cAAc,EACd,YAAY,EACZ,OAAO,GACR,EAAE;QACD,cAAc,EAAE,MAAM,GAAG,MAAM,CAAA;QAC/B,YAAY,EAAE,OAAO,CAAA;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAC9B,EACgB,OAAO,GAAE,OAAY;IAalC,SAAS,CACb,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,CAAA;QAClB,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB,UAAU,EAAE,QAAQ,CAAA;QACpB,YAAY,CAAC,EAAE,MAAM,CAAA;KACtB,EACgB,OAAO,GAAE,OAAY;IAMlC,WAAW,CACf,IAAI,EAAE;QACJ,UAAU,EAAE,MAAM,CAAA;QAClB,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB,cAAc,EAAE,MAAM,GAAG,QAAQ,CAAA;KAClC,EACgB,OAAO,GAAE,OAAY;CAIzC"}

package/dist/services/workflows-module.js

@@ -0,0 +1,128 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowsModuleService = void 0;
+const utils_1 = require("@medusajs/utils");
+const joiner_config_1 = require("../joiner-config");
+class WorkflowsModuleService {
+    constructor({ baseRepository, workflowExecutionService, workflowOrchestratorService, }, moduleDeclaration) {
+        this.moduleDeclaration = moduleDeclaration;
+        this.baseRepository_ = baseRepository;
+        this.workflowExecutionService_ = workflowExecutionService;
+        this.workflowOrchestratorService_ = workflowOrchestratorService;
+    }
+    __joinerConfig() {
+        return joiner_config_1.joinerConfig;
+    }
+    async listWorkflowExecution(filters = {}, config = {}, sharedContext = {}) {
+        const wfExecutions = await this.workflowExecutionService_.list(filters, config, sharedContext);
+        return this.baseRepository_.serialize(wfExecutions, {
+            populate: true,
+        });
+    }
+    async listAndCountWorkflowExecution(filters = {}, config = {}, sharedContext = {}) {
+        const [wfExecutions, count] = await this.workflowExecutionService_.listAndCount(filters, config, sharedContext);
+        return [
+            await this.baseRepository_.serialize(wfExecutions, {
+                populate: true,
+            }),
+            count,
+        ];
+    }
+    async run(workflowIdOrWorkflow, options = {}, context = {}) {
+        const ret = await this.workflowOrchestratorService_.run(workflowIdOrWorkflow, options, context);
+        return ret;
+    }
+    async getRunningTransaction(workflowId, transactionId, context = {}) {
+        return this.workflowOrchestratorService_.getRunningTransaction(workflowId, transactionId, context);
+    }
+    async setStepSuccess({ idempotencyKey, stepResponse, options, }, context = {}) {
+        return this.workflowOrchestratorService_.setStepSuccess({
+            idempotencyKey,
+            stepResponse,
+            options,
+        }, context);
+    }
+    async setStepFailure({ idempotencyKey, stepResponse, options, }, context = {}) {
+        return this.workflowOrchestratorService_.setStepFailure({
+            idempotencyKey,
+            stepResponse,
+            options,
+        }, context);
+    }
+    async subscribe(args, context = {}) {
+        return this.workflowOrchestratorService_.subscribe(args, context);
+    }
+    async unsubscribe(args, context = {}) {
+        return this.workflowOrchestratorService_.unsubscribe(args, context);
+    }
+}
+exports.WorkflowsModuleService = WorkflowsModuleService;
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowsModuleService.prototype, "listWorkflowExecution", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowsModuleService.prototype, "listAndCountWorkflowExecution", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_a = typeof TWorkflow !== "undefined" && TWorkflow) === "function" ? _a : Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowsModuleService.prototype, "run", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowsModuleService.prototype, "getRunningTransaction", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowsModuleService.prototype, "setStepSuccess", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowsModuleService.prototype, "setStepFailure", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowsModuleService.prototype, "subscribe", null);
+__decorate([
+    (0, utils_1.InjectSharedContext)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], WorkflowsModuleService.prototype, "unsubscribe", null);

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+import { Logger } from "@medusajs/types";
+export type InitializeModuleInjectableDependencies = {
+    logger?: Logger;
+};
+//# sourceMappingURL=index.d.ts.map