@haathie/pgmb 0.2.6 → 0.2.7

package/lib/batcher.d.ts

@@ -1,12 +0,0 @@
-import type { IEventData, PGMBEventBatcherOpts } from './types.ts';
-export declare class PGMBEventBatcher<T extends IEventData> {
-    #private;
-    constructor({ shouldLog, publish, flushIntervalMs, maxBatchSize, logger }: PGMBEventBatcherOpts<T>);
-    end(): Promise<void>;
-    /**
-     * Enqueue a message to be published, will be flushed to the database
-     * when flush() is called (either manually or via interval)
-     */
-    enqueue(msg: T): void;
-    flush(): Promise<void>;
-}

package/lib/client.d.ts

@@ -1,76 +0,0 @@
-import { type Logger } from 'pino';
-import { PGMBEventBatcher } from './batcher.ts';
-import type { PgClientLike } from './query-types.ts';
-import type { GetWebhookInfoFn, IEphemeralListener, IEventData, IEventHandler, IFindEventsFn, IReadEvent, IReadNextEventsFn, ISplitFn, Pgmb2ClientOpts, registerReliableHandlerParams, RegisterSubscriptionParams } from './types.ts';
-type IReliableListener<T extends IEventData> = {
-    type: 'reliable';
-    handler: IEventHandler<T>;
-    removeOnEmpty?: boolean;
-    extra?: unknown;
-    splitBy?: ISplitFn<T>;
-    queue: {
-        item: IReadEvent<T>;
-        checkpoint: Checkpoint;
-    }[];
-};
-type IFireAndForgetListener<T extends IEventData> = {
-    type: 'fire-and-forget';
-    stream: IEphemeralListener<T>;
-};
-type IListener<T extends IEventData> = IFireAndForgetListener<T> | IReliableListener<T>;
-type Checkpoint = {
-    activeTasks: number;
-    nextCursor: string;
-    cancelled?: boolean;
-};
-export type IListenerStore<T extends IEventData> = {
-    values: {
-        [id: string]: IListener<T>;
-    };
-};
-export declare class PgmbClient<T extends IEventData = IEventData> extends PGMBEventBatcher<T> {
-    #private;
-    readonly client: PgClientLike;
-    readonly logger: Logger;
-    readonly groupId: string;
-    readonly sleepDurationMs: number;
-    readonly readChunkSize: number;
-    readonly subscriptionMaintenanceMs: number;
-    readonly tableMaintenanceMs: number;
-    readonly maxActiveCheckpoints: number;
-    readonly readNextEvents: IReadNextEventsFn;
-    readonly findEvents?: IFindEventsFn;
-    readonly getWebhookInfo: GetWebhookInfoFn;
-    readonly webhookHandler: IEventHandler<T>;
-    readonly listeners: {
-        [subId: string]: IListenerStore<T>;
-    };
-    constructor({ client, groupId, logger, sleepDurationMs, readChunkSize, maxActiveCheckpoints, poll, subscriptionMaintenanceMs, webhookHandlerOpts: { splitBy: whSplitBy, ...whHandlerOpts }, getWebhookInfo, tableMaintainanceMs, readNextEvents, findEvents, ...batcherOpts }: Pgmb2ClientOpts<T>);
-    init(): Promise<void>;
-    end(): Promise<void>;
-    publish(events: T[], client?: PgClientLike): Promise<import("./queries.ts").IWriteEventsResult[]>;
-    assertSubscription(opts: RegisterSubscriptionParams, client?: PgClientLike): Promise<import("./queries.ts").IAssertSubscriptionResult>;
-    /**
-     * Registers a fire-and-forget handler, returning an async iterator
-     * that yields events as they arrive. The client does not wait for event
-     * processing acknowledgements. Useful for cases where data is eventually
-     * consistent, or when event delivery isn't critical
-     * (eg. http SSE, websockets).
-     */
-    registerFireAndForgetHandler(opts: RegisterSubscriptionParams): Promise<IEphemeralListener<T>>;
-    /**
-     * Registers a reliable handler for the given subscription params.
-     * If the handler throws an error, client will rollback to the last known
-     * good cursor, and re-deliver events.
-     * To avoid a full redelivery of a batch, a retry strategy can be provided
-     * to retry failed events by the handler itself, allowing for delayed retries
-     * with backoff, and without disrupting the overall event flow.
-     */
-    registerReliableHandler({ retryOpts, name, splitBy, ...opts }: registerReliableHandlerParams<T>, handler: IEventHandler<T>): Promise<{
-        subscriptionId: string;
-        cancel: () => void;
-    }>;
-    removeSubscription(subId: string): Promise<void>;
-    readChanges(): Promise<number>;
-}
-export {};

