@motiadev/core 0.0.27 → 0.0.29

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 export * from './src/types';
-export * from './src/server';
-export * from './src/step-handlers';
-export * from './src/event-manager';
-export * from './src/logger';
-export * from './src/state/create-state-adapter';
-export * from './src/cron-handler';
-export * from './src/guards';
-export * from './src/locked-data';
-export * from './src/get-step-config';
+export { createServer, MotiaServer } from './src/server';
+export { createStepHandlers, MotiaEventManager } from './src/step-handlers';
+export { createEventManager } from './src/event-manager';
+export { globalLogger, Logger } from './src/logger';
+export { createStateAdapter } from './src/state/create-state-adapter';
+export { setupCronHandlers, CronManager } from './src/cron-handler';
+export { isApiStep, isCronStep, isEventStep, isNoopStep } from './src/guards';
+export { LockedData } from './src/locked-data';
+export { getStepConfig } from './src/get-step-config';
+export { StateAdapter } from './src/state/state-adapter';

package/dist/index.js

@@ -14,13 +14,27 @@ 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 });
+exports.getStepConfig = exports.LockedData = exports.isNoopStep = exports.isEventStep = exports.isCronStep = exports.isApiStep = exports.setupCronHandlers = exports.createStateAdapter = exports.Logger = exports.globalLogger = exports.createEventManager = exports.createStepHandlers = exports.createServer = void 0;
 __exportStar(require("./src/types"), exports);
-__exportStar(require("./src/server"), exports);
-__exportStar(require("./src/step-handlers"), exports);
-__exportStar(require("./src/event-manager"), exports);
-__exportStar(require("./src/logger"), exports);
-__exportStar(require("./src/state/create-state-adapter"), exports);
-__exportStar(require("./src/cron-handler"), exports);
-__exportStar(require("./src/guards"), exports);
-__exportStar(require("./src/locked-data"), exports);
-__exportStar(require("./src/get-step-config"), exports);
+var server_1 = require("./src/server");
+Object.defineProperty(exports, "createServer", { enumerable: true, get: function () { return server_1.createServer; } });
+var step_handlers_1 = require("./src/step-handlers");
+Object.defineProperty(exports, "createStepHandlers", { enumerable: true, get: function () { return step_handlers_1.createStepHandlers; } });
+var event_manager_1 = require("./src/event-manager");
+Object.defineProperty(exports, "createEventManager", { enumerable: true, get: function () { return event_manager_1.createEventManager; } });
+var logger_1 = require("./src/logger");
+Object.defineProperty(exports, "globalLogger", { enumerable: true, get: function () { return logger_1.globalLogger; } });
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+var create_state_adapter_1 = require("./src/state/create-state-adapter");
+Object.defineProperty(exports, "createStateAdapter", { enumerable: true, get: function () { return create_state_adapter_1.createStateAdapter; } });
+var cron_handler_1 = require("./src/cron-handler");
+Object.defineProperty(exports, "setupCronHandlers", { enumerable: true, get: function () { return cron_handler_1.setupCronHandlers; } });
+var guards_1 = require("./src/guards");
+Object.defineProperty(exports, "isApiStep", { enumerable: true, get: function () { return guards_1.isApiStep; } });
+Object.defineProperty(exports, "isCronStep", { enumerable: true, get: function () { return guards_1.isCronStep; } });
+Object.defineProperty(exports, "isEventStep", { enumerable: true, get: function () { return guards_1.isEventStep; } });
+Object.defineProperty(exports, "isNoopStep", { enumerable: true, get: function () { return guards_1.isNoopStep; } });
+var locked_data_1 = require("./src/locked-data");
+Object.defineProperty(exports, "LockedData", { enumerable: true, get: function () { return locked_data_1.LockedData; } });
+var get_step_config_1 = require("./src/get-step-config");
+Object.defineProperty(exports, "getStepConfig", { enumerable: true, get: function () { return get_step_config_1.getStepConfig; } });

package/dist/src/LoggerFactory.d.ts

