@unito/integration-sdk 0.1.7 → 0.1.9

package/dist/src/index.d.ts

@@ -1,4 +1,5 @@
 export * as Api from '@unito/integration-api';
+export { Cache } from './resources/cache.js';
 export { default as Integration } from './integration.js';
 export * from './handler.js';
 export { Provider, type Response as ProviderResponse, type RequestOptions as ProviderRequestOptions, type RateLimiter, } from './resources/provider.js';

package/dist/src/index.js

@@ -1,5 +1,6 @@
 /* c8 ignore start */
 export * as Api from '@unito/integration-api';
+export { Cache } from './resources/cache.js';
 export { default as Integration } from './integration.js';
 export * from './handler.js';
 export { Provider, } from './resources/provider.js';

package/dist/src/integration.d.ts

@@ -5,7 +5,6 @@ type Options = {
 export default class Integration {
     private handlers;
     private instance;
-    private cache;
     private port;
     constructor(options?: Options);
     addHandler(path: string, handlers: HandlersInput): void;

package/dist/src/integration.js

@@ -7,7 +7,7 @@ import selectsMiddleware from './middlewares/selects.js';
 import errorsMiddleware from './middlewares/errors.js';
 import finishMiddleware from './middlewares/finish.js';
 import notFoundMiddleware from './middlewares/notFound.js';
-import { initializeCache } from './resources/cache.js';
+import { shutdownCaches } from './resources/cache.js';
 import { Handler } from './handler.js';
 function printErrorMessage(message) {
     console.error();
@@ -17,7 +17,6 @@ function printErrorMessage(message) {
 export default class Integration {
     handlers;
     instance = undefined;
-    cache = undefined;
     port;
     constructor(options = {}) {
         this.port = options.port || 9200;
@@ -56,8 +55,6 @@ export default class Integration {
         }
     }
     start() {
-        // Initialize the cache.
-        this.cache = initializeCache();
         // Express Server initialization
         const app = express();
         // Parse query strings with https://github.com/ljharb/qs.
@@ -97,9 +94,7 @@ export default class Integration {
                     if (this.instance) {
                         this.instance.close();
                     }
-                    if (this.cache) {
-                        await this.cache.quit();
-                    }
+                    await shutdownCaches();
                 }
                 catch (e) {
                     console.error('Failed to gracefully exit', e);

package/dist/src/middlewares/errors.d.ts

@@ -1,3 +1,11 @@
 import { Request, Response, NextFunction } from 'express';
-declare const middleware: (err: Error, _req: Request, res: Response, next: NextFunction) => void | Response<any, Record<string, any>>;
+import { Error as ApiError } from '@unito/integration-api';
+declare global {
+    namespace Express {
+        interface Locals {
+            error?: ApiError;
+        }
+    }
+}
+declare const middleware: (err: Error, _req: Request, res: Response, next: NextFunction) => void;
 export default middleware;

package/dist/src/middlewares/errors.js

@@ -3,20 +3,35 @@ const middleware = (err, _req, res, next) => {
     if (res.headersSent) {
         return next(err);
     }
-    if (process.env.NODE_ENV !== 'production') {
-        res.locals.logger.error(err);
-    }
+    let error;
     if (err instanceof HttpError) {
-        return res.status(err.status).json(err.message);
+        error = {
+            code: err.status.toString(),
+            message: err.message,
+            details: {
+                stack: err.stack,
+            },
+        };
+    }
+    else {
+        error = {
+            code: '500',
+            message: 'Oops! Something went wrong',
+            originalError: {
+                code: err.name,
+                message: err.message,
+                details: {
+                    stack: err.stack,
+                },
+            },
+        };
+    }
+    res.locals.error = structuredClone(error);
+    // Keep the stack details in development for the Debugger
+    if (process.env.NODE_ENV !== 'development') {
+        delete error.details;
+        delete error.originalError?.details;
     }
-    const originalError = {
-        code: err.name,
-        message: err.message,
-    };
-    res.status(500).json({
-        code: '500',
-        message: 'Oops! Something went wrong',
-        originalError,
-    });
+    res.status(Number(error.code)).json(error);
 };
 export default middleware;

package/dist/src/middlewares/finish.d.ts

@@ -1,9 +1,11 @@
 import { Request, Response, NextFunction } from 'express';
-import Logger from '../resources/logger.js';
+import { Error as ApiError } from '@unito/integration-api';
+import { default as Logger } from '../resources/logger.js';
 declare global {
     namespace Express {
         interface Locals {
             logger: Logger;
+            error?: ApiError;
         }
     }
 }

package/dist/src/middlewares/finish.js

@@ -1,8 +1,31 @@
 const middleware = (req, res, next) => {
     if (req.originalUrl !== '/health') {
         res.on('finish', function () {
-            const loggerLevel = res.statusCode >= 500 ? 'error' : 'info';
-            res.locals.logger[loggerLevel](`${req.method} ${req.originalUrl} ${res.statusCode}`);
+            const error = res.locals.error;
+            const message = `${req.method} ${req.originalUrl} ${res.statusCode}`;
+            const metadata = {
+                // Use reserved and standard attributes of Datadog
+                // https://app.datadoghq.com/logs/pipelines/standard-attributes
+                http: { method: req.method, status_code: res.statusCode, url_details: { path: req.originalUrl } },
+                ...(error
+                    ? {
+                        error: {
+                            kind: error.message,
+                            stack: (error.originalError?.details?.stack ?? error.details?.stack),
+                            message: error.originalError?.message ?? error.message,
+                        },
+                    }
+                    : {}),
+            };
+            if ([404, 429].includes(res.statusCode)) {
+                res.locals.logger.warn(message, metadata);
+            }
+            else if (res.statusCode >= 400) {
+                res.locals.logger.error(message, metadata);
+            }
+            else {
+                res.locals.logger.info(message, metadata);
+            }
         });
     }
     next();

package/dist/src/resources/cache.d.ts

@@ -1,4 +1,18 @@
-import { CacheInstance } from 'cachette';
-export type Cache = CacheInstance;
-export declare function initializeCache(): Cache;
-export declare function generateCacheKey(value: string): string;
+import { FetchingFunction, CachableValue } from 'cachette';
+export declare const shutdownCaches: () => Promise<PromiseSettledResult<void>[]>;
+export declare class Cache {
+    private cacheInstance;
+    private constructor();
+    getOrFetchValue<F extends FetchingFunction = FetchingFunction>(key: string, ttl: number, fetcher: F, lockTtl?: number, shouldCacheError?: (err: Error) => boolean): Promise<ReturnType<F>>;
+    getValue(key: string): Promise<CachableValue>;
+    setValue(key: string, value: CachableValue, ttl?: number): Promise<boolean>;
+    delValue(key: string): Promise<void>;
+    getTtl(key: string): Promise<number | undefined>;
+    /**
+     * Initializes a WriteThroughCache instance with the provided redis url if present, or a LocalCache otherwise.
+     *
+     * @param redisUrl - The redis url to connect to (optional).
+     * @returns A cache instance.
+     */
+    static create(redisUrl?: string): Cache;
+}

package/dist/src/resources/cache.js

@@ -1,25 +1,56 @@
 import { WriteThroughCache, LocalCache } from 'cachette';
-import { createHash } from 'node:crypto';
 import * as uuid from 'uuid';
 import Logger from './logger.js';
-export function initializeCache() {
-    const cacheInstance = process.env.REDIS_URL ? new WriteThroughCache(process.env.REDIS_URL) : new LocalCache();
-    // Intended: the correlation id will be the same for all logs of Cachette.
-    const correlationId = uuid.v4();
-    const logger = new Logger({ correlation_id: correlationId });
-    cacheInstance
-        .on('info', message => {
-        logger.info(message);
-    })
-        .on('warn', message => {
-        logger.warn(message);
-    })
-        .on('error', message => {
-        logger.error(message);
-    });
-    return cacheInstance;
-}
-const shake256 = createHash('shake256');
-export function generateCacheKey(value) {
-    return shake256.update(value).digest('hex');
+/**
+ * Array of created caches kept to allow for graceful shutdown on exit signals.
+ */
+const caches = [];
+export const shutdownCaches = async () => {
+    return Promise.allSettled(caches.map(cache => cache.quit()));
+};
+export class Cache {
+    cacheInstance;
+    constructor(cacheInstance) {
+        this.cacheInstance = cacheInstance;
+    }
+    getOrFetchValue(key, ttl, fetcher, lockTtl, shouldCacheError) {
+        return this.cacheInstance.getOrFetchValue(key, ttl, fetcher, lockTtl, shouldCacheError);
+    }
+    getValue(key) {
+        return this.cacheInstance.getValue(key);
+    }
+    setValue(key, value, ttl) {
+        return this.cacheInstance.setValue(key, value, ttl);
+    }
+    delValue(key) {
+        return this.cacheInstance.delValue(key);
+    }
+    getTtl(key) {
+        return this.cacheInstance.getTtl(key);
+    }
+    /**
+     * Initializes a WriteThroughCache instance with the provided redis url if present, or a LocalCache otherwise.
+     *
+     * @param redisUrl - The redis url to connect to (optional).
+     * @returns A cache instance.
+     */
+    static create(redisUrl) {
+        const cacheInstance = redisUrl ? new WriteThroughCache(redisUrl) : new LocalCache();
+        // Push to the array of caches for graceful shutdown on exit signals.
+        caches.push(cacheInstance);
+        // Intended: the correlation id will be the same for all logs of Cachette.
+        const correlationId = uuid.v4();
+        const logger = new Logger({ correlation_id: correlationId });
+        cacheInstance
+            .on('info', message => {
+            logger.info(message);
+        })
+            .on('warn', message => {
+            logger.warn(message);
+        })
+            .on('error', message => {
+            logger.error(message);
+        });
+        return new Cache(cacheInstance);
+    }
 }

package/dist/src/resources/context.d.ts

@@ -69,7 +69,7 @@ export type ParseWebhooksContext<P extends Record<string, string> = Record<strin
 export type UpdateWebhookSubscriptionsContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.WebhookSubscriptionRequestPayload = API.WebhookSubscriptionRequestPayload> = Context<P, Q> & {
     body: B;
 };
-export type AckknowledgeWebhooksContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.WebhookParseRequestPayload = API.WebhookParseRequestPayload> = Omit<Context<P, Q>, 'credentials'> & {
+export type AcknowledgeWebhooksContext<P extends Record<string, string> = Record<string, never>, Q extends Record<string, string> = Record<string, never>, B extends API.WebhookParseRequestPayload = API.WebhookParseRequestPayload> = Omit<Context<P, Q>, 'credentials'> & {
     body: B;
 };
 interface ParsedQueryString {

package/dist/src/resources/logger.d.ts

@@ -1,14 +1,53 @@
+type PrimitiveValue = undefined | null | string | string[] | number | number[] | boolean | boolean[];
+type Value = {
+    [key: string]: PrimitiveValue | Value;
+};
+export type Metadata = Value & {
+    message?: never;
+};
+type ForbidenMetadataKey = 'message';
 export default class Logger {
     private metadata;
-    constructor(metadata?: Record<string, unknown>);
-    private send;
-    log(data: unknown): void;
-    error(data: unknown): void;
-    warn(data: unknown): void;
-    info(data: unknown): void;
-    debug(data: unknown): void;
-    decorate(metadata: Record<string, unknown>): void;
-    getMetadata(): Record<string, unknown>;
-    setMetadata(key: string, value: unknown): void;
+    constructor(metadata?: Metadata);
+    /**
+     * Logs a message with the 'log' log level.
+     * @param message The message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    log(message: string, metadata?: Metadata): void;
+    /**
+     * Logs an error message with the 'error' log level.
+     * @param message The error message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    error(message: string, metadata?: Metadata): void;
+    /**
+     * Logs a warning message with the 'warn' log level.
+     * @param message The warning message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    warn(message: string, metadata?: Metadata): void;
+    /**
+     * Logs an informational message with the 'info' log level.
+     * @param message The informational message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    info(message: string, metadata?: Metadata): void;
+    /**
+     * Logs a debug message with the 'debug' log level.
+     * @param message The debug message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    debug(message: string, metadata?: Metadata): void;
+    /**
+     * Decorates the logger with additional metadata.
+     * @param metadata Additional metadata to be added to the logger.
+     */
+    decorate(metadata: Metadata): void;
+    getMetadata(): Metadata;
+    setMetadata<Key extends string>(key: Key extends ForbidenMetadataKey ? never : Key, value: PrimitiveValue | Value): void;
     clearMetadata(): void;
+    private send;
+    private snakifyKeys;
 }
+export {};

package/dist/src/resources/logger.js

@@ -7,30 +7,54 @@ var LogLevel;
     LogLevel["DEBUG"] = "debug";
 })(LogLevel || (LogLevel = {}));
 export default class Logger {
-    metadata = {};
-    constructor(metadata) {
-        if (metadata) {
-            this.metadata = structuredClone(metadata);
-        }
-    }
-    send(logLevel, message) {
-        console[logLevel](JSON.stringify({ message, ...this.metadata }));
+    metadata;
+    constructor(metadata = {}) {
+        this.metadata = structuredClone(metadata);
     }
-    log(data) {
-        this.send(LogLevel.LOG, data);
+    /**
+     * Logs a message with the 'log' log level.
+     * @param message The message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    log(message, metadata) {
+        this.send(LogLevel.LOG, message, metadata);
     }
-    error(data) {
-        this.send(LogLevel.ERROR, data);
+    /**
+     * Logs an error message with the 'error' log level.
+     * @param message The error message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    error(message, metadata) {
+        this.send(LogLevel.ERROR, message, metadata);
     }
-    warn(data) {
-        this.send(LogLevel.WARN, data);
+    /**
+     * Logs a warning message with the 'warn' log level.
+     * @param message The warning message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    warn(message, metadata) {
+        this.send(LogLevel.WARN, message, metadata);
     }
-    info(data) {
-        this.send(LogLevel.INFO, data);
+    /**
+     * Logs an informational message with the 'info' log level.
+     * @param message The informational message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    info(message, metadata) {
+        this.send(LogLevel.INFO, message, metadata);
     }
-    debug(data) {
-        this.send(LogLevel.DEBUG, data);
+    /**
+     * Logs a debug message with the 'debug' log level.
+     * @param message The debug message to be logged.
+     * @param metadata Optional metadata to be associated with the log message.
+     */
+    debug(message, metadata) {
+        this.send(LogLevel.DEBUG, message, metadata);
     }
+    /**
+     * Decorates the logger with additional metadata.
+     * @param metadata Additional metadata to be added to the logger.
+     */
     decorate(metadata) {
         this.metadata = { ...this.metadata, ...metadata };
     }
@@ -43,4 +67,26 @@ export default class Logger {
     clearMetadata() {
         this.metadata = {};
     }
+    send(logLevel, message, metadata) {
+        const processedMessage = this.snakifyKeys({
+            ...this.metadata,
+            ...metadata,
+            message,
+        });
+        if (process.env.NODE_ENV === 'development') {
+            console[logLevel](JSON.stringify(processedMessage, null, 2));
+        }
+        else {
+            console[logLevel](JSON.stringify(processedMessage));
+        }
+    }
+    snakifyKeys(value) {
+        const result = {};
+        for (const key in value) {
+            const deepValue = typeof value[key] === 'object' ? this.snakifyKeys(value[key]) : value[key];
+            const snakifiedKey = key.replace(/[\w](?<!_)([A-Z])/g, k => `${k[0]}_${k[1]}`).toLowerCase();
+            result[snakifiedKey] = deepValue;
+        }
+        return result;
+    }
 }

package/dist/test/errors.test.js

@@ -8,6 +8,7 @@ describe('handleErrorResponse', () => {
         assert.ok(errors.buildHttpError(403, 'forbidden') instanceof httpErrors.UnauthorizedError);
         assert.ok(errors.buildHttpError(404, 'not found') instanceof httpErrors.NotFoundError);
         assert.ok(errors.buildHttpError(408, 'timeout') instanceof httpErrors.TimeoutError);
+        assert.ok(errors.buildHttpError(410, 'resource gone') instanceof httpErrors.ResourceGoneError);
         assert.ok(errors.buildHttpError(422, 'unprocessable entity') instanceof httpErrors.UnprocessableEntityError);
         assert.ok(errors.buildHttpError(429, 'rate limit exceeded') instanceof httpErrors.RateLimitExceededError);
         assert.ok(errors.buildHttpError(500, 'internal server error') instanceof httpErrors.HttpError);

package/dist/test/middlewares/errors.test.js

@@ -39,7 +39,7 @@ describe('errors middleware', () => {
         };
         middleware(new HttpError('httpError', 429), {}, response, () => { });
         assert.strictEqual(actualStatus, 429);
-        assert.strictEqual(actualJson, 'httpError');
+        assert.deepEqual(actualJson, { code: '429', message: 'httpError' });
     });
     it('handles other error', () => {
         let actualStatus;

package/dist/test/resources/cache.test.js

@@ -1,25 +1,17 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 import { LocalCache } from 'cachette';
-import { generateCacheKey, initializeCache } from '../../src/resources/cache.js';
+import { Cache, shutdownCaches } from '../../src/resources/cache.js';
 describe('Cache', () => {
     describe('initializeCache', () => {
-        it('no redis url returns LocalCache', () => {
-            const cache = initializeCache();
-            assert.equal(cache instanceof LocalCache, true);
-            cache.quit();
+        it('no redis url returns Cache with a inner LocalCache', async () => {
+            const cache = Cache.create();
+            assert.ok(cache instanceof Cache);
+            assert.ok(cache['cacheInstance'] instanceof LocalCache);
+            await shutdownCaches();
         });
         it('redis url returns (tries) WriteThroughCache', () => {
-            process.env.REDIS_URL = 'fakeredis'; //'redis://localhost:6379';
-            assert.throws(() => initializeCache(), Error, 'Invalid redis url fakereis.');
-        });
-    });
-    describe('generateCacheKey', () => {
-        it('hashes string and returns hex value', () => {
-            const value = 'test';
-            const hash = generateCacheKey(value);
-            assert.equal(typeof hash, 'string');
-            assert.equal(hash.length, 64);
+            assert.throws(() => Cache.create('fakeredis'), Error, 'Invalid redis url fakereis.');
         });
     });
 });

package/dist/test/resources/logger.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import Logger from '../../src/resources/logger.js';
+import { default as Logger } from '../../src/resources/logger.js';
 describe('Logger', () => {
     it('metadata', () => {
         let metadata = { correlation_id: 'test' };
@@ -33,35 +33,82 @@ describe('Logger', () => {
         logger.log('test');
         assert.strictEqual(logSpy.mock.calls.length, 1);
         assert.deepEqual(logSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ message: 'test', correlation_id: '123456789' }),
+            JSON.stringify({ correlation_id: '123456789', message: 'test' }),
         ]);
         const errorSpy = testContext.mock.method(global.console, 'error', () => { });
         assert.strictEqual(errorSpy.mock.calls.length, 0);
         logger.error('test');
         assert.strictEqual(errorSpy.mock.calls.length, 1);
         assert.deepEqual(errorSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ message: 'test', correlation_id: '123456789' }),
+            JSON.stringify({ correlation_id: '123456789', message: 'test' }),
         ]);
         const warnSpy = testContext.mock.method(global.console, 'warn', () => { });
         assert.strictEqual(warnSpy.mock.calls.length, 0);
         logger.warn('test');
         assert.strictEqual(warnSpy.mock.calls.length, 1);
         assert.deepEqual(warnSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ message: 'test', correlation_id: '123456789' }),
+            JSON.stringify({ correlation_id: '123456789', message: 'test' }),
         ]);
         const infoSpy = testContext.mock.method(global.console, 'info', () => { });
         assert.strictEqual(infoSpy.mock.calls.length, 0);
         logger.info('test');
         assert.strictEqual(infoSpy.mock.calls.length, 1);
         assert.deepEqual(infoSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ message: 'test', correlation_id: '123456789' }),
+            JSON.stringify({ correlation_id: '123456789', message: 'test' }),
         ]);
         const debugSpy = testContext.mock.method(global.console, 'debug', () => { });
         assert.strictEqual(debugSpy.mock.calls.length, 0);
         logger.debug('test');
         assert.strictEqual(debugSpy.mock.calls.length, 1);
         assert.deepEqual(debugSpy.mock.calls[0]?.arguments, [
-            JSON.stringify({ message: 'test', correlation_id: '123456789' }),
+            JSON.stringify({ correlation_id: '123456789', message: 'test' }),
+        ]);
+    });
+    it('merges message payload with metadata', testContext => {
+        const metadata = { correlation_id: '123456789', http: { method: 'GET' } };
+        const logger = new Logger(metadata);
+        const logSpy = testContext.mock.method(global.console, 'log', () => { });
+        assert.strictEqual(logSpy.mock.calls.length, 0);
+        logger.log('test', { error: { code: '200', message: 'Page Not Found' } });
+        assert.strictEqual(logSpy.mock.calls.length, 1);
+        assert.deepEqual(logSpy.mock.calls[0]?.arguments, [
+            JSON.stringify({
+                correlation_id: '123456789',
+                http: { method: 'GET' },
+                error: { code: '200', message: 'Page Not Found' },
+                message: 'test',
+            }),
+        ]);
+    });
+    it('overwrites conflicting metadata keys (1st level) with message payload', testContext => {
+        const metadata = { correlation_id: '123456789', http: { method: 'GET' } };
+        const logger = new Logger(metadata);
+        const logSpy = testContext.mock.method(global.console, 'log', () => { });
+        assert.strictEqual(logSpy.mock.calls.length, 0);
+        logger.log('test', { http: { status_code: 200 } });
+        assert.strictEqual(logSpy.mock.calls.length, 1);
+        assert.deepEqual(logSpy.mock.calls[0]?.arguments, [
+            JSON.stringify({
+                correlation_id: '123456789',
+                http: { status_code: 200 },
+                message: 'test',
+            }),
+        ]);
+    });
+    it('snakify keys of Message and Metadata', testContext => {
+        const metadata = { correlationId: '123456789', http: { method: 'GET', statusCode: 200 } };
+        const logger = new Logger(metadata);
+        const logSpy = testContext.mock.method(global.console, 'log', () => { });
+        assert.strictEqual(logSpy.mock.calls.length, 0);
+        logger.log('test', { errorContext: { errorCode: 200, errorMessage: 'Page Not Found' } });
+        assert.strictEqual(logSpy.mock.calls.length, 1);
+        assert.deepEqual(logSpy.mock.calls[0]?.arguments, [
+            JSON.stringify({
+                correlation_id: '123456789',
+                http: { method: 'GET', status_code: 200 },
+                error_context: { error_code: 200, error_message: 'Page Not Found' },
+                message: 'test',
+            }),
         ]);
     });
 });

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@unito/integration-sdk",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Integration SDK",
   "type": "module",
   "types": "dist/src/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
-    ".": "./dist/src/index.js"
+    ".": {
+      "import": "./dist/src/index.js",
+      "require": "./dist/src/index.cjs"
+    }
   },
   "license": "LicenseRef-LICENSE",
   "engines": {
@@ -21,8 +24,10 @@
     "prepublishOnly": "npm run lint && npm run test",
     "prepare": "npm run compile",
     "lint": "eslint --fix src test --ext .ts && prettier --write src test",
-    "compile": "tsc --build",
-    "compile:watch": "npm run compile -- --watch",
+    "compile": "npm run compile:esm && npm run compile:cjs",
+    "compile:watch": "nodemon --watch \"src/**\" --ext js,ts --exec \"npm run compile\"",
+    "compile:esm": "tsc --build",
+    "compile:cjs": "rollup dist/src/index.js --file dist/src/index.cjs --format cjs",
     "test": "NODE_ENV=test node --test --no-warnings --loader ts-node/esm --test-name-pattern=${ONLY:-.*} $(find test -type f -name '*.test.ts')",
     "test:debug": "NODE_ENV=test node --test --loader ts-node/esm --test-name-pattern=${ONLY:-.*} --inspect-brk $(find test -type f -name '*.test.ts')",
     "ci:test": "npm run test"
@@ -36,7 +41,9 @@
     "c8": "9.x",
     "eslint": "8.x",
     "prettier": "3.x",
+    "rollup": "4.x",
     "ts-node": "10.x",
+    "nodemon": "3.x",
     "typescript": "5.x"
   },
   "dependencies": {