@haathie/pgmb 0.2.0

package/lib/query-types.d.ts

@@ -0,0 +1,17 @@
+export type QueryResult<T> = {
+    rowCount: number;
+    rows: T[];
+};
+export interface PgClient {
+    query<T = any>(query: string, params?: unknown[]): Promise<QueryResult<T>>;
+    exec?(query: string): Promise<unknown>;
+}
+export interface PgReleasableClient extends PgClient {
+    release: () => void;
+}
+export interface PgPoolLike extends PgClient {
+    connect: () => Promise<PgReleasableClient>;
+    on(ev: 'remove', handler: (cl: PgReleasableClient) => void): this;
+    off(ev: 'remove', handler: (cl: PgReleasableClient) => void): this;
+}
+export type PgClientLike = PgClient | PgPoolLike;

package/lib/query-types.js

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

package/lib/retry-handler.d.ts

@@ -0,0 +1,11 @@
+import type { IReadNextEventsResult } from './queries.ts';
+import type { PgClientLike } from './query-types.ts';
+import type { IEventData, IEventHandler, IReadEvent, IRetryHandlerOpts } from './types.ts';
+export declare function createRetryHandler<T extends IEventData>({ retriesS }: IRetryHandlerOpts, handler: IEventHandler<T>): IEventHandler<T>;
+export declare function normaliseRetryEventsInReadEventMap<T extends IEventData>(rows: IReadNextEventsResult[], client: PgClientLike): Promise<{
+    map: {
+        [sid: string]: IReadEvent<T>[];
+    };
+    retryEvents: number;
+    retryItemCount: number;
+}>;

package/lib/retry-handler.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRetryHandler = createRetryHandler;
+exports.normaliseRetryEventsInReadEventMap = normaliseRetryEventsInReadEventMap;
+const consts_ts_1 = require("./consts.js");
+const queries_ts_1 = require("./queries.js");
+function createRetryHandler({ retriesS }, handler) {
+    return async (ev, ctx) => {
+        const { name, client, subscriptionId, logger } = ctx;
+        try {
+            await handler(ev, ctx);
+        }
+        catch (err) {
+            const retryNumber = (ev.retry?.retryNumber ?? 0);
+            const nextRetryGapS = retriesS[retryNumber];
+            logger.error({ err, nextRetryGapS }, 'error in event handler');
+            if (!nextRetryGapS) {
+                return;
+            }
+            await queries_ts_1.scheduleEventRetry.run({
+                subscriptionId,
+                ids: ev.items.map(i => i.id),
+                retryNumber: retryNumber + 1,
+                delayInterval: `${nextRetryGapS} seconds`,
+                handlerName: name,
+            }, client);
+        }
+    };
+}
+async function normaliseRetryEventsInReadEventMap(rows, client) {
+    const map = {};
+    const evsToPopulate = [];
+    const idsToLoad = [];
+    // reverse the map, do subscriptionId -> events
+    const subToEventMap = {};
+    for (const row of rows) {
+        for (const subId of row.subscriptionIds) {
+            subToEventMap[subId] ||= [];
+            subToEventMap[subId].push(row);
+        }
+    }
+    const subEventList = Object.entries(subToEventMap);
+    for (const [subscriptionId, items] of subEventList) {
+        for (let i = 0; i < items.length; i) {
+            const item = items[i];
+            if (item.topic !== consts_ts_1.RETRY_EVENT) {
+                i++;
+                continue;
+            }
+            const retry = item.payload;
+            if (!retry.ids?.length) {
+                continue;
+            }
+            idsToLoad.push(...retry.ids);
+            map[subscriptionId] ||= [];
+            const ev = { items: [], retry };
+            map[subscriptionId].push(ev);
+            evsToPopulate.push(ev);
+            items.splice(i, 1);
+        }
+        if (!items.length) {
+            continue;
+        }
+        map[subscriptionId] ||= [];
+        map[subscriptionId].push({ items: items });
+    }
+    if (!idsToLoad.length) {
+        return { map, retryEvents: 0, retryItemCount: 0 };
+    }
+    const fetchedEvents = await queries_ts_1.findEvents.run({ ids: idsToLoad }, client);
+    const fetchedEventMap = fetchedEvents.reduce((map, ev) => {
+        map[ev.id] = ev;
+        return map;
+    }, {});
+    // populate the events
+    for (const { items, retry } of evsToPopulate) {
+        if (!retry) {
+            continue;
+        }
+        for (const id of retry.ids) {
+            const ev = fetchedEventMap[id];
+            if (!ev) {
+                continue;
+            }
+            items.push(ev);
+        }
+    }
+    return {
+        map,
+        retryEvents: evsToPopulate.length,
+        retryItemCount: idsToLoad.length,
+    };
+}