@@ -0,0 +1,14 @@
+import { Server } from 'socket.io';
+import { Logger } from './logger';
+type CreateLogger = {
+    traceId: string;
+    flows?: string[];
+    stepName: string;
+};
+export declare class LoggerFactory {
+    private readonly isVerbose;
+    private readonly socketServer;
+    constructor(isVerbose: boolean, socketServer: Server);
+    create({ stepName, traceId, flows }: CreateLogger): Logger;
+}
+export {};

package/dist/src/LoggerFactory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFactory = void 0;
+const logger_1 = require("./logger");
+class LoggerFactory {
+    constructor(isVerbose, socketServer) {
+        this.isVerbose = isVerbose;
+        this.socketServer = socketServer;
+    }
+    create({ stepName, traceId, flows }) {
+        return new logger_1.Logger(traceId, flows, stepName, this.isVerbose, this.socketServer);
+    }
+}
+exports.LoggerFactory = LoggerFactory;

package/dist/src/call-step-file.js

@@ -70,12 +70,20 @@ const callStepFile = (options) => {
         child.stderr?.on('data', (data) => logger.error(Buffer.from(data).toString()));
         child.on('close', (code) => {
             if (code !== 0 && code !== null) {
-                reject(new Error(`Process exited with code ${code}`));
+                reject(`Process exited with code ${code}`);
             }
             else {
                 resolve(result);
             }
         });
+        child.on('error', (error) => {
+            if (error.code === 'ENOENT') {
+                reject(`Executable ${command} not found`);
+            }
+            else {
+                reject(error);
+            }
+        });
     });
 };
 exports.callStepFile = callStepFile;

package/dist/src/cron-handler.d.ts

@@ -1,13 +1,13 @@
-import { Server } from 'socket.io';
 import { LockedData } from './locked-data';
 import { StateAdapter } from './state/state-adapter';
 import { CronConfig, EventManager, Step } from './types';
+import { LoggerFactory } from './LoggerFactory';
 export type CronManager = {
     createCronJob: (step: Step<CronConfig>) => void;
     removeCronJob: (step: Step<CronConfig>) => void;
     close: () => void;
 };