package/lib/consts.d.ts

@@ -1 +0,0 @@
-export declare const RETRY_EVENT = "pgmb-retry";

package/lib/index.d.ts

@@ -1,6 +0,0 @@
-export * from './client.ts';
-export type * from './types.ts';
-export type * from './query-types.ts';
-export * from './utils.ts';
-export * from './sse.ts';
-export * from './queries.ts';

package/lib/queries.d.ts

@@ -1,453 +0,0 @@
-/** Types generated for queries found in "sql/queries.sql" */
-import { PreparedQuery } from '@pgtyped/runtime';
-export type DateOrString = Date | string;
-export type DateOrStringArray = (DateOrString)[];
-export type stringArray = (string)[];
-export type unknownArray = (unknown)[];
-/** 'AssertGroup' parameters type */
-export interface IAssertGroupParams {
-    id: string;
-}
-/** 'AssertGroup' return type */
-export type IAssertGroupResult = void;
-/** 'AssertGroup' query type */
-export interface IAssertGroupQuery {
-    params: IAssertGroupParams;
-    result: IAssertGroupResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * INSERT INTO pgmb.subscription_groups (id)
- * VALUES (:id!)
- * ON CONFLICT DO NOTHING
- * ```
- */
-export declare const assertGroup: PreparedQuery<IAssertGroupParams, void>;
-/** 'AssertSubscription' parameters type */
-export interface IAssertSubscriptionParams {
-    conditionsSql?: string | null | void;
-    expiryInterval?: DateOrString | null | void;
-    groupId: string;
-    params?: unknown | null | void;
-}
-/** 'AssertSubscription' return type */
-export interface IAssertSubscriptionResult {
-    id: string;
-}
-/** 'AssertSubscription' query type */
-export interface IAssertSubscriptionQuery {
-    params: IAssertSubscriptionParams;
-    result: IAssertSubscriptionResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * INSERT INTO pgmb.subscriptions
- * 	AS s(group_id, conditions_sql, params, expiry_interval)
- * VALUES (
- * 	:groupId!,
- * 	COALESCE(:conditionsSql, 'TRUE'),
- * 	COALESCE(:params::jsonb, '{}'),
- * 	:expiryInterval::interval
- * )
- * ON CONFLICT (identity) DO UPDATE
- * SET
- * 	-- set expiry_interval to the new value only if it's greater than the existing one
- * 	-- or if the new value is NULL (indicating no expiration)
- * 	expiry_interval = CASE
- * 		WHEN EXCLUDED.expiry_interval IS NULL OR s.expiry_interval IS NULL
- * 			THEN NULL
- * 		ELSE
- * 			GREATEST(s.expiry_interval, EXCLUDED.expiry_interval)
- * 	END,
- * 	last_active_at = NOW()
- * RETURNING id AS "id!"
- * ```
- */
-export declare const assertSubscription: PreparedQuery<IAssertSubscriptionParams, IAssertSubscriptionResult>;
-/** 'DeleteSubscriptions' parameters type */
-export interface IDeleteSubscriptionsParams {
-    ids: readonly (string)[];
-}
-/** 'DeleteSubscriptions' return type */
-export type IDeleteSubscriptionsResult = void;
-/** 'DeleteSubscriptions' query type */
-export interface IDeleteSubscriptionsQuery {
-    params: IDeleteSubscriptionsParams;
-    result: IDeleteSubscriptionsResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * DELETE FROM pgmb.subscriptions
- * WHERE id IN :ids!
- * ```
- */
-export declare const deleteSubscriptions: PreparedQuery<IDeleteSubscriptionsParams, void>;
-/** 'MarkSubscriptionsActive' parameters type */
-export interface IMarkSubscriptionsActiveParams {
-    ids: stringArray;
-}
-/** 'MarkSubscriptionsActive' return type */
-export type IMarkSubscriptionsActiveResult = void;
-/** 'MarkSubscriptionsActive' query type */
-export interface IMarkSubscriptionsActiveQuery {
-    params: IMarkSubscriptionsActiveParams;
-    result: IMarkSubscriptionsActiveResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * UPDATE pgmb.subscriptions
- * SET
- * 	last_active_at = NOW()
- * WHERE id IN (SELECT * FROM unnest(:ids!::pgmb.subscription_id[]))
- * ```
- */
-export declare const markSubscriptionsActive: PreparedQuery<IMarkSubscriptionsActiveParams, void>;
-/** 'PollForEvents' parameters type */
-export type IPollForEventsParams = void;
-/** 'PollForEvents' return type */
-export interface IPollForEventsResult {
-    count: number;
-}
-/** 'PollForEvents' query type */
-export interface IPollForEventsQuery {
-    params: IPollForEventsParams;
-    result: IPollForEventsResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * SELECT count AS "count!" FROM pgmb.poll_for_events() AS count
- * ```
- */
-export declare const pollForEvents: PreparedQuery<void, IPollForEventsResult>;
-/** 'ReadNextEvents' parameters type */
-export interface IReadNextEventsParams {
-    chunkSize: number;
-    cursor?: string | null | void;
-    groupId: string;
-}
-/** 'ReadNextEvents' return type */
-export interface IReadNextEventsResult {
-    id: string;
-    metadata: unknown;
-    nextCursor: string;
-    payload: unknown;
-    subscriptionIds: stringArray;
-    topic: string;
-}
-/** 'ReadNextEvents' query type */
-export interface IReadNextEventsQuery {
-    params: IReadNextEventsParams;
-    result: IReadNextEventsResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * SELECT
- * 	id AS "id!",
- * 	topic AS "topic!",
- * 	payload AS "payload!",
- * 	metadata AS "metadata!",
- * 	subscription_ids::text[] AS "subscriptionIds!",
- * 	next_cursor AS "nextCursor!"
- * FROM pgmb.read_next_events(:groupId!, :cursor, :chunkSize!)
- * ```
- */
-export declare const readNextEvents: PreparedQuery<IReadNextEventsParams, IReadNextEventsResult>;
-/** 'ReadNextEventsText' parameters type */
-export interface IReadNextEventsTextParams {
-    chunkSize: number;
-    cursor?: string | null | void;
-    groupId: string;
-}
-/** 'ReadNextEventsText' return type */
-export interface IReadNextEventsTextResult {
-    id: string;
-    payload: string;
-    topic: string;
-}
-/** 'ReadNextEventsText' query type */
-export interface IReadNextEventsTextQuery {
-    params: IReadNextEventsTextParams;
-    result: IReadNextEventsTextResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * SELECT
- * 	id AS "id!",
- * 	topic AS "topic!",
- * 	payload::text AS "payload!"
- * FROM pgmb.read_next_events(:groupId!, :cursor, :chunkSize!)
- * ```
- */
-export declare const readNextEventsText: PreparedQuery<IReadNextEventsTextParams, IReadNextEventsTextResult>;
-/** 'ReplayEvents' parameters type */
-export interface IReplayEventsParams {
-    fromEventId: string;
-    groupId: string;
-    maxEvents: number;
-    subscriptionId: string;
-}
-/** 'ReplayEvents' return type */
-export interface IReplayEventsResult {
-    id: string;
-    metadata: unknown;
-    payload: unknown;
-    topic: string;
-}
-/** 'ReplayEvents' query type */
-export interface IReplayEventsQuery {
-    params: IReplayEventsParams;
-    result: IReplayEventsResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * SELECT
- * 	id AS "id!",
- * 	topic AS "topic!",
- * 	payload AS "payload!",
- * 	metadata AS "metadata!"
- * FROM pgmb.replay_events(
- * 	:groupId!,
- * 	:subscriptionId!,
- * 	:fromEventId!::pgmb.event_id,
- * 	:maxEvents!
- * )
- * ```
- */
-export declare const replayEvents: PreparedQuery<IReplayEventsParams, IReplayEventsResult>;
-/** 'SetGroupCursor' parameters type */
-export interface ISetGroupCursorParams {
-    cursor: string;
-    groupId: string;
-    releaseLock?: boolean | null | void;
-}
-/** 'SetGroupCursor' return type */
-export interface ISetGroupCursorResult {
-    success: undefined;
-}
-/** 'SetGroupCursor' query type */
-export interface ISetGroupCursorQuery {
-    params: ISetGroupCursorParams;
-    result: ISetGroupCursorResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * SELECT pgmb.set_group_cursor(
- * 	:groupId!,
- * 	:cursor!::pgmb.event_id,
- * 	:releaseLock::boolean
- * ) AS "success!"
- * ```
- */
-export declare const setGroupCursor: PreparedQuery<ISetGroupCursorParams, ISetGroupCursorResult>;
-/** 'ReleaseGroupLock' parameters type */
-export interface IReleaseGroupLockParams {
-    groupId: string;
-}
-/** 'ReleaseGroupLock' return type */
-export interface IReleaseGroupLockResult {
-    success: undefined;
-}
-/** 'ReleaseGroupLock' query type */
-export interface IReleaseGroupLockQuery {
-    params: IReleaseGroupLockParams;
-    result: IReleaseGroupLockResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * SELECT pgmb.release_group_lock(:groupId!) AS "success!"
- * ```
- */
-export declare const releaseGroupLock: PreparedQuery<IReleaseGroupLockParams, IReleaseGroupLockResult>;
-/** 'WriteEvents' parameters type */
-export interface IWriteEventsParams {
-    metadatas: unknownArray;
-    payloads: unknownArray;
-    topics: stringArray;
-}
-/** 'WriteEvents' return type */
-export interface IWriteEventsResult {
-    id: string;
-}
-/** 'WriteEvents' query type */
-export interface IWriteEventsQuery {
-    params: IWriteEventsParams;
-    result: IWriteEventsResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * INSERT INTO pgmb.events (topic, payload, metadata)
- * SELECT
- * 	topic,
- * 	payload,
- * 	metadata
- * FROM unnest(
- * 	:topics!::TEXT[],
- * 	:payloads!::JSONB[],
- * 	:metadatas!::JSONB[]
- * ) AS t(topic, payload, metadata)
- * RETURNING id AS "id!"
- * ```
- */
-export declare const writeEvents: PreparedQuery<IWriteEventsParams, IWriteEventsResult>;
-/** 'WriteScheduledEvents' parameters type */
-export interface IWriteScheduledEventsParams {
-    metadatas: unknownArray;
-    payloads: unknownArray;
-    topics: stringArray;
-    ts: DateOrStringArray;
-}
-/** 'WriteScheduledEvents' return type */
-export interface IWriteScheduledEventsResult {
-    id: string;
-}
-/** 'WriteScheduledEvents' query type */
-export interface IWriteScheduledEventsQuery {
-    params: IWriteScheduledEventsParams;
-    result: IWriteScheduledEventsResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * INSERT INTO pgmb.events (id, topic, payload, metadata)
- * SELECT
- * 	pgmb.create_event_id(COALESCE(ts, clock_timestamp()), pgmb.create_random_bigint()),
- * 	topic,
- * 	payload,
- * 	metadata
- * FROM unnest(
- * 	:ts!::TIMESTAMPTZ[],
- * 	:topics!::TEXT[],
- * 	:payloads!::JSONB[],
- * 	:metadatas!::JSONB[]
- * ) AS t(ts, topic, payload, metadata)
- * RETURNING id AS "id!"
- * ```
- */
-export declare const writeScheduledEvents: PreparedQuery<IWriteScheduledEventsParams, IWriteScheduledEventsResult>;
-/** 'ScheduleEventRetry' parameters type */
-export interface IScheduleEventRetryParams {
-    delayInterval: DateOrString;
-    handlerName: string;
-    ids: stringArray;
-    retryNumber: number;
-    subscriptionId: string;
-}
-/** 'ScheduleEventRetry' return type */
-export interface IScheduleEventRetryResult {
-    id: string;
-}
-/** 'ScheduleEventRetry' query type */
-export interface IScheduleEventRetryQuery {
-    params: IScheduleEventRetryParams;
-    result: IScheduleEventRetryResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * INSERT INTO pgmb.events (id, topic, payload, subscription_id)
- * SELECT
- * 	pgmb.create_event_id(
- * 		NOW() + (:delayInterval!::INTERVAL),
- * 		pgmb.create_random_bigint()
- * 	),
- * 	'pgmb-retry',
- * 	jsonb_build_object(
- * 		'ids',
- * 		:ids!::pgmb.event_id[],
- * 		'retryNumber',
- * 		:retryNumber!::int,
- * 		'handlerName',
- * 		:handlerName!::text
- * 	),
- * 	:subscriptionId!::pgmb.subscription_id
- * RETURNING id AS "id!"
- * ```
- */
-export declare const scheduleEventRetry: PreparedQuery<IScheduleEventRetryParams, IScheduleEventRetryResult>;
-/** 'FindEvents' parameters type */
-export interface IFindEventsParams {
-    ids: stringArray;
-}
-/** 'FindEvents' return type */
-export interface IFindEventsResult {
-    id: string;
-    metadata: unknown;
-    payload: unknown;
-    topic: string;
-}
-/** 'FindEvents' query type */
-export interface IFindEventsQuery {
-    params: IFindEventsParams;
-    result: IFindEventsResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * SELECT
- * 	id AS "id!",
- * 	topic AS "topic!",
- * 	payload AS "payload!",
- * 	metadata AS "metadata!"
- * FROM pgmb.events
- * WHERE id = ANY(:ids!::pgmb.event_id[])
- * ```
- */
-export declare const findEvents: PreparedQuery<IFindEventsParams, IFindEventsResult>;
-/** 'RemoveExpiredSubscriptions' parameters type */
-export interface IRemoveExpiredSubscriptionsParams {
-    activeIds: stringArray;
-    groupId: string;
-}
-/** 'RemoveExpiredSubscriptions' return type */
-export interface IRemoveExpiredSubscriptionsResult {
-    deleted: string;
-}
-/** 'RemoveExpiredSubscriptions' query type */
-export interface IRemoveExpiredSubscriptionsQuery {
-    params: IRemoveExpiredSubscriptionsParams;
-    result: IRemoveExpiredSubscriptionsResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * WITH deleted AS (
- * 	DELETE FROM pgmb.subscriptions
- * 	WHERE group_id = :groupId!
- * 		AND expiry_interval IS NOT NULL
- * 		AND pgmb.add_interval_imm(last_active_at, expiry_interval) < NOW()
- * 		AND id NOT IN (select * from unnest(:activeIds!::pgmb.subscription_id[]))
- * 	RETURNING id
- * )
- * SELECT COUNT(*) AS "deleted!" FROM deleted
- * ```
- */
-export declare const removeExpiredSubscriptions: PreparedQuery<IRemoveExpiredSubscriptionsParams, IRemoveExpiredSubscriptionsResult>;
-/** 'MaintainEventsTable' parameters type */
-export type IMaintainEventsTableParams = void;
-/** 'MaintainEventsTable' return type */
-export interface IMaintainEventsTableResult {
-    maintainEventsTable: undefined | null;
-}
-/** 'MaintainEventsTable' query type */
-export interface IMaintainEventsTableQuery {
-    params: IMaintainEventsTableParams;
-    result: IMaintainEventsTableResult;
-}
-/**
- * Query generated from SQL:
- * ```
- * SELECT pgmb.maintain_events_table()
- * ```
- */
-export declare const maintainEventsTable: PreparedQuery<void, IMaintainEventsTableResult>;

package/lib/query-types.d.ts

@@ -1,17 +0,0 @@
-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/retry-handler.d.ts

@@ -1,11 +0,0 @@
-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/sse.d.ts

@@ -1,4 +0,0 @@
-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>;