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

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,30 @@
+import { Logger } from "@medusajs/types";
+import { RedisOptions } from "ioredis";
+export type InitializeModuleInjectableDependencies = {
+    logger?: Logger;
+};
+/**
+ * Module config type
+ */
+export type RedisWorkflowsOptions = {
+    /**
+     * Redis connection string
+     */
+    url?: string;
+    /**
+     * Queue name used for retries and timeouts
+     */
+    queueName?: string;
+    /**
+     * Redis client options
+     */
+    options?: RedisOptions;
+    /**
+     * Optiona connection string and options to pub/sub
+     */
+    pubsub?: {
+        url: string;
+        options?: RedisOptions;
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAEtC,MAAM,MAAM,sCAAsC,GAAG;IACnD,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IAEZ;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAA;IAElB;;OAEG;IACH,OAAO,CAAC,EAAE,YAAY,CAAA;IAEtB;;OAEG;IACH,MAAM,CAAC,EAAE;QACP,GAAG,EAAE,MAAM,CAAA;QACX,OAAO,CAAC,EAAE,YAAY,CAAA;KACvB,CAAA;CACF,CAAA"}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./workflow-orchestrator-storage";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAA"}

package/dist/utils/index.js

@@ -0,0 +1,17 @@
+"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-orchestrator-storage"), exports);

package/dist/utils/workflow-orchestrator-storage.d.ts

@@ -0,0 +1,35 @@
+import { DistributedTransaction, DistributedTransactionStorage, TransactionCheckpoint, TransactionStep } from "@medusajs/orchestration";
+import { WorkflowExecutionService } from "../services";
+import Redis from "ioredis";
+export declare class RedisDistributedTransactionStorage extends DistributedTransactionStorage {
+    private static TTL_AFTER_COMPLETED;
+    private workflowExecutionService_;
+    private workflowOrchestratorService_;
+    private redisClient;
+    private queue;
+    private worker;
+    constructor({ workflowExecutionService, redisConnection, redisWorkerConnection, redisQueueName, }: {
+        workflowExecutionService: WorkflowExecutionService;
+        redisConnection: Redis;
+        redisWorkerConnection: Redis;
+        redisQueueName: string;
+    });
+    setWorkflowOrchestratorService(workflowOrchestratorService: any): void;
+    private saveToDb;
+    private deleteFromDb;
+    private executeTransaction;
+    private stringifyWithSymbol;
+    private jsonWithSymbol;
+    get(key: string): Promise<TransactionCheckpoint | undefined>;
+    list(): Promise<TransactionCheckpoint[]>;
+    save(key: string, data: TransactionCheckpoint, ttl?: number): Promise<void>;
+    scheduleRetry(transaction: DistributedTransaction, step: TransactionStep, timestamp: number, interval: number): Promise<void>;
+    clearRetry(transaction: DistributedTransaction, step: TransactionStep): Promise<void>;
+    scheduleTransactionTimeout(transaction: DistributedTransaction, timestamp: number, interval: number): Promise<void>;
+    clearTransactionTimeout(transaction: DistributedTransaction): Promise<void>;
+    scheduleStepTimeout(transaction: DistributedTransaction, step: TransactionStep, timestamp: number, interval: number): Promise<void>;
+    clearStepTimeout(transaction: DistributedTransaction, step: TransactionStep): Promise<void>;
+    private getJobId;
+    private removeJob;
+}
+//# sourceMappingURL=workflow-orchestrator-storage.d.ts.map

package/dist/utils/workflow-orchestrator-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-orchestrator-storage.d.ts","sourceRoot":"","sources":["../../src/utils/workflow-orchestrator-storage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,6BAA6B,EAC7B,qBAAqB,EACrB,eAAe,EAChB,MAAM,yBAAyB,CAAA;AAEhC,OAAO,EACL,wBAAwB,EAEzB,MAAM,WAAW,CAAA;AAElB,OAAO,KAAK,MAAM,SAAS,CAAA;AAS3B,qBAAa,kCAAmC,SAAQ,6BAA6B;IACnF,OAAO,CAAC,MAAM,CAAC,mBAAmB,CAAU;IAC5C,OAAO,CAAC,yBAAyB,CAA0B;IAC3D,OAAO,CAAC,4BAA4B,CAA6B;IAEjE,OAAO,CAAC,WAAW,CAAO;IAC1B,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,MAAM,CAAQ;gBAEV,EACV,wBAAwB,EACxB,eAAe,EACf,qBAAqB,EACrB,cAAc,GACf,EAAE;QACD,wBAAwB,EAAE,wBAAwB,CAAA;QAClD,eAAe,EAAE,KAAK,CAAA;QACtB,qBAAqB,EAAE,KAAK,CAAA;QAC5B,cAAc,EAAE,MAAM,CAAA;KACvB;IA4BD,8BAA8B,CAAC,2BAA2B,KAAA;YAI5C,QAAQ;YAeR,YAAY;YASZ,kBAAkB;IAOhC,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,cAAc;IAQhB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC;IAM5D,IAAI,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAcxC,IAAI,CACR,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,qBAAqB,EAC3B,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC;IAqDV,aAAa,CACjB,WAAW,EAAE,sBAAsB,EACnC,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAgBV,UAAU,CACd,WAAW,EAAE,sBAAsB,EACnC,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,IAAI,CAAC;IAIV,0BAA0B,CAC9B,WAAW,EAAE,sBAAsB,EACnC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAeV,uBAAuB,CAC3B,WAAW,EAAE,sBAAsB,GAClC,OAAO,CAAC,IAAI,CAAC;IAIV,mBAAmB,CACvB,WAAW,EAAE,sBAAsB,EACnC,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC;IAgBV,gBAAgB,CACpB,WAAW,EAAE,sBAAsB,EACnC,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,IAAI,CAAC;IAIhB,OAAO,CAAC,QAAQ;YAcF,SAAS;CAYxB"}

