@haathie/pgmb 0.2.8 → 0.2.10

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

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

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, IFindEventsFn, 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, findEvents?: IFindEventsFn): Promise<{
+    map: {
+        [sid: string]: IReadEvent<T>[];
+    };
+    retryEvents: number;
+    retryItemCount: number;
+}>;

package/lib/retry-handler.js

@@ -1,11 +1,7 @@
-"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");
-const defaultFindEvents = queries_ts_1.findEvents.run.bind(queries_ts_1.findEvents);
-function createRetryHandler({ retriesS }, handler) {
+import { RETRY_EVENT } from "./consts.js";
+import { findEvents, scheduleEventRetry } from "./queries.js";
+const defaultFindEvents = findEvents.run.bind(findEvents);
+export function createRetryHandler({ retriesS }, handler) {
     return async (ev, ctx) => {
         const { name, client, subscriptionId, logger } = ctx;
         try {
@@ -18,7 +14,7 @@ function createRetryHandler({ retriesS }, handler) {
             if (!nextRetryGapS) {
                 return;
             }
-            await queries_ts_1.scheduleEventRetry.run({
+            await scheduleEventRetry.run({
                 subscriptionId,
                 ids: ev.items.map(i => i.id),
                 retryNumber: retryNumber + 1,
@@ -28,7 +24,7 @@ function createRetryHandler({ retriesS }, handler) {
         }
     };
 }
-async function normaliseRetryEventsInReadEventMap(rows, client, findEvents = defaultFindEvents) {
+export async function normaliseRetryEventsInReadEventMap(rows, client, findEvents = defaultFindEvents) {
     const map = {};
     const evsToPopulate = [];
     const idsToLoad = [];
@@ -44,7 +40,7 @@ async function normaliseRetryEventsInReadEventMap(rows, client, findEvents = def
     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) {
+            if (item.topic !== RETRY_EVENT) {
                 i++;
                 continue;
             }

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

@@ -1,69 +1,33 @@
-"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 }) {
+import assert, { AssertionError } from 'node:assert';
+import { replayEvents } from "./queries.js";
+import { getCreateDateFromSubscriptionId, getDateFromMessageId } from "./utils.js";
+export 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');
+            assert(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');
+                assert(replayEnabled, 'replay disabled on server');
+                assert(typeof fromEventId === 'string', 'invalid last-event-id header');
+                const fromDt = getDateFromMessageId(fromEventId);
+                assert(fromDt, 'invalid last-event-id header value');
+                assert(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({
+                const fromDt = getDateFromMessageId(fromEventId);
+                const subDt = getCreateDateFromSubscriptionId(sub.id);
+                assert(subDt, 'internal: invalid subscription id format');
+                assert(fromDt >= subDt, 'last-event-id is before subscription creation, cannot replay');
+                eventsToReplay = await replayEvents.run({
                     groupId: this.groupId,
                     subscriptionId: sub.id,
                     fromEventId: fromEventId,
@@ -85,7 +49,7 @@ function createSSERequestHandler({ getSubscriptionOpts, maxReplayEvents = 1000,
             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;
+            const code = err instanceof AssertionError ? 204 : 500;
             res
                 .writeHead(code, message)
                 .end();

package/lib/types.d.ts

@@ -0,0 +1,234 @@
+import type { IDatabaseConnection } from '@pgtyped/runtime';
+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, IFindEventsParams, IFindEventsResult, IReadNextEventsParams, IReadNextEventsResult } from './queries.ts';
+import type { PgClientLike } from './query-types.ts';
+export type ISplitFn<T extends IEventData> = (event: IReadEvent<T>) => IReadEvent<T>[];
+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<T extends IEventData> = {
+    /**
+     * 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;
+    splitBy?: ISplitFn<T>;
+    jsonifier?: JSONifier;
+    serialiseEvent?(ev: IReadEvent, logger: Logger): 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 IReadNextEventsFn = (parmas: IReadNextEventsParams, db: IDatabaseConnection) => Promise<IReadNextEventsResult[]>;
+export type IFindEventsFn = (parmas: IFindEventsParams, db: IDatabaseConnection) => Promise<IFindEventsResult[]>;
+export type Pgmb2ClientOpts<T extends IEventData> = {
+    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 polling for new events from
+     * the global events table.
+     * Only one global call is required across all clients.
+     * Set to 0 to disable polling.
+     *
+     * @default 1 second
+     * */
+    pollEventsIntervalMs?: number;
+    /**
+     * Group level configuration for how often to read new events
+     * relevant to the group's subscriptions.
+     * @default 1 second
+     */
+    readEventsIntervalMs?: 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)
+     * Set to 0 to disable automatic maintenance.
+     *
+     * @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;
+    webhookHandlerOpts?: Partial<PgmbWebhookOpts<T>>;
+    getWebhookInfo?: GetWebhookInfoFn;
+    /**
+     * Override the default readNextEvents implementation
+     */
+    readNextEvents?: IReadNextEventsFn;
+    /**
+     * Override the default findEvents implementation
+     */
+    findEvents?: IFindEventsFn;
+} & 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<T extends IEventData = IEventData> = 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;
+    /**
+     * If provided, will split an incoming event into multiple events
+     * as determined by the function.
+     */
+    splitBy?: ISplitFn<T>;
+};
+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.
+     * This will result in an approximate even split for all processors, the only
+     * caveat being it requires knowing the number of event processors on this
+     * subscription beforehand.
+     */
+    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

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

package/lib/utils.d.ts

@@ -0,0 +1,19 @@
+import type { CreateTopicalSubscriptionOpts, IEventData, RegisterSubscriptionParams } from './types.ts';
+/**
+ * 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;
+/**
+ * Get an environment variable as a number
+ */
+export declare function getEnvNumber(key: string, defaultValue?: number): number;

package/lib/utils.js

@@ -1,17 +1,8 @@
-"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;
-exports.getEnvNumber = getEnvNumber;
-const node_assert_1 = __importDefault(require("node:assert"));
+import assert from 'node:assert';
 /**
  * Extract the date from a message ID, same as the PG function
  */
-function getDateFromMessageId(messageId) {
+export function getDateFromMessageId(messageId) {
     if (!messageId.startsWith('pm')) {
         return undefined;
     }
@@ -25,7 +16,7 @@ function getDateFromMessageId(messageId) {
 /**
  * Extract the date from a subscription ID
  */
-function getCreateDateFromSubscriptionId(id) {
+export function getCreateDateFromSubscriptionId(id) {
     if (!id.startsWith('su')) {
         return undefined;
     }
@@ -36,8 +27,8 @@ function getCreateDateFromSubscriptionId(id) {
  * 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');
+export function createTopicalSubscriptionParams({ topics, partition, additionalFilters = {}, additionalParams = {}, ...rest }) {
+    assert(topics.length > 0, 'At least one topic must be provided');
     const filters = { ...additionalFilters };
     filters['topics'] ||= 'ARRAY[e.topic]';
     if (partition) {
@@ -54,7 +45,7 @@ function createTopicalSubscriptionParams({ topics, partition, additionalFilters
 /**
  * Get an environment variable as a number
  */
-function getEnvNumber(key, defaultValue = 0) {
+export function getEnvNumber(key, defaultValue = 0) {
     const num = +(process.env[key] || defaultValue);
     if (isNaN(num) || !isFinite(num)) {
         return defaultValue;

package/lib/webhook-handler.d.ts

@@ -0,0 +1,6 @@
+import type { IEventData, 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<T extends IEventData>({ timeoutMs, headers, retryOpts, jsonifier, serialiseEvent }: Partial<PgmbWebhookOpts<T>>): IEventHandler;

package/lib/webhook-handler.js

@@ -1,22 +1,16 @@
-"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");
+import assert from 'node:assert';
+import { createHash } from 'node:crypto';
+import { createRetryHandler } from "./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 = {
+export 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'
+        assert(typeof extra === 'object'
             && extra !== null
             && 'url' in extra
             && (typeof extra.url === 'string'
@@ -51,10 +45,10 @@ function createWebhookHandler({ timeoutMs = 5_000, headers, retryOpts = {
     if (!retryOpts) {
         return handler;
     }
-    return (0, retry_handler_ts_1.createRetryHandler)(retryOpts, handler);
+    return createRetryHandler(retryOpts, handler);
 }
 function getIdempotencyKeyHeader(ev) {
-    const hasher = (0, node_crypto_1.createHash)('sha256');
+    const hasher = createHash('sha256');
     for (const item of ev.items) {
         hasher.update(item.id);
     }

package/package.json

@@ -1,18 +1,13 @@
 {
   "name": "@haathie/pgmb",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "PG message broker, with a type-safe typescript client with built-in webhook & SSE support.",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
-  "exports": {
-    ".": {
-      "import": "./src/index.ts",
-      "types": "./src/index.ts",
-      "require": "./lib/index.js"
-    }
-  },
+  "type": "module",
+  "main": "lib/index.js",
   "repository": "https://github.com/haathie/pgmb",
   "scripts": {
     "test": "TZ=UTC NODE_ENV=test node --env-file ./.env.test --test tests/*.test.ts",
@@ -40,7 +35,6 @@
   },
   "files": [
     "lib",
-    "src",
     "sql"
   ],
   "keywords": [

package/sql/pgmb-0.2.0-0.2.8.sql

@@ -5,7 +5,6 @@ ALTER TYPE config_type ADD VALUE 'pg_cron_poll_for_events_cron';
 ALTER TYPE config_type ADD VALUE 'pg_cron_partition_maintenance_cron';
 
 INSERT INTO config(id, value) VALUES
-('poll_chunk_size', '10000'),
 ('pg_cron_poll_for_events_cron', '1 second'),
 -- every 30 minutes
 ('pg_cron_partition_maintenance_cron', '*/30 * * * *');

package/src/abortable-async-iterator.ts

@@ -1,98 +0,0 @@
-import assert from 'assert'
-
-type AAResult<T> = IteratorResult<T>
-
-export class AbortableAsyncIterator<T> implements AsyncIterableIterator<T> {
-	readonly signal: AbortSignal
-	readonly onEnd: () => void
-
-	ended = false
-
-	#resolve: (() => void) | undefined
-	#reject: ((reason?: unknown) => void) | undefined
-	#queue: T[] = []
-	#locked = false
-
-	constructor(signal: AbortSignal, onEnd: () => void = () => {}) {
-		this.signal = signal
-		this.onEnd = onEnd
-		signal.addEventListener('abort', this.#onAbort)
-	}
-
-	async next(): Promise<AAResult<T>> {
-		assert(!this.ended, 'Iterator has already been completed')
-		assert(!this.#locked, 'Concurrent calls to next() are not allowed')
-
-		let nextItem = this.#queue.shift()
-		if(nextItem) {
-			return { value: nextItem, done: false }
-		}
-
-		this.#locked = true
-		try {
-			await this.#setupNextPromise()
-		} finally {
-			this.#locked = false
-		}
-
-		nextItem = this.#queue.shift()
-		if(nextItem) {
-			return { value: nextItem, done: false }
-		}
-
-		return { value: undefined, done: true }
-	}
-
-	enqueue(value: T) {
-		assert(!this.ended, 'Iterator has already been completed')
-		this.#queue.push(value)
-		this.#resolve?.()
-	}
-
-	throw(reason?: unknown): Promise<AAResult<T>> {
-		this.signal.throwIfAborted()
-		this.#reject?.(reason)
-		this.#end()
-		return Promise.resolve({ done: true, value: undefined })
-	}
-
-	return(value?: any): Promise<AAResult<T>> {
-		this.#resolve?.()
-		this.#end()
-		return Promise.resolve({ done: true, value })
-	}
-
-	#setupNextPromise() {
-		return new Promise<void>((resolve, reject) => {
-			this.#resolve = () => {
-				resolve()
-				this.#cleanupTask()
-			}
-
-			this.#reject = err => {
-				reject(err)
-				this.#cleanupTask()
-			}
-		})
-	}
-
-	#cleanupTask() {
-		this.#resolve = undefined
-		this.#reject = undefined
-	}
-
-	#onAbort = (reason: any) => {
-		this.#reject?.(reason)
-		this.#end()
-		this.ended = true
-	}
-
-	#end() {
-		this.signal.removeEventListener('abort', this.#onAbort)
-		this.onEnd()
-	}
-
-	[Symbol.asyncIterator]() {
-		return this
-	}
-}