@haathie/pgmb 0.2.0

package/lib/queries.d.ts

@@ -0,0 +1,453 @@
+/** 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/queries.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maintainEventsTable = exports.removeExpiredSubscriptions = exports.findEvents = exports.scheduleEventRetry = exports.writeScheduledEvents = exports.writeEvents = exports.releaseGroupLock = exports.setGroupCursor = exports.replayEvents = exports.readNextEventsText = exports.readNextEvents = exports.pollForEvents = exports.markSubscriptionsActive = exports.deleteSubscriptions = exports.assertSubscription = exports.assertGroup = void 0;
+/** Types generated for queries found in "sql/queries.sql" */
+const runtime_1 = require("@pgtyped/runtime");
+const assertGroupIR = { "usedParamSet": { "id": true }, "params": [{ "name": "id", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 50, "b": 53 }] }], "statement": "INSERT INTO pgmb.subscription_groups (id)\nVALUES (:id!)\nON CONFLICT DO NOTHING" };
+/**
+ * Query generated from SQL:
+ * ```
+ * INSERT INTO pgmb.subscription_groups (id)
+ * VALUES (:id!)
+ * ON CONFLICT DO NOTHING
+ * ```
+ */
+exports.assertGroup = new runtime_1.PreparedQuery(assertGroupIR);
+const assertSubscriptionIR = { "usedParamSet": { "groupId": true, "conditionsSql": true, "params": true, "expiryInterval": true }, "params": [{ "name": "groupId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 98, "b": 106 }] }, { "name": "conditionsSql", "required": false, "transform": { "type": "scalar" }, "locs": [{ "a": 119, "b": 132 }] }, { "name": "params", "required": false, "transform": { "type": "scalar" }, "locs": [{ "a": 154, "b": 160 }] }, { "name": "expiryInterval", "required": false, "transform": { "type": "scalar" }, "locs": [{ "a": 178, "b": 192 }] }], "statement": "INSERT INTO pgmb.subscriptions\n\tAS s(group_id, conditions_sql, params, expiry_interval)\nVALUES (\n\t:groupId!,\n\tCOALESCE(:conditionsSql, 'TRUE'),\n\tCOALESCE(:params::jsonb, '{}'),\n\t:expiryInterval::interval\n)\nON CONFLICT (identity) DO UPDATE\nSET\n\t-- set expiry_interval to the new value only if it's greater than the existing one\n\t-- or if the new value is NULL (indicating no expiration)\n\texpiry_interval = CASE\n\t\tWHEN EXCLUDED.expiry_interval IS NULL OR s.expiry_interval IS NULL\n\t\t\tTHEN NULL\n\t\tELSE\n\t\t\tGREATEST(s.expiry_interval, EXCLUDED.expiry_interval)\n\tEND,\n\tlast_active_at = NOW()\nRETURNING id AS \"id!\"" };
+/**
+ * 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!"
+ * ```
+ */
+exports.assertSubscription = new runtime_1.PreparedQuery(assertSubscriptionIR);
+const deleteSubscriptionsIR = { "usedParamSet": { "ids": true }, "params": [{ "name": "ids", "required": true, "transform": { "type": "array_spread" }, "locs": [{ "a": 43, "b": 47 }] }], "statement": "DELETE FROM pgmb.subscriptions\nWHERE id IN :ids!" };
+/**
+ * Query generated from SQL:
+ * ```
+ * DELETE FROM pgmb.subscriptions
+ * WHERE id IN :ids!
+ * ```
+ */
+exports.deleteSubscriptions = new runtime_1.PreparedQuery(deleteSubscriptionsIR);
+const markSubscriptionsActiveIR = { "usedParamSet": { "ids": true }, "params": [{ "name": "ids", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 88, "b": 92 }] }], "statement": "UPDATE pgmb.subscriptions\nSET\n\tlast_active_at = NOW()\nWHERE id IN (SELECT * FROM unnest(:ids!::pgmb.subscription_id[]))" };
+/**
+ * Query generated from SQL:
+ * ```
+ * UPDATE pgmb.subscriptions
+ * SET
+ * 	last_active_at = NOW()
+ * WHERE id IN (SELECT * FROM unnest(:ids!::pgmb.subscription_id[]))
+ * ```
+ */
+exports.markSubscriptionsActive = new runtime_1.PreparedQuery(markSubscriptionsActiveIR);
+const pollForEventsIR = { "usedParamSet": {}, "params": [], "statement": "SELECT count AS \"count!\" FROM pgmb.poll_for_events() AS count" };
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT count AS "count!" FROM pgmb.poll_for_events() AS count
+ * ```
+ */
+exports.pollForEvents = new runtime_1.PreparedQuery(pollForEventsIR);
+const readNextEventsIR = { "usedParamSet": { "groupId": true, "cursor": true, "chunkSize": true }, "params": [{ "name": "groupId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 197, "b": 205 }] }, { "name": "cursor", "required": false, "transform": { "type": "scalar" }, "locs": [{ "a": 208, "b": 214 }] }, { "name": "chunkSize", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 217, "b": 227 }] }], "statement": "SELECT\n\tid AS \"id!\",\n\ttopic AS \"topic!\",\n\tpayload AS \"payload!\",\n\tmetadata AS \"metadata!\",\n\tsubscription_ids::text[] AS \"subscriptionIds!\",\n\tnext_cursor AS \"nextCursor!\"\nFROM pgmb.read_next_events(:groupId!, :cursor, :chunkSize!)" };
+/**
+ * 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!)
+ * ```
+ */
+exports.readNextEvents = new runtime_1.PreparedQuery(readNextEventsIR);
+const readNextEventsTextIR = { "usedParamSet": { "groupId": true, "cursor": true, "chunkSize": true }, "params": [{ "name": "groupId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 97, "b": 105 }] }, { "name": "cursor", "required": false, "transform": { "type": "scalar" }, "locs": [{ "a": 108, "b": 114 }] }, { "name": "chunkSize", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 117, "b": 127 }] }], "statement": "SELECT\n\tid AS \"id!\",\n\ttopic AS \"topic!\",\n\tpayload::text AS \"payload!\"\nFROM pgmb.read_next_events(:groupId!, :cursor, :chunkSize!)" };
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT
+ * 	id AS "id!",
+ * 	topic AS "topic!",
+ * 	payload::text AS "payload!"
+ * FROM pgmb.read_next_events(:groupId!, :cursor, :chunkSize!)
+ * ```
+ */
+exports.readNextEventsText = new runtime_1.PreparedQuery(readNextEventsTextIR);
+const replayEventsIR = { "usedParamSet": { "groupId": true, "subscriptionId": true, "fromEventId": true, "maxEvents": true }, "params": [{ "name": "groupId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 116, "b": 124 }] }, { "name": "subscriptionId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 128, "b": 143 }] }, { "name": "fromEventId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 147, "b": 159 }] }, { "name": "maxEvents", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 178, "b": 188 }] }], "statement": "SELECT\n\tid AS \"id!\",\n\ttopic AS \"topic!\",\n\tpayload AS \"payload!\",\n\tmetadata AS \"metadata!\"\nFROM pgmb.replay_events(\n\t:groupId!,\n\t:subscriptionId!,\n\t:fromEventId!::pgmb.event_id,\n\t:maxEvents!\n)" };
+/**
+ * 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!
+ * )
+ * ```
+ */
+exports.replayEvents = new runtime_1.PreparedQuery(replayEventsIR);
+const setGroupCursorIR = { "usedParamSet": { "groupId": true, "cursor": true, "releaseLock": true }, "params": [{ "name": "groupId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 31, "b": 39 }] }, { "name": "cursor", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 43, "b": 50 }] }, { "name": "releaseLock", "required": false, "transform": { "type": "scalar" }, "locs": [{ "a": 69, "b": 80 }] }], "statement": "SELECT pgmb.set_group_cursor(\n\t:groupId!,\n\t:cursor!::pgmb.event_id,\n\t:releaseLock::boolean\n) AS \"success!\"" };
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT pgmb.set_group_cursor(
+ * 	:groupId!,
+ * 	:cursor!::pgmb.event_id,
+ * 	:releaseLock::boolean
+ * ) AS "success!"
+ * ```
+ */
+exports.setGroupCursor = new runtime_1.PreparedQuery(setGroupCursorIR);
+const releaseGroupLockIR = { "usedParamSet": { "groupId": true }, "params": [{ "name": "groupId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 31, "b": 39 }] }], "statement": "SELECT pgmb.release_group_lock(:groupId!) AS \"success!\"" };
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT pgmb.release_group_lock(:groupId!) AS "success!"
+ * ```
+ */
+exports.releaseGroupLock = new runtime_1.PreparedQuery(releaseGroupLockIR);
+const writeEventsIR = { "usedParamSet": { "topics": true, "payloads": true, "metadatas": true }, "params": [{ "name": "topics", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 100, "b": 107 }] }, { "name": "payloads", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 119, "b": 128 }] }, { "name": "metadatas", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 141, "b": 151 }] }], "statement": "INSERT INTO pgmb.events (topic, payload, metadata)\nSELECT\n\ttopic,\n\tpayload,\n\tmetadata\nFROM unnest(\n\t:topics!::TEXT[],\n\t:payloads!::JSONB[],\n\t:metadatas!::JSONB[]\n) AS t(topic, payload, metadata)\nRETURNING id AS \"id!\"" };
+/**
+ * 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!"
+ * ```
+ */
+exports.writeEvents = new runtime_1.PreparedQuery(writeEventsIR);
+const writeScheduledEventsIR = { "usedParamSet": { "ts": true, "topics": true, "payloads": true, "metadatas": true }, "params": [{ "name": "ts", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 189, "b": 192 }] }, { "name": "topics", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 211, "b": 218 }] }, { "name": "payloads", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 230, "b": 239 }] }, { "name": "metadatas", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 252, "b": 262 }] }], "statement": "INSERT INTO pgmb.events (id, topic, payload, metadata)\nSELECT\n\tpgmb.create_event_id(COALESCE(ts, clock_timestamp()), pgmb.create_random_bigint()),\n\ttopic,\n\tpayload,\n\tmetadata\nFROM unnest(\n\t:ts!::TIMESTAMPTZ[],\n\t:topics!::TEXT[],\n\t:payloads!::JSONB[],\n\t:metadatas!::JSONB[]\n) AS t(ts, topic, payload, metadata)\nRETURNING id AS \"id!\"" };
+/**
+ * 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!"
+ * ```
+ */
+exports.writeScheduledEvents = new runtime_1.PreparedQuery(writeScheduledEventsIR);
+const scheduleEventRetryIR = { "usedParamSet": { "delayInterval": true, "ids": true, "retryNumber": true, "handlerName": true, "subscriptionId": true }, "params": [{ "name": "delayInterval", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 103, "b": 117 }] }, { "name": "ids", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 212, "b": 216 }] }, { "name": "retryNumber", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 255, "b": 267 }] }, { "name": "handlerName", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 294, "b": 306 }] }, { "name": "subscriptionId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 319, "b": 334 }] }], "statement": "INSERT INTO pgmb.events (id, topic, payload, subscription_id)\nSELECT\n\tpgmb.create_event_id(\n\t\tNOW() + (:delayInterval!::INTERVAL),\n\t\tpgmb.create_random_bigint()\n\t),\n\t'pgmb-retry',\n\tjsonb_build_object(\n\t\t'ids',\n\t\t:ids!::pgmb.event_id[],\n\t\t'retryNumber',\n\t\t:retryNumber!::int,\n\t\t'handlerName',\n\t\t:handlerName!::text\n\t),\n\t:subscriptionId!::pgmb.subscription_id\nRETURNING id AS \"id!\"" };
+/**
+ * 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!"
+ * ```
+ */
+exports.scheduleEventRetry = new runtime_1.PreparedQuery(scheduleEventRetryIR);
+const findEventsIR = { "usedParamSet": { "ids": true }, "params": [{ "name": "ids", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 122, "b": 126 }] }], "statement": "SELECT\n\tid AS \"id!\",\n\ttopic AS \"topic!\",\n\tpayload AS \"payload!\",\n\tmetadata AS \"metadata!\"\nFROM pgmb.events\nWHERE id = ANY(:ids!::pgmb.event_id[])" };
+/**
+ * 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[])
+ * ```
+ */
+exports.findEvents = new runtime_1.PreparedQuery(findEventsIR);
+const removeExpiredSubscriptionsIR = { "usedParamSet": { "groupId": true, "activeIds": true }, "params": [{ "name": "groupId", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 68, "b": 76 }] }, { "name": "activeIds", "required": true, "transform": { "type": "scalar" }, "locs": [{ "a": 219, "b": 229 }] }], "statement": "WITH deleted AS (\n\tDELETE FROM pgmb.subscriptions\n\tWHERE group_id = :groupId!\n\t\tAND expiry_interval IS NOT NULL\n\t\tAND pgmb.add_interval_imm(last_active_at, expiry_interval) < NOW()\n\t\tAND id NOT IN (select * from unnest(:activeIds!::pgmb.subscription_id[]))\n\tRETURNING id\n)\nSELECT COUNT(*) AS \"deleted!\" FROM deleted" };
+/**
+ * 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
+ * ```
+ */
+exports.removeExpiredSubscriptions = new runtime_1.PreparedQuery(removeExpiredSubscriptionsIR);
+const maintainEventsTableIR = { "usedParamSet": {}, "params": [], "statement": "SELECT pgmb.maintain_events_table()" };
+/**
+ * Query generated from SQL:
+ * ```
+ * SELECT pgmb.maintain_events_table()
+ * ```
+ */
+exports.maintainEventsTable = new runtime_1.PreparedQuery(maintainEventsTableIR);