-export declare const setupCronHandlers: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter, socketServer: Server) => {
+export declare const setupCronHandlers: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter, loggerFactory: LoggerFactory) => {
     createCronJob: (step: Step<CronConfig>) => void;
     removeCronJob: (step: Step<CronConfig>) => void;
     close: () => void;

package/dist/src/cron-handler.js

@@ -38,12 +38,12 @@ const crypto_1 = require("crypto");
 const cron = __importStar(require("node-cron"));
 const call_step_file_1 = require("./call-step-file");
 const logger_1 = require("./logger");
-const setupCronHandlers = (lockedData, eventManager, state, socketServer) => {
+const setupCronHandlers = (lockedData, eventManager, state, loggerFactory) => {
     const cronJobs = new Map();
     const printer = lockedData.printer;
     const createCronJob = (step) => {
         const { config, filePath } = step;
-        const { cron: cronExpression, name: stepName } = config;
+        const { cron: cronExpression, name: stepName, flows } = config;
         if (!cron.validate(cronExpression)) {
             logger_1.globalLogger.error('[cron handler] invalid cron expression', {
                 expression: cronExpression,
@@ -58,7 +58,7 @@ const setupCronHandlers = (lockedData, eventManager, state, socketServer) => {
         });
         const task = cron.schedule(cronExpression, async () => {
             const traceId = (0, crypto_1.randomUUID)();
-            const logger = new logger_1.Logger(traceId, config.flows, stepName, socketServer);
+            const logger = loggerFactory.create({ traceId, flows, stepName });
             try {
                 await (0, call_step_file_1.callStepFile)({
                     contextInFirstArg: true,

package/dist/src/get-step-config.js

@@ -47,10 +47,18 @@ const getStepConfig = (file) => {
                 return; // Config was already resolved
             }
             else if (code !== 0) {
-                reject(new Error(`Process exited with code ${code}`));
+                reject(`Process exited with code ${code}`);
             }
             else if (!config) {
-                reject(new Error(`No config found for file ${file}`));
+                reject(`No config found for file ${file}`);
+            }
+        });
+        child.on('error', (error) => {
+            if (error.code === 'ENOENT') {
+                reject(`Executable ${command} not found`);
+            }
+            else {
+                reject(error);
             }
         });
     });

package/dist/src/logger.d.ts

@@ -1,14 +1,15 @@
 import { Server } from 'socket.io';
 export declare class BaseLogger {
+    readonly isVerbose: boolean;
     private readonly meta;
-    private logger;
-    constructor(meta?: Record<string, unknown>);
+    constructor(isVerbose?: boolean, meta?: Record<string, unknown>);
     child(meta?: Record<string, unknown>): this;
+    private _log;
     info(message: string, args?: unknown): void;
     error(message: string, args?: unknown): void;
     debug(message: string, args?: unknown): void;
     warn(message: string, args?: unknown): void;
-    log(args: unknown): void;
+    log(args: any): void;
 }
 export declare class Logger extends BaseLogger {
     private readonly traceId;
@@ -16,7 +17,7 @@ export declare class Logger extends BaseLogger {
     private readonly step;
     private readonly socketServer?;
     private emitLog;
-    constructor(traceId: string, flows: string[] | undefined, step: string, socketServer?: Server | undefined);
+    constructor(traceId: string, flows: string[] | undefined, step: string, isVerbose: boolean, socketServer?: Server | undefined);
     child(meta?: Record<string, unknown>): this;
     log(message: any): void;
     info: (message: string, args?: unknown) => void;

package/dist/src/logger.js

@@ -1,44 +1,51 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.globalLogger = exports.Logger = exports.BaseLogger = void 0;
-const pino_1 = __importDefault(require("pino"));
-const isDebugEnabled = () => process.env.LOG_LEVEL === 'debug';
+const pretty_print_1 = require("./pretty-print");
+const logLevel = process.env.LOG_LEVEL ?? 'info';
+const isDebugEnabled = logLevel === 'debug';
+const isInfoEnabled = ['info', 'debug'].includes(logLevel);
+const isWarnEnabled = ['warn', 'info', 'debug', 'trace'].includes(logLevel);
 class BaseLogger {
-    constructor(meta = {}) {
+    constructor(isVerbose = false, meta = {}) {
+        this.isVerbose = isVerbose;
         this.meta = meta;
-        this.logger = (0, pino_1.default)({
-            level: process.env.LOG_LEVEL || 'info',
-            formatters: { level: (level) => ({ level }) },
-            base: null,
-            mixin: () => meta,
-        });
     }
     child(meta = {}) {
-        return new BaseLogger({ ...this.meta, ...meta });
+        return new BaseLogger(this.isVerbose, { ...this.meta, ...meta });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _log(level, msg, args) {
+        const time = Date.now();
+        (0, pretty_print_1.prettyPrint)({ level, time, msg, ...this.meta, ...(args ?? {}) }, !this.isVerbose);
     }
     info(message, args) {
-        this.logger.info(args, message);
+        if (isInfoEnabled) {
+            this._log('info', message, args);
+        }
     }
     error(message, args) {
-        this.logger.error(args, message);
+        this._log('error', message, args);
     }
     debug(message, args) {
-        this.logger.debug(args, message);
+        if (isDebugEnabled) {
+            this._log('debug', message, args);
+        }
     }
     warn(message, args) {
-        this.logger.warn(args, message);
+        if (isWarnEnabled) {
+            this._log('warn', message, args);
+        }
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     log(args) {
-        this.logger.info(args);
+        this._log('info', args.msg, args);
     }
 }
 exports.BaseLogger = BaseLogger;
 class Logger extends BaseLogger {
-    constructor(traceId, flows, step, socketServer) {
-        super({ traceId, flows, step });
+    constructor(traceId, flows, step, isVerbose, socketServer) {
+        super(isVerbose, { traceId, flows, step });
         this.traceId = traceId;
         this.flows = flows;
         this.step = step;
@@ -52,8 +59,8 @@ class Logger extends BaseLogger {
             this.emitLog('error', message, args);
         };
         this.debug = (message, args) => {
-            super.debug(message, args);
-            if (isDebugEnabled()) {
+            if (isDebugEnabled) {
+                super.debug(message, args);
                 this.emitLog('debug', message, args);
             }
         };
@@ -74,11 +81,11 @@ class Logger extends BaseLogger {
         };
     }
     child(meta = {}) {
-        return new Logger(this.traceId, this.flows, meta.step, this.socketServer);
+        return new Logger(this.traceId, this.flows, meta.step, this.isVerbose, this.socketServer);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     log(message) {
-        console.log(JSON.stringify(message));
+        super.log(message);
         this.emitLog(message.level, message.msg, message);
     }
 }

package/dist/src/pretty-print.d.ts

@@ -0,0 +1 @@
+export declare const prettyPrint: (json: Record<string, any>, excludeDetails?: boolean) => void;

package/dist/src/pretty-print.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyPrint = void 0;
+const colors_1 = __importDefault(require("colors"));
+const stepTag = (step) => colors_1.default.bold(colors_1.default.cyan(step));
+const timestampTag = (timestamp) => colors_1.default.gray(timestamp);
+const traceIdTag = (traceId) => colors_1.default.gray(traceId);
+const levelTags = {
+    error: colors_1.default.red('[ERROR]'),
+    info: colors_1.default.blue('[INFO]'),
+    warn: colors_1.default.yellow('[WARN]'),
+    debug: colors_1.default.gray('[DEBUG]'),
+    trace: colors_1.default.gray('[TRACE]'),
+};
+const numericTag = (value) => colors_1.default.green(value);
+const stringTag = (value) => colors_1.default.cyan(value);
+const booleanTag = (value) => colors_1.default.blue(value);
+const arrayBrackets = ['[', ']'].map((s) => colors_1.default.gray(s));
+const objectBrackets = ['{', '}'].map((s) => colors_1.default.gray(s));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const prettyPrintObject = (obj, depth = 0, parentIsLast = false, prefix = '') => {
+    const tab = prefix + (depth === 0 ? '' : parentIsLast ? '│ ' : '│ ');
+    if (depth > 2) {
+        return `${tab} └ ${colors_1.default.gray('[...]')}`;
+    }
+    const entries = Object.entries(obj);
+    return entries
+        .map(([key, value], index) => {
+        const isLast = index === entries.length - 1;
+        const isObject = typeof value === 'object' && value !== null;
+        const prefix = isLast && !isObject ? '└' : '├';
+        if (isObject) {
+            const subObject = prettyPrintObject(value, depth + 1, isLast, tab);
+            const [start, end] = Array.isArray(value) ? arrayBrackets : objectBrackets;
+            return `${tab}${prefix} ${key}: ${start}\n${subObject}\n${tab}${isLast ? '└' : '│'} ${end}`;
+        }
+        let printedValue = value;
+        if (typeof value === 'number') {
+            printedValue = numericTag(String(value));
+        }
+        else if (typeof value === 'boolean') {
+            printedValue = booleanTag(String(value));
+        }
+        else if (typeof value === 'string') {
+            printedValue = stringTag(value);
+        }
+        return `${tab}${prefix} ${key}: ${printedValue}`;
+    })
+        .join('\n');
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const prettyPrint = (json, excludeDetails = false) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { time, traceId, msg, flows, level, step, ...details } = json;
+    const levelTag = levelTags[level];
+    const timestamp = timestampTag(`[${new Date(time).toLocaleTimeString()}]`);
+    const objectHasKeys = Object.keys(details).length > 0;
+    console.log(`${timestamp} ${traceIdTag(traceId)} ${levelTag} ${stepTag(step)} ${msg}`);
+    if (objectHasKeys && !excludeDetails) {
+        console.log(prettyPrintObject(details));
+    }
+};
+exports.prettyPrint = prettyPrint;

package/dist/src/server.d.ts

@@ -14,4 +14,8 @@ export type MotiaServer = {
     addRoute: (step: Step<ApiRouteConfig>) => void;
     cronManager: CronManager;
 };
-export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter) => Promise<MotiaServer>;
+type MotiaServerConfig = {
+    isVerbose: boolean;
+};
+export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter, config: MotiaServerConfig) => Promise<MotiaServer>;
+export {};

package/dist/src/server.js

@@ -15,18 +15,20 @@ const guards_1 = require("./guards");
 const logger_1 = require("./logger");
 const steps_1 = require("./steps");
 const call_step_file_1 = require("./call-step-file");
-const createServer = async (lockedData, eventManager, state) => {
+const LoggerFactory_1 = require("./LoggerFactory");
+const createServer = async (lockedData, eventManager, state, config) => {
     const printer = lockedData.printer;
     const app = (0, express_1.default)();
     const server = http_1.default.createServer(app);
     const io = new socket_io_1.Server(server);
+    const loggerFactory = new LoggerFactory_1.LoggerFactory(config.isVerbose, io);
     const allSteps = [...steps_1.systemSteps, ...lockedData.activeSteps];
-    const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, state, io);
+    const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, state, loggerFactory);
     const asyncHandler = (step) => {
         return async (req, res) => {
             const traceId = (0, crypto_1.randomUUID)();
-            const { name, flows } = step.config;
-            const logger = new logger_1.Logger(traceId, flows, name, io);
+            const { name: stepName, flows } = step.config;
+            const logger = loggerFactory.create({ traceId, flows, stepName });
             logger.debug('[API] Received request, processing step', { path: req.path });
             const request = {
                 body: req.body,
@@ -69,15 +71,21 @@ const createServer = async (lockedData, eventManager, state) => {
     const addRoute = (step) => {
         const { method, path } = step.config;
         logger_1.globalLogger.debug('[API] Registering route', step.config);
-        if (method === 'POST') {
-            router.post(path, asyncHandler(step));
-        }
-        else if (method === 'GET') {
-            router.get(path, asyncHandler(step));
-        }
-        else {
+        const handler = asyncHandler(step);
+        const methods = {
+            GET: () => router.get(path, handler),
+            POST: () => router.post(path, handler),
+            PUT: () => router.put(path, handler),
+            DELETE: () => router.delete(path, handler),
+            PATCH: () => router.patch(path, handler),
+            OPTIONS: () => router.options(path, handler),
+            HEAD: () => router.head(path, handler),
+        };
+        const methodHandler = methods[method];
+        if (!methodHandler) {
             throw new Error(`Unsupported method: ${method}`);
         }
+        methodHandler();
     };
     const removeRoute = (step) => {
         const { path, method } = step.config;

package/dist/src/state/adapters/default-state-adapter.d.ts

@@ -10,6 +10,8 @@ export declare class FileStateAdapter implements StateAdapter {
     set<T>(traceId: string, key: string, value: T): Promise<void>;
     delete(traceId: string, key: string): Promise<void>;
     clear(traceId: string): Promise<void>;
+    keys(traceId: string): Promise<string[]>;
+    traceIds(): Promise<string[]>;
     cleanup(): Promise<void>;
     private _makeKey;
     private _readFile;

package/dist/src/state/adapters/default-state-adapter.js

@@ -59,31 +59,43 @@ class FileStateAdapter {
         }
     }
     async get(traceId, key) {
-        const data = await this._readFile();
+        const data = this._readFile();
         const fullKey = this._makeKey(traceId, key);
         return data[fullKey] ? JSON.parse(data[fullKey]) : null;
     }
     async set(traceId, key, value) {
-        const data = await this._readFile();
+        const data = this._readFile();
         const fullKey = this._makeKey(traceId, key);
         data[fullKey] = JSON.stringify(value);
-        await this._writeFile(data);
+        this._writeFile(data);
     }
     async delete(traceId, key) {
-        const data = await this._readFile();
+        const data = this._readFile();
         const fullKey = this._makeKey(traceId, key);
         delete data[fullKey];
-        await this._writeFile(data);
+        this._writeFile(data);
     }
     async clear(traceId) {
-        const data = await this._readFile();
+        const data = this._readFile();
         const pattern = this._makeKey(traceId, '');
         for (const key in data) {
             if (key.startsWith(pattern)) {
                 delete data[key];
             }
         }
-        await this._writeFile(data);
+        this._writeFile(data);
+    }
+    async keys(traceId) {
+        const data = this._readFile();
+        return Object.keys(data)
+            .filter((key) => key.startsWith(this._makeKey(traceId, '')))
+            .map((key) => key.replace(this._makeKey(traceId, ''), ''));
+    }
+    async traceIds() {
+        const data = this._readFile();
+        const traceIds = new Set();
+        Object.keys(data).forEach((key) => traceIds.add(key.split(':')[0]));
+        return Array.from(traceIds);
     }
     async cleanup() {
         // No cleanup needed for file system
@@ -91,11 +103,11 @@ class FileStateAdapter {
     _makeKey(traceId, key) {
         return `${traceId}:${key}`;
     }
-    async _readFile() {
+    _readFile() {
         const content = fs_1.default.readFileSync(this.filePath, 'utf-8');
         return JSON.parse(content);
     }
-    async _writeFile(data) {
+    _writeFile(data) {
         fs_1.default.writeFileSync(this.filePath, JSON.stringify(data, null, 2), 'utf-8');
     }
 }

package/dist/src/state/adapters/memory-state-adapter.d.ts

@@ -6,6 +6,8 @@ export declare class MemoryStateAdapter implements StateAdapter {
     set<T>(traceId: string, key: string, value: T): Promise<void>;
     delete(traceId: string, key: string): Promise<void>;
     clear(traceId: string): Promise<void>;
+    keys(traceId: string): Promise<string[]>;
+    traceIds(): Promise<string[]>;
     cleanup(): Promise<void>;
     private _makeKey;
 }

package/dist/src/state/adapters/memory-state-adapter.js

@@ -28,6 +28,16 @@ class MemoryStateAdapter {
             }
         }
     }
+    async keys(traceId) {
+        return Object.keys(this.state)
+            .filter((key) => key.startsWith(this._makeKey(traceId, '')))
+            .map((key) => key.replace(this._makeKey(traceId, ''), ''));
+    }
+    async traceIds() {
+        const traceIds = new Set();
+        Object.keys(this.state).forEach((key) => traceIds.add(key.split(':')[0]));
+        return Array.from(traceIds);
+    }
     async cleanup() {
         // No cleanup needed for file system
     }

package/dist/src/state/adapters/redis-state-adapter.d.ts

@@ -14,6 +14,8 @@ export declare class RedisStateAdapter implements StateAdapter {
     set<T>(traceId: string, key: string, value: T): Promise<void>;
     delete(traceId: string, key: string): Promise<void>;
     clear(traceId: string): Promise<void>;
+    keys(traceId: string): Promise<string[]>;
+    traceIds(): Promise<string[]>;
     cleanup(): Promise<void>;
     _makeKey(traceId: string, key: string): string;
 }

package/dist/src/state/adapters/redis-state-adapter.js

@@ -34,6 +34,16 @@ class RedisStateAdapter {
             await this.client.del(keys);
         }
     }
+    async keys(traceId) {
+        const pattern = this._makeKey(traceId, '*');
+        const keys = await this.client.keys(pattern);
+        return keys.map((key) => key.replace(this._makeKey(traceId, ''), ''));
+    }
+    async traceIds() {
+        const pattern = `${this.prefix}:*`;
+        const keys = await this.client.keys(pattern);
+        return keys.map((key) => key.split(':')[1]);
+    }
     async cleanup() {
         await this.client.quit();
     }

package/dist/src/state/state-adapter.d.ts

@@ -7,4 +7,6 @@ export interface StateAdapter {
     delete(traceId: string, key: string): Promise<void>;
     clear(traceId: string): Promise<void>;
     cleanup(): Promise<void>;
+    keys(traceId: string): Promise<string[]>;
+    traceIds(): Promise<string[]>;
 }

package/dist/src/step-handlers.js

@@ -38,11 +38,8 @@ const createStepHandlers = (lockedData, eventManager, state) => {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     }
                     catch (error) {
-                        logger_1.globalLogger.error(`[step handler] error calling step`, {
-                            error: error.message,
-                            filePath,
-                            step: name,
-                        });
+                        const message = typeof error === 'string' ? error : error.message;
+                        logger.error(message);
                     }
                 },
             });

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@motiadev/core",
   "main": "dist/index.js",
-  "version": "0.0.27",
+  "version": "0.0.29",
   "dependencies": {
     "body-parser": "^1.20.3",
     "colors": "^1.4.0",
     "express": "^4.21.2",
     "ioredis": "^5.4.2",
     "node-cron": "^3.0.3",
-    "pino": "^9.6.0",
     "socket.io": "^4.8.1",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",