@motiadev/core 0.0.28 → 0.0.29

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,

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.28",
+  "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",