lonnymq 1.0.2 → 1.1.0

package/dist/index.mjs

@@ -0,0 +1,1181 @@
+import { randomUUID } from "node:crypto";
+//#region src/util/sql.ts
+const value = (value) => ({
+	nodeType: "VALUE",
+	value
+});
+const ref = (value) => ({
+	nodeType: "REF",
+	value
+});
+const raw = (value) => ({
+	nodeType: "RAW",
+	value
+});
+const escapeString = (value) => {
+	return `'${value.replace(/'/g, "''")}'`;
+};
+const escapeValue = (value) => {
+	if (value === null) return "NULL";
+	else if (typeof value === "string") return escapeString(value);
+	else if (typeof value === "number") return value.toString();
+	else if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	else if (value instanceof Date) return `'${value.toISOString()}'`;
+	else if (typeof value === "bigint") return value.toString();
+	else throw new Error(`Unsupported value type: ${typeof value}`);
+};
+const escapeRef = (value) => {
+	return `"${value.replace(/"/g, "\"\"")}"`;
+};
+const escapeNode = (value) => {
+	if (value.nodeType === "VALUE") return escapeValue(value.value);
+	else if (value.nodeType === "REF") return escapeRef(value.value);
+	else if (value.nodeType === "RAW") return value.value;
+	else throw new Error("Unsupported SQL node type");
+};
+const fragment = (fragments, ...values) => {
+	const parts = [];
+	for (let ix = 0; ix < fragments.length; ix += 1) {
+		parts.push(fragments[ix]);
+		if (ix < values.length) parts.push(escapeNode(values[ix]));
+	}
+	return raw(parts.join(""));
+};
+//#endregion
+//#region src/util/text.ts
+const dedent = (value) => {
+	const lines = value.split("\n");
+	let minIndent = Number.MAX_SAFE_INTEGER;
+	for (const line of lines) {
+		if (line.trim().length === 0) continue;
+		const indent = line.search(/\S/);
+		minIndent = Math.min(minIndent, indent);
+	}
+	return lines.map((line) => line.slice(minIndent)).join("\n").trim();
+};
+//#endregion
+//#region src/command/channel-policy/clear.ts
+var Clear = class {
+	schema;
+	channelId;
+	createdAt;
+	constructor(params) {
+		this.schema = params.schema;
+		this.channelId = params.channelId;
+		this.createdAt = /* @__PURE__ */ new Date();
+	}
+	async execute(databaseClient) {
+		await databaseClient.query(fragment`
+            SELECT 1 FROM ${ref(this.schema)}."channel_policy_clear"(
+                $1
+            )
+        `.value, [this.channelId]);
+	}
+};
+//#endregion
+//#region src/command/channel-policy/set.ts
+var Set = class {
+	schema;
+	channelId;
+	maxConcurrency;
+	maxSize;
+	releaseIntervalMs;
+	createdAt;
+	constructor(params) {
+		this.schema = params.schema;
+		this.channelId = params.channelId;
+		const maxConcurrency = params.maxConcurrency ?? null;
+		this.maxConcurrency = maxConcurrency !== null ? Math.max(1, maxConcurrency) : null;
+		const maxSize = params.maxSize ?? null;
+		this.maxSize = maxSize !== null ? Math.max(1, maxSize) : null;
+		const releaseIntervalMs = params.releaseIntervalMs ?? null;
+		this.releaseIntervalMs = releaseIntervalMs !== null ? Math.max(0, releaseIntervalMs) : null;
+		this.createdAt = /* @__PURE__ */ new Date();
+	}
+	async execute(databaseClient) {
+		await databaseClient.query(fragment`
+            SELECT 1 FROM ${ref(this.schema)}."channel_policy_set"(
+                $1,
+                $2::INTEGER,
+                $3::INTEGER,
+                $4::INTEGER
+            )
+        `.value, [
+			this.channelId,
+			this.maxConcurrency,
+			this.maxSize,
+			this.releaseIntervalMs
+		]);
+	}
+};
+//#endregion
+//#region src/command/message/create.ts
+var Create = class {
+	schema;
+	channelId;
+	content;
+	dequeueAt;
+	constructor(params) {
+		this.schema = params.schema;
+		this.channelId = params.channelId;
+		this.content = params.content;
+		this.dequeueAt = params.dequeueAt;
+	}
+	async execute(databaseClient) {
+		const result = await databaseClient.query(fragment`
+            SELECT 
+                result_code, 
+                metadata 
+            FROM ${ref(this.schema)}."message_create"(
+                $1, 
+                $2,
+                $3::BIGINT
+            )
+        `.value, [
+			this.channelId,
+			this.content,
+			this.dequeueAt
+		]).then((res) => res.rows[0]);
+		if (result.result_code === 0) return {
+			resultType: "MESSAGE_CREATED",
+			id: BigInt(result.metadata.id),
+			channelSize: result.metadata.channel_size
+		};
+		else if (result.result_code === 1) return { resultType: "MESSAGE_DROPPED" };
+		else throw new Error("Unexpected result code");
+	}
+};
+//#endregion
+//#region src/command/message/dequeue.ts
+var Dequeue = class {
+	schema;
+	lockMs;
+	constructor(params) {
+		this.schema = params.schema;
+		this.lockMs = params.lockMs;
+	}
+	async execute(databaseClient) {
+		const result = await databaseClient.query(fragment`
+            SELECT
+                result_code,
+                metadata,
+                content,
+                state
+            FROM ${ref(this.schema)}."message_dequeue"($1::BIGINT)
+        `.value, [this.lockMs]).then((res) => res.rows[0]);
+		if (result.result_code === 2) return { resultType: "MESSAGE_NOT_AVAILABLE" };
+		else if (result.result_code === 3) return {
+			resultType: "MESSAGE_DEQUEUED",
+			id: BigInt(result.metadata.id),
+			channelId: result.metadata.channel_id,
+			isUnlocked: result.metadata.is_unlocked,
+			content: result.content,
+			state: result.state,
+			numAttempts: result.metadata.num_attempts
+		};
+		else throw new Error("Unexpected dequeue result");
+	}
+};
+//#endregion
+//#region src/command/message/retire.ts
+var Retire = class {
+	schema;
+	id;
+	numAttempts;
+	constructor(params) {
+		this.schema = params.schema;
+		this.id = params.id;
+		this.numAttempts = params.numAttempts;
+	}
+	async execute(databaseClient) {
+		const result = await databaseClient.query(fragment`
+            SELECT * FROM ${ref(this.schema)}."message_retire"(
+                $1::BIGINT,
+                $2::BIGINT
+            )
+        `.value, [this.id.toString(), this.numAttempts]).then((res) => res.rows[0]);
+		if (result.result_code === 4) return { resultType: "MESSAGE_NOT_FOUND" };
+		else if (result.result_code === 5) return { resultType: "STATE_INVALID" };
+		else if (result.result_code === 6) return { resultType: "MESSAGE_RETIRED" };
+		else throw new Error("Unexpected result");
+	}
+};
+//#endregion
+//#region src/command/message/defer.ts
+var Defer = class {
+	schema;
+	id;
+	numAttempts;
+	state;
+	dequeueAt;
+	constructor(params) {
+		this.schema = params.schema;
+		this.numAttempts = params.numAttempts;
+		this.id = params.id;
+		this.state = params.state;
+		this.dequeueAt = params.dequeueAt;
+	}
+	async execute(databaseClient) {
+		const result = await databaseClient.query(fragment`
+            SELECT * FROM ${ref(this.schema)}."message_defer"(
+                $1::BIGINT,
+                $2::BIGINT,
+                $3::BIGINT,
+                $4
+            )
+        `.value, [
+			this.id.toString(),
+			this.numAttempts,
+			this.dequeueAt,
+			this.state
+		]).then((res) => res.rows[0]);
+		if (result.result_code === 4) return { resultType: "MESSAGE_NOT_FOUND" };
+		else if (result.result_code === 5) return { resultType: "STATE_INVALID" };
+		else if (result.result_code === 7) return { resultType: "MESSAGE_DEFERRED" };
+		else throw new Error("Unexpected result");
+	}
+};
+//#endregion
+//#region src/command/message/heartbeat.ts
+var Heartbeat = class {
+	schema;
+	id;
+	numAttempts;
+	lockMs;
+	constructor(params) {
+		this.schema = params.schema;
+		this.numAttempts = params.numAttempts;
+		this.id = params.id;
+		this.lockMs = params.lockMs;
+	}
+	async execute(databaseClient) {
+		const result = await databaseClient.query(fragment`
+            SELECT * FROM ${ref(this.schema)}."message_heartbeat"(
+                $1::BIGINT,
+                $2::BIGINT,
+                $3::BIGINT
+            )
+        `.value, [
+			this.id.toString(),
+			this.numAttempts,
+			this.lockMs
+		]).then((res) => res.rows[0]);
+		if (result.result_code === 4) return { resultType: "MESSAGE_NOT_FOUND" };
+		else if (result.result_code === 5) return { resultType: "MESSAGE_STATE_INVALID" };
+		else if (result.result_code === 8) return { resultType: "MESSAGE_HEARTBEATED" };
+		else throw new Error("Unexpected result");
+	}
+};
+//#endregion
+//#region src/install/function/epoch.ts
+const epoch = (params) => {
+	return [fragment`
+            CREATE FUNCTION ${ref(params.schema)}."epoch" () 
+            RETURNS BIGINT AS $$
+            DECLARE
+                v_now TIMESTAMPTZ;
+            BEGIN
+                v_now := NOW();
+                RETURN 
+                    EXTRACT(EPOCH FROM v_now)::BIGINT * 1_000 +
+                    EXTRACT(MILLISECOND FROM v_now)::BIGINT;
+            END;
+            $$ LANGUAGE plpgsql;
+        `];
+};
+//#endregion
+//#region src/install/function/channel-policy/clear.ts
+const clear = (params) => {
+	return [fragment`
+            CREATE FUNCTION ${ref(params.schema)}."channel_policy_clear" (
+                p_id TEXT
+            ) RETURNS VOID AS $$
+            DECLARE
+                v_channel_state RECORD;
+            BEGIN
+                DELETE FROM ${ref(params.schema)}."channel_policy" 
+                WHERE "id" = p_id;
+
+                SELECT
+                    "channel_state"."id",
+                    "channel_state"."current_size"
+                FROM ${ref(params.schema)}."channel_state"
+                WHERE "id" = p_id
+                FOR UPDATE
+                INTO v_channel_state;
+
+                IF v_channel_state."current_size" = 0 THEN
+                    DELETE FROM ${ref(params.schema)}."channel_state"
+                    WHERE "id" = v_channel_state."id";
+                ELSE
+                    UPDATE ${ref(params.schema)}."channel_state" SET
+                        "max_concurrency" = NULL,
+                        "release_interval_ms" = NULL
+                    WHERE "id" = p_id;
+                END IF;
+            END;
+            $$ LANGUAGE plpgsql;
+        `];
+};
+//#endregion
+//#region src/install/function/channel-policy/set.ts
+const set = (params) => {
+	return [fragment`
+            CREATE FUNCTION ${ref(params.schema)}."channel_policy_set" (
+                p_id TEXT,
+                p_max_concurrency INTEGER,
+                p_max_size INTEGER,
+                p_release_interval_ms INTEGER
+            ) RETURNS VOID AS $$
+            BEGIN
+                INSERT INTO ${ref(params.schema)}."channel_policy" (
+                    "id",
+                    "max_concurrency",
+                    "max_size",
+                    "release_interval_ms"
+                ) VALUES (
+                    p_id,
+                    p_max_concurrency,
+                    p_max_size,
+                    p_release_interval_ms
+                ) ON CONFLICT ("id") DO UPDATE SET
+                    "max_concurrency" = EXCLUDED."max_concurrency",
+                    "max_size" = EXCLUDED."max_size",
+                    "release_interval_ms" = EXCLUDED."release_interval_ms";
+
+                UPDATE ${ref(params.schema)}."channel_state" SET
+                    "max_concurrency" = p_max_concurrency,
+                    "max_size" = p_max_size,
+                    "release_interval_ms" = p_release_interval_ms
+                WHERE "id" = p_id;
+            END;
+            $$ LANGUAGE plpgsql;
+        `];
+};
+//#endregion
+//#region src/install/function/message/create.ts
+const create = (params) => {
+	return [fragment`
+                CREATE FUNCTION ${ref(params.schema)}."message_create" (
+                    p_channel TEXT,
+                    p_content BYTEA,
+                    p_dequeue_at BIGINT
+                ) RETURNS TABLE (
+                    result_code INTEGER,
+                    metadata JSON
+                ) AS $$
+                DECLARE
+                    v_now BIGINT;
+                    v_dequeue_at BIGINT;
+                    v_channel_policy RECORD;
+                    v_channel_state RECORD;
+                    v_message RECORD;
+                BEGIN
+                    v_now := ${ref(params.schema)}."epoch"();
+                    v_dequeue_at := COALESCE(p_dequeue_at, v_now);
+
+                    SELECT 
+                        "id",
+                        "current_concurrency",
+                        "current_size",
+                        "max_concurrency",
+                        "max_size",
+                        "release_interval_ms",
+                        "dequeue_prev_at",
+                        "message_id",
+                        "message_dequeue_at"
+                    FROM ${ref(params.schema)}."channel_state"
+                    WHERE "id" = p_channel
+                    FOR UPDATE
+                    INTO v_channel_state;
+
+                    IF v_channel_state."id" IS NULL THEN
+                        SELECT
+                            "channel_policy"."max_concurrency",
+                            "channel_policy"."max_size",
+                            "channel_policy"."release_interval_ms"
+                        FROM ${ref(params.schema)}."channel_policy"
+                        WHERE "id" = p_channel
+                        FOR SHARE
+                        INTO v_channel_policy;
+
+                        INSERT INTO ${ref(params.schema)}."channel_state" (
+                            "id",
+                            "current_concurrency",
+                            "current_size",
+                            "max_concurrency",
+                            "max_size",
+                            "release_interval_ms",
+                            "dequeue_prev_at"
+                        ) VALUES (
+                            p_channel,
+                            0,
+                            0,
+                            v_channel_policy."max_concurrency",
+                            v_channel_policy."max_size",
+                            v_channel_policy."release_interval_ms",
+                            v_now
+                        ) RETURNING
+                            "id",
+                            "current_concurrency",
+                            "current_size",
+                            "max_concurrency",
+                            "max_size",
+                            "release_interval_ms",
+                            "dequeue_prev_at",
+                            "message_id",
+                            "message_dequeue_at"
+                        INTO v_channel_state;
+                    END IF;
+
+                    IF v_channel_state."current_size" >= v_channel_state."max_size" THEN
+                        RETURN QUERY SELECT
+                            ${value(1)},
+                            NULL::JSON;
+                        RETURN;
+                    END IF;
+
+                    INSERT INTO ${ref(params.schema)}."message" (
+                        "channel_id",
+                        "content",
+                        "is_locked",
+                        "num_attempts",
+                        "dequeue_at"
+                    ) VALUES (
+                        p_channel,
+                        p_content,
+                        FALSE,
+                        0,
+                        v_dequeue_at
+                    ) RETURNING
+                        "id"
+                    INTO v_message;
+
+                    IF 
+                        v_channel_state."message_id" IS NULL OR
+                        v_dequeue_at < v_channel_state."message_dequeue_at" OR
+                        v_dequeue_at = v_channel_state."message_dequeue_at" AND v_message."id" < v_channel_state."message_id"
+                    THEN
+                        UPDATE ${ref(params.schema)}."channel_state" SET
+                            "current_size" = v_channel_state."current_size" + 1,
+                            "message_id" = v_message."id",
+                            "message_dequeue_at" = v_dequeue_at,
+                            "dequeue_next_at" = GREATEST(
+                                v_channel_state."dequeue_prev_at" + COALESCE(v_channel_state."release_interval_ms", 0),
+                                v_dequeue_at
+                            )
+                        WHERE "id" = v_channel_state."id";
+                    ELSE
+                        UPDATE ${ref(params.schema)}."channel_state" SET
+                            "current_size" = v_channel_state."current_size" + 1
+                        WHERE "id" = v_channel_state."id";
+                    END IF;
+
+                    IF ${value(params.eventChannel !== null)} THEN
+                        PERFORM PG_NOTIFY(
+                            ${value(params.eventChannel)},
+                            JSON_BUILD_OBJECT(
+                                'type', ${value(0)},
+                                'id', v_message."id"::TEXT,
+                                'dequeue_at', v_dequeue_at
+                            )::TEXT
+                        );
+                    END IF;
+
+                    RETURN QUERY SELECT
+                        ${value(0)},
+                        JSON_BUILD_OBJECT(
+                            'id', v_message."id"::TEXT,
+                            'channel_size', v_channel_state."current_size" + 1
+                        );
+                END;
+                $$ LANGUAGE plpgsql;
+        `];
+};
+//#endregion
+//#region src/install/function/message/defer.ts
+const defer = (params) => {
+	return [fragment`
+                CREATE FUNCTION ${ref(params.schema)}."message_defer" (
+                    p_id BIGINT,
+                    p_num_attempts BIGINT,
+                    p_dequeue_at BIGINT,
+                    p_state BYTEA
+                )
+                RETURNS TABLE (
+                    result_code INTEGER
+                ) AS $$
+                DECLARE
+                    v_now BIGINT;
+                    v_channel_state RECORD;
+                    v_message RECORD;
+                    v_dequeue_at BIGINT;
+                BEGIN
+                    v_now := ${ref(params.schema)}."epoch"();
+
+                    SELECT
+                        "message"."id",
+                        "message"."channel_id",
+                        "message"."num_attempts",
+                        "message"."is_locked"
+                    FROM ${ref(params.schema)}."message"
+                    WHERE "id" = p_id
+                    FOR UPDATE
+                    INTO v_message;
+
+                    IF v_message."id" IS NULL THEN
+                        RETURN QUERY SELECT
+                            ${value(4)};
+                        RETURN;
+                    ELSIF NOT v_message."is_locked" OR v_message."num_attempts" <> p_num_attempts THEN
+                        RETURN QUERY SELECT
+                            ${value(5)};
+                        RETURN;
+                    END IF;
+
+                    SELECT
+                        "channel_state"."current_concurrency",
+                        "channel_state"."release_interval_ms",
+                        "channel_state"."message_id",
+                        "channel_state"."message_dequeue_at",
+                        "channel_state"."dequeue_prev_at"
+                    FROM ${ref(params.schema)}."channel_state"
+                    WHERE "id" = v_message."channel_id"
+                    FOR UPDATE
+                    INTO v_channel_state;
+
+                    v_dequeue_at := COALESCE(p_dequeue_at, v_now);
+
+                    IF 
+                        v_channel_state."message_id" IS NULL OR 
+                        v_dequeue_at < v_channel_state."message_dequeue_at" OR
+                        v_dequeue_at = v_channel_state."message_dequeue_at" AND v_message."id" < v_channel_state."message_id"
+                    THEN
+                        UPDATE ${ref(params.schema)}."channel_state" SET
+                            "current_concurrency" = v_channel_state."current_concurrency" - 1,
+                            "message_id" = v_message."id",
+                            "message_dequeue_at" = v_dequeue_at,
+                            "dequeue_next_at" = GREATEST(
+                                v_channel_state."dequeue_prev_at" + COALESCE(v_channel_state."release_interval_ms", 0),
+                                v_dequeue_at
+                            )
+                        WHERE "id" = v_message."channel_id";
+                    ELSE
+                        UPDATE ${ref(params.schema)}."channel_state" SET
+                            "current_concurrency" = v_channel_state."current_concurrency" - 1
+                        WHERE "id" = v_message."channel_id";
+                    END IF;
+
+                    UPDATE ${ref(params.schema)}."message" SET
+                        "state" = p_state,
+                        "is_locked" = FALSE,
+                        "dequeue_at" = v_dequeue_at
+                    WHERE "id" = p_id;
+
+                    IF ${value(params.eventChannel !== null)} THEN
+                        PERFORM PG_NOTIFY(
+                            ${value(params.eventChannel)},
+                            JSON_BUILD_OBJECT(
+                                'type', ${value(7)},
+                                'dequeue_at', v_dequeue_at,
+                                'id', p_id::TEXT
+                            )::TEXT
+                        );
+                    END IF;
+
+                    RETURN QUERY SELECT
+                        ${value(7)};
+                    RETURN;
+                END;
+                $$ LANGUAGE plpgsql;
+        `];
+};
+//#endregion
+//#region src/install/function/message/dequeue.ts
+const queryNextLockedMessage = (params) => fragment`
+    SELECT
+        "message"."id",
+        "message"."state",
+        "message"."content",
+        "message"."channel_id",
+        "message"."unlock_at",
+        "message"."num_attempts"
+    FROM ${ref(params.schema)}."message"
+    WHERE "is_locked"
+    AND "unlock_at" <= ${params.now}
+    ORDER BY "unlock_at" ASC
+`;
+const queryNextChannel = (params) => fragment`
+    SELECT
+        "channel_state"."id",
+        "channel_state"."release_interval_ms",
+        "channel_state"."message_id",
+        "channel_state"."dequeue_next_at",
+        "channel_state"."dequeue_prev_at",
+        "channel_state"."current_concurrency"
+    FROM ${ref(params.schema)}."channel_state"
+    WHERE "message_id" IS NOT NULL
+    AND ("max_concurrency" IS NULL OR "current_concurrency" < "max_concurrency")
+    ORDER BY "dequeue_next_at" ASC
+`;
+const queryNextChannelMessage = (params) => fragment`
+    SELECT
+        "message"."id",
+        "message"."dequeue_at"
+    FROM ${ref(params.schema)}."message"
+    WHERE NOT "is_locked"
+    AND "channel_id" = ${params.channelId}
+    ORDER BY "dequeue_at" ASC, "id" ASC
+`;
+const dequeue = (params) => {
+	const nextLockedMessage = queryNextLockedMessage({
+		now: fragment`v_now`,
+		schema: params.schema
+	});
+	const nextChannelMessage = queryNextChannelMessage({
+		channelId: fragment`v_channel_state."id"`,
+		schema: params.schema
+	});
+	const nextChannel = queryNextChannel({ schema: params.schema });
+	return [fragment`
+                CREATE FUNCTION ${ref(params.schema)}."message_dequeue" (
+                    p_lock_ms BIGINT
+                )
+                RETURNS TABLE (
+                    result_code INTEGER,
+                    content BYTEA,
+                    state BYTEA,
+                    metadata JSON
+                ) AS $$
+                DECLARE
+                    v_now BIGINT;
+                    v_channel_state RECORD;
+                    v_message_locked RECORD;
+                    v_message_dequeue RECORD;
+                    v_message_next RECORD;
+                BEGIN
+                    v_now := ${ref(params.schema)}."epoch"();
+
+                    ${nextLockedMessage}
+                    FOR UPDATE
+                    SKIP LOCKED
+                    LIMIT 1
+                    INTO v_message_locked;
+
+                    IF v_message_locked."id" IS NOT NULL THEN
+                        UPDATE ${ref(params.schema)}."message" SET
+                            "num_attempts" = v_message_locked."num_attempts" + 1,
+                            "unlock_at" = v_now + p_lock_ms 
+                        WHERE "id" = v_message_locked."id";
+
+                        RETURN QUERY SELECT 
+                            ${value(3)},
+                            v_message_locked.content,
+                            v_message_locked.state,
+                            JSON_BUILD_OBJECT(
+                                'id', v_message_locked."id",
+                                'is_unlocked', TRUE,
+                                'channel', v_message_locked."channel_id",
+                                'num_attempts', v_message_locked."num_attempts" + 1
+                            );
+                        RETURN;
+                    END IF;
+
+                    ${nextChannel}
+                    FOR UPDATE
+                    SKIP LOCKED
+                    LIMIT 1
+                    INTO v_channel_state;
+
+                    IF v_channel_state."id" IS NULL OR v_channel_state."dequeue_next_at" > v_now THEN
+                        RETURN QUERY SELECT
+                            ${value(2)},
+                            NULL::BYTEA,
+                            NULL::BYTEA,
+                            NULL::JSON;
+                        RETURN;
+                    END IF;
+
+                    SELECT
+                        "message"."id",
+                        "message"."channel_id",
+                        "message"."content",
+                        "message"."num_attempts",
+                        "message"."state"
+                    FROM ${ref(params.schema)}."message"
+                    WHERE "id" = v_channel_state."message_id"
+                    INTO v_message_dequeue;
+
+                    UPDATE ${ref(params.schema)}."message" SET
+                        "is_locked" = TRUE,
+                        "num_attempts" = v_message_dequeue."num_attempts" + 1,
+                        "unlock_at" = v_now + p_lock_ms
+                    WHERE "id" = v_message_dequeue."id";
+
+                    ${nextChannelMessage}
+                    LIMIT 1
+                    INTO v_message_next;
+
+                    IF v_message_next."id" IS NULL THEN
+                        UPDATE ${ref(params.schema)}."channel_state" SET
+                            "current_concurrency" = v_channel_state."current_concurrency" + 1,
+                            "dequeue_prev_at" = v_now,
+                            "message_id" = NULL
+                        WHERE "id" = v_channel_state."id";
+                    ELSE
+                        UPDATE ${ref(params.schema)}."channel_state" SET
+                            "current_concurrency" = v_channel_state."current_concurrency" + 1,
+                            "message_id" = v_message_next."id",
+                            "message_dequeue_at" = v_message_next."dequeue_at",
+                            "dequeue_prev_at" = v_now,
+                            "dequeue_next_at" = GREATEST(
+                                v_message_next."dequeue_at",
+                                v_now + COALESCE(v_channel_state."release_interval_ms", 0)
+                            )
+                        WHERE "id" = v_channel_state."id";
+                    END IF;
+
+                    RETURN QUERY SELECT
+                        ${value(3)},
+                        v_message_dequeue."content",
+                        v_message_dequeue."state",
+                        JSON_BUILD_OBJECT(
+                            'id', v_message_dequeue."id"::TEXT,
+                            'is_unlocked', FALSE,
+                            'channel_id', v_message_dequeue."channel_id",
+                            'num_attempts', v_message_dequeue."num_attempts" + 1
+                        );
+                    RETURN;
+                END;
+                $$ LANGUAGE plpgsql;
+        `];
+};
+//#endregion
+//#region src/install/function/message/heartbeat.ts
+const heartbeat = (params) => {
+	return [fragment`
+                CREATE FUNCTION ${ref(params.schema)}."message_heartbeat" (
+                    p_id BIGINT,
+                    p_num_attempts BIGINT,
+                    p_lock_ms BIGINT
+                )
+                RETURNS TABLE (
+                    result_code INTEGER
+                ) AS $$
+                DECLARE
+                    v_now BIGINT;
+                    v_message RECORD;
+                BEGIN
+                    v_now := ${ref(params.schema)}."epoch"();
+
+                    SELECT
+                        "message"."id",
+                        "message"."num_attempts",
+                        "message"."is_locked",
+                        "message"."unlock_at"
+                    FROM ${ref(params.schema)}."message"
+                    WHERE "id" = p_id
+                    FOR UPDATE
+                    INTO v_message;
+
+                    IF v_message."id" IS NULL THEN
+                        RETURN QUERY SELECT
+                            ${value(4)};
+                        RETURN;
+                    ELSIF NOT v_message."is_locked" OR v_message."num_attempts" <> p_num_attempts THEN
+                        RETURN QUERY SELECT
+                            ${value(5)};
+                        RETURN;
+                    END IF;
+
+                    UPDATE ${ref(params.schema)}."message" SET
+                        "unlock_at" = GREATEST(
+                            v_now + p_lock_ms,
+                            v_message."unlock_at"
+                        )
+                    WHERE "id" = p_id;
+
+                    RETURN QUERY SELECT
+                        ${value(8)};
+                    RETURN;
+                END;
+                $$ LANGUAGE plpgsql;
+        `];
+};
+//#endregion
+//#region src/install/function/message/retire.ts
+const retire = (params) => {
+	return [fragment`
+                CREATE FUNCTION ${ref(params.schema)}."message_retire" (
+                    p_id BIGINT,
+                    p_num_attempts BIGINT
+                )
+                RETURNS TABLE (
+                    result_code INTEGER
+                ) AS $$
+                DECLARE
+                    v_channel_policy RECORD;
+                    v_channel_state RECORD;
+                    v_message RECORD;
+                BEGIN
+                    SELECT
+                        "message"."id",
+                        "message"."channel_id",
+                        "message"."num_attempts",
+                        "message"."is_locked"
+                    FROM ${ref(params.schema)}."message"
+                    WHERE "id" = p_id
+                    FOR UPDATE
+                    INTO v_message;
+
+                    IF v_message."id" IS NULL THEN
+                        RETURN QUERY SELECT
+                            ${value(4)};
+                        RETURN;
+                    ELSIF NOT v_message."is_locked" OR v_message."num_attempts" <> p_num_attempts THEN
+                        RETURN QUERY SELECT
+                            ${value(5)};
+                        RETURN;
+                    END IF;
+
+                    SELECT
+                        "channel_policy"."id"
+                    FROM ${ref(params.schema)}."channel_policy"
+                    WHERE "id" = v_message."channel_id"
+                    FOR SHARE
+                    INTO v_channel_policy;
+
+                    SELECT
+                        "channel_state"."id",
+                        "channel_state"."current_size",
+                        "channel_state"."current_concurrency"
+                    FROM ${ref(params.schema)}."channel_state"
+                    WHERE "id" = v_message."channel_id"
+                    FOR UPDATE
+                    INTO v_channel_state;
+
+                    IF v_channel_policy."id" IS NULL AND v_channel_state."current_size" = 1 THEN
+                        DELETE FROM ${ref(params.schema)}."channel_state"
+                        WHERE "id" = v_channel_state."id";
+                    ELSE
+                        UPDATE ${ref(params.schema)}."channel_state" SET
+                            "current_concurrency" = v_channel_state."current_concurrency" - 1,
+                            "current_size" = v_channel_state."current_size" - 1
+                        WHERE "id" = v_channel_state."id";
+                    END IF;
+
+                    IF ${value(params.eventChannel !== null)} THEN
+                        PERFORM PG_NOTIFY(
+                            ${value(params.eventChannel)},
+                            JSON_BUILD_OBJECT(
+                                'type', ${value(6)},
+                                'id', p_id::TEXT
+                            )::TEXT
+                        );
+                    END IF;
+
+                    DELETE FROM ${ref(params.schema)}."message"
+                    WHERE "id" = p_id;
+
+                    RETURN QUERY SELECT
+                        ${value(6)};
+                    RETURN;
+                END;
+                $$ LANGUAGE plpgsql;
+        `];
+};
+//#endregion
+//#region src/install/table/channel-policy.ts
+const channelPolicy = (params) => {
+	return [fragment`
+            CREATE TABLE ${ref(params.schema)}."channel_policy" (
+                "id" TEXT NOT NULL,
+                "max_concurrency" INTEGER,
+                "max_size" INTEGER,
+                "release_interval_ms" INTEGER,
+                PRIMARY KEY ("id")
+            );
+        `];
+};
+//#endregion
+//#region src/install/table/channel-state.ts
+const channelState = (params) => {
+	const dequeueIndex = [params.schema, "channel_state_dequeue_ix"].join("_");
+	return [fragment`
+            CREATE TABLE ${ref(params.schema)}."channel_state" (
+                "id" TEXT NOT NULL,
+                "max_concurrency" INTEGER,
+                "max_size" INTEGER,
+                "release_interval_ms" INTEGER,
+                "current_size" INTEGER NOT NULL,
+                "current_concurrency" INTEGER NOT NULL,
+                "message_id" BIGINT,
+                "message_dequeue_at" BIGINT,
+                "dequeue_prev_at" BIGINT NOT NULL,
+                "dequeue_next_at" BIGINT NULL,
+                PRIMARY KEY ("id")
+            );
+        `, fragment`
+            CREATE INDEX ${ref(dequeueIndex)}
+            ON ${ref(params.schema)}."channel_state" (
+                "dequeue_next_at" ASC
+            ) WHERE "message_id" IS NOT NULL
+            AND ("max_concurrency" IS NULL OR "current_concurrency" < "max_concurrency");
+        `];
+};
+//#endregion
+//#region src/install/table/message.ts
+const message = (params) => {
+	return [
+		fragment`
+            CREATE TABLE ${ref(params.schema)}."message" (
+                "id" BIGSERIAL NOT NULL,
+                "channel_id" TEXT NOT NULL,
+                "content" BYTEA NOT NULL,
+                "state" BYTEA,
+                "is_locked" BOOLEAN NOT NULL,
+                "num_attempts" BIGINT NOT NULL,
+                "dequeue_at" BIGINT NOT NULL,
+                "unlock_at" BIGINT,
+                PRIMARY KEY ("id")
+            );
+        `,
+		fragment`
+            CREATE INDEX "message_dequeue_ix"
+            ON ${ref(params.schema)}."message" (
+                "channel_id",
+                "dequeue_at" ASC,
+                "id" ASC
+            ) WHERE NOT "is_locked";
+        `,
+		fragment`
+            CREATE INDEX "message_locked_dequeue_ix"
+            ON ${ref(params.schema)}."message" (
+                "unlock_at" ASC
+            ) WHERE "is_locked";
+        `
+	];
+};
+//#endregion
+//#region src/queue/module/channel/message.ts
+var Message$2 = class {
+	schema;
+	channelId;
+	adaptor;
+	constructor(params) {
+		this.schema = params.schema;
+		this.adaptor = params.adaptor;
+		this.channelId = params.channelId;
+	}
+	async create(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return await new Create({
+			schema: this.schema,
+			channelId: this.channelId,
+			content: params.content,
+			dequeueAt: params.dequeueAt ?? null
+		}).execute(adaptedClient);
+	}
+};
+//#endregion
+//#region src/queue/module/channel/policy.ts
+var Policy = class {
+	schema;
+	adaptor;
+	channelId;
+	constructor(params) {
+		this.schema = params.schema;
+		this.adaptor = params.adaptor;
+		this.channelId = params.channelId;
+	}
+	set(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return new Set({
+			schema: this.schema,
+			channelId: this.channelId,
+			maxConcurrency: params.maxConcurrency,
+			maxSize: params.maxSize,
+			releaseIntervalMs: params.releaseIntervalMs
+		}).execute(adaptedClient);
+	}
+	clear(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return new Clear({
+			schema: this.schema,
+			channelId: this.channelId
+		}).execute(adaptedClient);
+	}
+};
+//#endregion
+//#region src/queue/module/channel/index.ts
+var Channel = class {
+	policy;
+	message;
+	constructor(params) {
+		this.message = new Message$2({
+			schema: params.schema,
+			adaptor: params.adaptor,
+			channelId: params.channelId
+		});
+		this.policy = new Policy({
+			schema: params.schema,
+			adaptor: params.adaptor,
+			channelId: params.channelId
+		});
+	}
+};
+//#endregion
+//#region src/queue/module/message.ts
+var Message$1 = class {
+	schema;
+	adaptor;
+	constructor(params) {
+		this.schema = params.schema;
+		this.adaptor = params.adaptor;
+	}
+	async create(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return await new Create({
+			schema: this.schema,
+			content: params.content,
+			dequeueAt: params.dequeueAt ?? null,
+			channelId: randomUUID()
+		}).execute(adaptedClient);
+	}
+};
+//#endregion
+//#region src/event.ts
+const decode = (payload) => {
+	const parsed = JSON.parse(payload);
+	if (parsed.type === 0) return {
+		eventType: "MESSAGE_CREATED",
+		id: parsed.id,
+		dequeueAt: Number(parsed.dequeue_at)
+	};
+	else if (parsed.type === 6) return {
+		eventType: "MESSAGE_RETIRED",
+		id: parsed.id
+	};
+	else if (parsed.type === 7) return {
+		eventType: "MESSAGE_DEFERRED",
+		id: parsed.id,
+		dequeueAt: Number(parsed.dequeue_at)
+	};
+	else throw new Error("Unknown event type");
+};
+//#endregion
+//#region src/queue/message.ts
+var Message = class {
+	schema;
+	adaptor;
+	id;
+	isUnlocked;
+	channelId;
+	content;
+	state;
+	numAttempts;
+	constructor(params) {
+		this.schema = params.schema;
+		this.adaptor = params.adaptor;
+		this.id = params.id;
+		this.channelId = params.channelId;
+		this.isUnlocked = params.isUnlocked;
+		this.content = params.content;
+		this.state = params.state;
+		this.numAttempts = params.numAttempts;
+	}
+	async defer(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return new Defer({
+			schema: this.schema,
+			id: this.id,
+			numAttempts: this.numAttempts,
+			dequeueAt: params.dequeueAt ?? null,
+			state: params.state ?? null
+		}).execute(adaptedClient);
+	}
+	async retire(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return new Retire({
+			schema: this.schema,
+			numAttempts: this.numAttempts,
+			id: this.id
+		}).execute(adaptedClient);
+	}
+	async heartbeat(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return new Heartbeat({
+			schema: this.schema,
+			id: this.id,
+			numAttempts: this.numAttempts,
+			lockMs: params.lockMs
+		}).execute(adaptedClient);
+	}
+};
+//#endregion
+//#region src/queue/index.ts
+var Queue = class {
+	schema;
+	message;
+	adaptor;
+	constructor(params) {
+		this.schema = params.schema;
+		this.adaptor = params.adaptor ? params.adaptor : (x) => x;
+		this.message = new Message$1({
+			schema: this.schema,
+			adaptor: this.adaptor
+		});
+	}
+	async dequeue(params) {
+		const dequeue = new Dequeue({
+			schema: this.schema,
+			lockMs: params.lockMs
+		});
+		const adaptedClient = this.adaptor(params.databaseClient);
+		const result = await dequeue.execute(adaptedClient);
+		if (result.resultType === "MESSAGE_DEQUEUED") return {
+			resultType: "MESSAGE_DEQUEUED",
+			message: new Message({
+				schema: this.schema,
+				adaptor: this.adaptor,
+				id: result.id,
+				channelId: result.channelId,
+				isUnlocked: result.isUnlocked,
+				content: result.content,
+				state: result.state,
+				numAttempts: result.numAttempts
+			})
+		};
+		else return result;
+	}
+	channel(channelId) {
+		return new Channel({
+			adaptor: this.adaptor,
+			schema: this.schema,
+			channelId
+		});
+	}
+	install(params = {}) {
+		return [
+			channelPolicy,
+			channelState,
+			message,
+			epoch,
+			set,
+			clear,
+			create,
+			dequeue,
+			retire,
+			defer,
+			heartbeat
+		].flatMap((install) => install({
+			schema: this.schema,
+			eventChannel: params.eventChannel ?? null
+		})).map((sql) => dedent(sql.value));
+	}
+	static decode(payload) {
+		return decode(payload);
+	}
+};
+//#endregion
+export { Queue };