package/lib/sse.d.ts

@@ -0,0 +1,4 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { PgmbClient } from './client.ts';
+import type { IEventData, SSERequestHandlerOpts } from './types.ts';
+export declare function createSSERequestHandler<T extends IEventData>(this: PgmbClient<T>, { getSubscriptionOpts, maxReplayEvents, maxReplayIntervalMs, jsonifier }: SSERequestHandlerOpts): (req: IncomingMessage, res: ServerResponse<IncomingMessage>) => Promise<void>;

package/lib/sse.js

@@ -0,0 +1,137 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSSERequestHandler = createSSERequestHandler;
+const node_assert_1 = __importStar(require("node:assert"));
+const queries_ts_1 = require("./queries.js");
+const utils_ts_1 = require("./utils.js");
+function createSSERequestHandler({ getSubscriptionOpts, maxReplayEvents = 1000, maxReplayIntervalMs = 5 * 60 * 1000, jsonifier = JSON }) {
+    const replayEnabled = maxReplayEvents > 0;
+    return handleSSERequest.bind(this);
+    async function handleSSERequest(req, res) {
+        let sub;
+        let eventsToReplay = [];
+        try {
+            (0, node_assert_1.default)(req.method?.toLowerCase() === 'get', 'SSE only supports GET requests');
+            // validate last-event-id header
+            const fromEventId = req.headers['last-event-id'];
+            if (fromEventId) {
+                (0, node_assert_1.default)(replayEnabled, 'replay disabled on server');
+                (0, node_assert_1.default)(typeof fromEventId === 'string', 'invalid last-event-id header');
+                const fromDt = (0, utils_ts_1.getDateFromMessageId)(fromEventId);
+                (0, node_assert_1.default)(fromDt, 'invalid last-event-id header value');
+                (0, node_assert_1.default)(fromDt.getTime() >= (Date.now() - maxReplayIntervalMs), 'last-event-id is too old to replay');
+            }
+            sub = await this.registerFireAndForgetHandler({
+                ...await getSubscriptionOpts(req),
+                expiryInterval: `${maxReplayIntervalMs * 2} milliseconds`
+            });
+            if (fromEventId) {
+                const fromDt = (0, utils_ts_1.getDateFromMessageId)(fromEventId);
+                const subDt = (0, utils_ts_1.getCreateDateFromSubscriptionId)(sub.id);
+                (0, node_assert_1.default)(subDt, 'internal: invalid subscription id format');
+                (0, node_assert_1.default)(fromDt >= subDt, 'last-event-id is before subscription creation, cannot replay');
+                eventsToReplay = await queries_ts_1.replayEvents.run({
+                    groupId: this.groupId,
+                    subscriptionId: sub.id,
+                    fromEventId: fromEventId,
+                    maxEvents: maxReplayEvents
+                }, this.client);
+                this.logger.trace({ subId: sub.id, count: eventsToReplay.length }, 'got events to replay');
+            }
+            if (res.writableEnded) {
+                throw new Error('response already ended');
+            }
+        }
+        catch (err) {
+            this.logger
+                .error({ subId: sub?.id, err }, 'error in sse subscription setup');
+            await sub?.throw(err).catch(() => { });
+            if (res.writableEnded) {
+                return;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            // if an assertion failed, we cannot connect with these parameters
+            // so use 204 No Content
+            const code = err instanceof node_assert_1.AssertionError ? 204 : 500;
+            res
+                .writeHead(code, message)
+                .end();
+            return;
+        }
+        res.once('close', () => {
+            sub?.return();
+        });
+        res.once('error', err => {
+            sub?.throw(err).catch(() => { });
+        });
+        res.writeHead(200, {
+            'content-type': 'text/event-stream',
+            'cache-control': 'no-cache',
+            'connection': 'keep-alive',
+            'transfer-encoding': 'chunked',
+        });
+        res.flushHeaders();
+        try {
+            // send replayed events first
+            writeSseEvents(res, eventsToReplay);
+            for await (const { items } of sub) {
+                writeSseEvents(res, items);
+            }
+        }
+        catch (err) {
+            this.logger.error({ err }, 'error in sse subscription');
+            if (res.writableEnded) {
+                return;
+            }
+            // send error event
+            const message = err instanceof Error ? err.message : String(err);
+            const errData = jsonifier.stringify({ message });
+            res.write(`event: error\ndata: ${errData}\nretry: 250\n\n`);
+            res.end();
+        }
+    }
+    function writeSseEvents(res, items) {
+        for (const { id, payload, topic } of items) {
+            const data = jsonifier.stringify(payload);
+            if (!replayEnabled) {
+                // if replay is disabled, do not send an id field
+                res.write(`event: ${topic}\ndata: ${data}\n\n`);
+                continue;
+            }
+            res.write(`id: ${id}\nevent: ${topic}\ndata: ${data}\n\n`);
+        }
+    }
+}

package/lib/types.d.ts

@@ -0,0 +1,202 @@
+import type { IncomingMessage } from 'node:http';
+import type { Logger } from 'pino';
+import type { HeaderRecord } from 'undici-types/header.js';
+import type { AbortableAsyncIterator } from './abortable-async-iterator.ts';
+import type { IAssertSubscriptionParams } from './queries.ts';
+import type { PgClientLike } from './query-types.ts';
+export type SerialisedEvent = {
+    body: Buffer | string;
+    contentType: string;
+};
+export type WebhookInfo = {
+    id: string;
+    url: string | URL;
+};
+export type GetWebhookInfoFn = (subscriptionIds: string[]) => Promise<{
+    [id: string]: WebhookInfo[];
+}> | {
+    [id: string]: WebhookInfo[];
+};
+export type PgmbWebhookOpts = {
+    /**
+     * Maximum time to wait for webhook request to complete
+     * @default 5 seconds
+     */
+    timeoutMs?: number;
+    headers?: HeaderRecord;
+    /**
+     * Configure retry intervals in seconds for failed webhook requests.
+     * If null, a failed handler will fail the event processor. Use carefully.
+     */
+    retryOpts?: IRetryHandlerOpts | null;
+    jsonifier?: JSONifier;
+    serialiseEvent?(ev: IReadEvent): SerialisedEvent;
+};
+export interface IEventData {
+    topic: string;
+    payload: unknown;
+    metadata?: unknown;
+}
+export type IEvent<T extends IEventData> = (T & {
+    id: string;
+});
+export type PGMBEventBatcherOpts<T extends IEventData> = {
+    /**
+     * Whether a particular published message should be logged.
+     * By default, all messages are logged -- in case of certain
+     * failures, the logs can be used to replay the messages.
+     */
+    shouldLog?(msg: T): boolean;
+    publish(...msgs: T[]): Promise<{
+        id: string;
+    }[]>;
+    logger?: Logger;
+    /**
+     * Automatically flush after this interval.
+     * Set to undefined or 0 to disable. Will need to
+     * manually call `flush()` to publish messages.
+     * @default undefined
+     */
+    flushIntervalMs?: number;
+    /**
+     * Max number of messages to send in a batch
+     * @default 2500
+     */
+    maxBatchSize?: number;
+};
+export type Pgmb2ClientOpts = {
+    client: PgClientLike;
+    /**
+     * Globally unique identifier for this Pgmb2Client instance. All subs
+     * registered with this client will use this groupId.
+     */
+    groupId: string;
+    logger?: Logger;
+    /** How long to sleep between polls & read fn calls */
+    sleepDurationMs?: number;
+    /**
+     * How often to mark subscriptions as active,
+     * and remove expired ones.
+     * @default 1 minute
+     */
+    subscriptionMaintenanceMs?: number;
+    /** How often to maintain the events tables
+     * (drop old partitions, create new ones, etc)
+     * @default 5 minutes
+     */
+    tableMaintainanceMs?: number;
+    readChunkSize?: number;
+    /**
+     * As we process in batches, a single handler taking time to finish
+     * can lead to buildup of unprocessed checkpoints. To avoid this,
+     * we keep moving forward while handlers run in the background, but
+     * to avoid an unbounded number of items being backlogged, we limit
+     * how much further we can go ahead from the earliest uncompleted checkpoint.
+     * @default 10
+     */
+    maxActiveCheckpoints?: number;
+    /**
+     * Should this client poll for new events?
+     * @default true
+     */
+    poll?: boolean;
+    webhookHandlerOpts?: Partial<PgmbWebhookOpts>;
+    getWebhookInfo?: GetWebhookInfoFn;
+} & Pick<PGMBEventBatcherOpts<IEventData>, 'flushIntervalMs' | 'maxBatchSize' | 'shouldLog'>;
+export type IReadEvent<T extends IEventData = IEventData> = {
+    items: IEvent<T>[];
+    retry?: IRetryEventPayload;
+};
+export type RegisterSubscriptionParams = Omit<IAssertSubscriptionParams, 'groupId'>;
+export type registerReliableHandlerParams = RegisterSubscriptionParams & {
+    /**
+     * Name for the retry handler, used to ensure retries for a particular
+     * handler are not mixed with another handler. This name need only be
+     * unique for a particular subscription.
+    */
+    name?: string;
+    retryOpts?: IRetryHandlerOpts;
+};
+export type CreateTopicalSubscriptionOpts<T extends IEventData> = {
+    /**
+     * The topics to subscribe to.
+     */
+    topics: T['topic'][];
+    /**
+     * To scale out processing, you can partition the subscriptions.
+     * For example, with `current: 0, total: 3`, only messages
+     * where `hashtext(e.id) % 3 == 0` will be received by this subscription.
+     */
+    partition?: {
+        current: number;
+        total: number;
+    };
+    /**
+     * Add any additional params to filter by.
+     * i.e "s.params @> jsonb_build_object(...additionalFilters)"
+     * The value should be a valid SQL snippet.
+     */
+    additionalFilters?: Record<string, string>;
+    /** JSON to populate params */
+    additionalParams?: Record<string, any>;
+    expiryInterval?: RegisterSubscriptionParams['expiryInterval'];
+};
+export interface IEphemeralListener<T extends IEventData> extends AbortableAsyncIterator<IReadEvent<T>> {
+    id: string;
+}
+export type IEventHandlerContext = {
+    logger: Logger;
+    client: PgClientLike;
+    subscriptionId: string;
+    /** registered name of the handler */
+    name: string;
+    extra?: unknown;
+};
+export type IEventHandler<T extends IEventData = IEventData> = (item: IReadEvent<T>, ctx: IEventHandlerContext) => Promise<void>;
+export type IRetryEventPayload = {
+    ids: string[];
+    handlerName: string;
+    retryNumber: number;
+};
+type SSESubscriptionOpts = Pick<RegisterSubscriptionParams, 'conditionsSql' | 'params'>;
+export type SSERequestHandlerOpts = {
+    getSubscriptionOpts(req: IncomingMessage): Promise<SSESubscriptionOpts> | SSESubscriptionOpts;
+    /**
+     * Maximum interval to replay events for an SSE subscription.
+     * @default 5 minutes
+     */
+    maxReplayIntervalMs?: number;
+    /**
+     * Max number of events to replay for an SSE subscription.
+     * Set to 0 to disable replaying events.
+     * @default 1000
+     */
+    maxReplayEvents?: number;
+    jsonifier?: JSONifier;
+};
+export type IRetryHandlerOpts = {
+    retriesS: number[];
+};
+export interface JSONifier {
+    stringify(data: unknown): string;
+    parse(data: string): unknown;
+}
+export type ITableMutationEventData<T, N extends string> = {
+    topic: `${N}.insert`;
+    payload: T;
+    metadata: {};
+} | {
+    topic: `${N}.delete`;
+    payload: T;
+    metadata: {};
+} | {
+    topic: `${N}.update`;
+    /**
+     * The fields that were updated in the row
+     */
+    payload: Partial<T>;
+    metadata: {
+        old: T;
+    };
+};
+export {};

package/lib/types.js

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

package/lib/utils.d.ts

@@ -0,0 +1,15 @@
+import type { CreateTopicalSubscriptionOpts, IEventData, RegisterSubscriptionParams } from './types';
+/**
+ * Extract the date from a message ID, same as the PG function
+ */
+export declare function getDateFromMessageId(messageId: string): Date | undefined;
+/**
+ * Extract the date from a subscription ID
+ */
+export declare function getCreateDateFromSubscriptionId(id: string): Date | undefined;
+/**
+ * Creates subscription params for a subscription that matches
+ * 1 or more topics. Also supports partitioning the subscription
+ * such that only a subset of messages are received.
+ */
+export declare function createTopicalSubscriptionParams<T extends IEventData>({ topics, partition, additionalFilters, additionalParams, ...rest }: CreateTopicalSubscriptionOpts<T>): RegisterSubscriptionParams;

package/lib/utils.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDateFromMessageId = getDateFromMessageId;
+exports.getCreateDateFromSubscriptionId = getCreateDateFromSubscriptionId;
+exports.createTopicalSubscriptionParams = createTopicalSubscriptionParams;
+const node_assert_1 = __importDefault(require("node:assert"));
+/**
+ * Extract the date from a message ID, same as the PG function
+ */
+function getDateFromMessageId(messageId) {
+    if (!messageId.startsWith('pm')) {
+        return undefined;
+    }
+    const micros = parseInt(messageId.slice(2, 15), 16);
+    if (isNaN(micros)) {
+        return undefined;
+    }
+    const date = new Date(micros / 1000);
+    return date;
+}
+/**
+ * Extract the date from a subscription ID
+ */
+function getCreateDateFromSubscriptionId(id) {
+    if (!id.startsWith('su')) {
+        return undefined;
+    }
+    return getDateFromMessageId('pm' + id.slice(2));
+}
+/**
+ * Creates subscription params for a subscription that matches
+ * 1 or more topics. Also supports partitioning the subscription
+ * such that only a subset of messages are received.
+ */
+function createTopicalSubscriptionParams({ topics, partition, additionalFilters = {}, additionalParams = {}, ...rest }) {
+    (0, node_assert_1.default)(topics.length > 0, 'At least one topic must be provided');
+    const filters = { ...additionalFilters };
+    filters['topics'] ||= 'ARRAY[e.topic]';
+    if (partition) {
+        filters['partition'] = `hashtext(e.id) % ${partition.total}`;
+    }
+    const strs = Object.entries(filters)
+        .map(([k, v]) => `'${k}',${v}`);
+    return {
+        conditionsSql: `s.params @> jsonb_build_object(${strs.join(',')})`,
+        params: { topics, partition: partition?.current, ...additionalParams },
+        ...rest
+    };
+}

package/lib/webhook-handler.d.ts

@@ -0,0 +1,6 @@
+import type { IEventHandler, PgmbWebhookOpts } from './types.ts';
+/**
+ * Create a handler that sends events to a webhook URL via HTTP POST.
+ * @param url Where to send the webhook requests
+ */
+export declare function createWebhookHandler({ timeoutMs, headers, retryOpts, jsonifier, serialiseEvent }: Partial<PgmbWebhookOpts>): IEventHandler;

package/lib/webhook-handler.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebhookHandler = createWebhookHandler;
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_crypto_1 = require("node:crypto");
+const retry_handler_ts_1 = require("./retry-handler.js");
+/**
+ * Create a handler that sends events to a webhook URL via HTTP POST.
+ * @param url Where to send the webhook requests
+ */
+function createWebhookHandler({ timeoutMs = 5_000, headers, retryOpts = {
+    // retry after 5 minutes, then after 30 minutes
+    retriesS: [5 * 60, 30 * 60]
+}, jsonifier = JSON, serialiseEvent = createSimpleSerialiser(jsonifier) }) {
+    const handler = async (ev, { logger, extra }) => {
+        (0, node_assert_1.default)(typeof extra === 'object'
+            && extra !== null
+            && 'url' in extra
+            && (typeof extra.url === 'string'
+                || extra.url instanceof URL), 'webhook handler requires extra.url parameter');
+        const { url } = extra;
+        const { body, contentType } = serialiseEvent(ev);
+        const { status, statusText, body: res } = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': contentType,
+                'idempotency-key': getIdempotencyKeyHeader(ev),
+                ...headers
+            },
+            body,
+            redirect: 'manual',
+            signal: AbortSignal.timeout(timeoutMs)
+        });
+        // don't care about response body
+        await res?.cancel().catch(() => { });
+        // see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Idempotency-Key
+        if (status === 422) { // unprocessable request, do not retry
+            logger.warn('webhook returned 422, dropping event');
+            return;
+        }
+        if (status < 200 || status >= 300) {
+            throw new Error(`Non-2xx response: ${status} (${statusText})`);
+        }
+    };
+    if (!retryOpts) {
+        return handler;
+    }
+    return (0, retry_handler_ts_1.createRetryHandler)(retryOpts, handler);
+}
+function getIdempotencyKeyHeader(ev) {
+    const hasher = (0, node_crypto_1.createHash)('sha256');
+    for (const item of ev.items) {
+        hasher.update(item.id);
+    }
+    return hasher.digest('hex').slice(0, 16);
+}
+function createSimpleSerialiser(jsonifier) {
+    return ev => ({
+        body: jsonifier.stringify({
+            items: ev.items
+                .map(({ id, payload, topic }) => ({ id, payload, topic }))
+        }),
+        contentType: 'application/json'
+    });
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@haathie/pgmb",
+  "version": "0.2.0",
+  "description": "Postgres Message Broker",
+  "main": "lib/index.js",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": "https://github.com/haathie/pgmb",
+  "scripts": {
+    "test": "TZ=UTC NODE_ENV=test node --env-file ./.env.test --test tests/*.test.ts",
+    "prepare": "tsc",
+    "build": "tsc",
+    "lint": "eslint ./ --ext .js,.ts,.jsx,.tsx",
+    "lint:fix": "eslint ./ --fix --ext .js,.ts,.jsx,.tsx",
+    "benchmark": "TZ=utc node --env-file ./.env.test src/benchmark/run.ts",
+    "gen:pgtyped": "pgtyped --config ./pgtyped.config.json"
+  },
+  "devDependencies": {
+    "@adiwajshing/eslint-config": "git+https://github.com/adiwajshing/eslint-config",
+    "@pgtyped/cli": "^2.4.3",
+    "@types/amqplib": "^0.10.0",
+    "@types/chance": "^1.1.6",
+    "@types/jest": "^27.0.0",
+    "@types/node": "^24.0.0",
+    "@types/pg": "^8.11.14",
+    "amqplib": "^0.10.7",
+    "chance": "^1.1.12",
+    "eslint": "^8.19.0",
+    "eventsource": "^4.1.0",
+    "pg": "^8.16.3",
+    "typescript": "^5.0.0"
+  },
+  "files": [
+    "lib",
+    "sql"
+  ],
+  "keywords": [
+    "postgres",
+    "message-broker",
+    "pgmb",
+    "pg-mb",
+    "postgres-message-broker"
+  ],
+  "author": "Adhiraj Singh",
+  "license": "MIT",
+  "dependencies": {
+    "@pgtyped/runtime": "^2.4.2",
+    "pino": "^9.0.0"
+  }
+}