package/dist/utils/workflow-orchestrator-storage.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisDistributedTransactionStorage = void 0;
+const orchestration_1 = require("@medusajs/orchestration");
+const utils_1 = require("@medusajs/utils");
+const bullmq_1 = require("bullmq");
+var JobType;
+(function (JobType) {
+    JobType["RETRY"] = "retry";
+    JobType["STEP_TIMEOUT"] = "step_timeout";
+    JobType["TRANSACTION_TIMEOUT"] = "transaction_timeout";
+})(JobType || (JobType = {}));
+// eslint-disable-next-line max-len
+class RedisDistributedTransactionStorage extends orchestration_1.DistributedTransactionStorage {
+    constructor({ workflowExecutionService, redisConnection, redisWorkerConnection, redisQueueName, }) {
+        super();
+        this.workflowExecutionService_ = workflowExecutionService;
+        this.redisClient = redisConnection;
+        this.queue = new bullmq_1.Queue(redisQueueName, { connection: this.redisClient });
+        this.worker = new bullmq_1.Worker(redisQueueName, async (job) => {
+            const allJobs = [
+                JobType.RETRY,
+                JobType.STEP_TIMEOUT,
+                JobType.TRANSACTION_TIMEOUT,
+            ];
+            if (allJobs.includes(job.name)) {
+                await this.executeTransaction(job.data.workflowId, job.data.transactionId);
+            }
+        }, { connection: redisWorkerConnection });
+    }
+    setWorkflowOrchestratorService(workflowOrchestratorService) {
+        this.workflowOrchestratorService_ = workflowOrchestratorService;
+    }
+    async saveToDb(data) {
+        await this.workflowExecutionService_.upsert([
+            {
+                workflow_id: data.flow.modelId,
+                transaction_id: data.flow.transactionId,
+                execution: data.flow,
+                context: {
+                    data: data.context,
+                    errors: data.errors,
+                },
+                state: data.flow.state,
+            },
+        ]);
+    }
+    async deleteFromDb(data) {
+        await this.workflowExecutionService_.delete([
+            {
+                workflow_id: data.flow.modelId,
+                transaction_id: data.flow.transactionId,
+            },
+        ]);
+    }
+    async executeTransaction(workflowId, transactionId) {
+        return await this.workflowOrchestratorService_.run(workflowId, {
+            transactionId,
+            throwOnError: false,
+        });
+    }
+    stringifyWithSymbol(key, value) {
+        if (key === "__type" && typeof value === "symbol") {
+            return Symbol.keyFor(value);
+        }
+        return value;
+    }
+    jsonWithSymbol(key, value) {
+        if (key === "__type" && typeof value === "string") {
+            return Symbol.for(value);
+        }
+        return value;
+    }
+    async get(key) {
+        const data = await this.redisClient.get(key);
+        return data ? JSON.parse(data, this.jsonWithSymbol) : undefined;
+    }
+    async list() {
+        const keys = await this.redisClient.keys(orchestration_1.DistributedTransaction.keyPrefix + ":*");
+        const transactions = [];
+        for (const key of keys) {
+            const data = await this.redisClient.get(key);
+            if (data) {
+                transactions.push(JSON.parse(data, this.jsonWithSymbol));
+            }
+        }
+        return transactions;
+    }
+    async save(key, data, ttl) {
+        let retentionTime;
+        /**
+         * Store the retention time only if the transaction is done, failed or reverted.
+         * From that moment, this tuple can be later on archived or deleted after the retention time.
+         */
+        const hasFinished = [
+            utils_1.TransactionState.DONE,
+            utils_1.TransactionState.FAILED,
+            utils_1.TransactionState.REVERTED,
+        ].includes(data.flow.state);
+        if (hasFinished) {
+            retentionTime = data.flow.options?.retentionTime;
+            Object.assign(data, {
+                retention_time: retentionTime,
+            });
+        }
+        if (!hasFinished) {
+            if (ttl) {
+                await this.redisClient.set(key, JSON.stringify(data, this.stringifyWithSymbol), "EX", ttl);
+            }
+            else {
+                await this.redisClient.set(key, JSON.stringify(data, this.stringifyWithSymbol));
+            }
+        }
+        if (hasFinished && !retentionTime) {
+            await this.deleteFromDb(data);
+        }
+        else {
+            await this.saveToDb(data);
+        }
+        if (hasFinished) {
+            // await this.redisClient.del(key)
+            await this.redisClient.set(key, JSON.stringify(data, this.stringifyWithSymbol), "EX", RedisDistributedTransactionStorage.TTL_AFTER_COMPLETED);
+        }
+    }
+    async scheduleRetry(transaction, step, timestamp, interval) {
+        await this.queue.add(JobType.RETRY, {
+            workflowId: transaction.modelId,
+            transactionId: transaction.transactionId,
+            stepId: step.id,
+        }, {
+            delay: interval * 1000,
+            jobId: this.getJobId(JobType.RETRY, transaction, step),
+            removeOnComplete: true,
+        });
+    }
+    async clearRetry(transaction, step) {
+        await this.removeJob(JobType.RETRY, transaction, step);
+    }
+    async scheduleTransactionTimeout(transaction, timestamp, interval) {
+        await this.queue.add(JobType.TRANSACTION_TIMEOUT, {
+            workflowId: transaction.modelId,
+            transactionId: transaction.transactionId,
+        }, {
+            delay: interval * 1000,
+            jobId: this.getJobId(JobType.TRANSACTION_TIMEOUT, transaction),
+            removeOnComplete: true,
+        });
+    }
+    async clearTransactionTimeout(transaction) {
+        await this.removeJob(JobType.TRANSACTION_TIMEOUT, transaction);
+    }
+    async scheduleStepTimeout(transaction, step, timestamp, interval) {
+        await this.queue.add(JobType.STEP_TIMEOUT, {
+            workflowId: transaction.modelId,
+            transactionId: transaction.transactionId,
+            stepId: step.id,
+        }, {
+            delay: interval * 1000,
+            jobId: this.getJobId(JobType.STEP_TIMEOUT, transaction, step),
+            removeOnComplete: true,
+        });
+    }
+    async clearStepTimeout(transaction, step) {
+        await this.removeJob(JobType.STEP_TIMEOUT, transaction, step);
+    }
+    getJobId(type, transaction, step) {
+        const key = [type, transaction.modelId, transaction.transactionId];
+        if (step) {
+            key.push(step.id);
+        }
+        return key.join(":");
+    }
+    async removeJob(type, transaction, step) {
+        const jobId = this.getJobId(type, transaction, step);
+        const job = await this.queue.getJob(jobId);
+        if (job && job.attemptsStarted === 0) {
+            await job.remove();
+        }
+    }
+}
+exports.RedisDistributedTransactionStorage = RedisDistributedTransactionStorage;
+RedisDistributedTransactionStorage.TTL_AFTER_COMPLETED = 60 * 15; // 15 minutes

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@medusajs/workflow-engine-redis",
+  "version": "0.0.2-next-20240124093206",
+  "description": "Medusa Workflow Orchestrator module using Redis to track workflows executions",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/medusajs/medusa",
+    "directory": "packages/workflow-engine-redis"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "Medusa",
+  "license": "MIT",
+  "scripts": {
+    "watch": "tsc --build --watch",
+    "watch:test": "tsc --build tsconfig.spec.json --watch",
+    "prepublishOnly": "cross-env NODE_ENV=production tsc --build && tsc-alias -p tsconfig.json",
+    "build": "rimraf dist && tsc --build && tsc-alias -p tsconfig.json",
+    "test": "jest --passWithNoTests --runInBand --bail --forceExit -- src/**/__tests__/**/*.ts",
+    "test:integration": "jest --runInBand --forceExit -- integration-tests/**/__tests__/**/*.ts",
+    "migration:generate": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:generate",
+    "migration:initial": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:create --initial",
+    "migration:create": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:create",
+    "migration:up": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm migration:up",
+    "orm:cache:clear": " MIKRO_ORM_CLI=./mikro-orm.config.dev.ts mikro-orm cache:clear"
+  },
+  "devDependencies": {
+    "@mikro-orm/cli": "5.9.7",
+    "cross-env": "^5.2.1",
+    "jest": "^29.6.3",
+    "medusa-test-utils": "^1.1.40",
+    "rimraf": "^3.0.2",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.6",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@medusajs/modules-sdk": "1.12.7-next-20240124093206",
+    "@medusajs/types": "1.11.11-next-20240124093206",
+    "@medusajs/utils": "1.11.4-next-20240124093206",
+    "@medusajs/workflows-sdk": "0.1.2-next-20240124093206",
+    "@mikro-orm/core": "5.9.7",
+    "@mikro-orm/migrations": "5.9.7",
+    "@mikro-orm/postgresql": "5.9.7",
+    "awilix": "^8.0.0",
+    "bullmq": "^5.1.3",
+    "dotenv": "^16.1.4",
+    "ioredis": "^5.3.2",
+    "knex": "2.4.2"
+  }
+}