lonnymq 1.0.2 → 1.2.0

package/dist/index.mjs

@@ -0,0 +1,1117 @@
+const INTEGER_MAX = 2147483647;
+//#endregion
+//#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/release.ts
+var Release = class {
+	schema;
+	channel;
+	createdAt;
+	constructor(params) {
+		this.schema = params.schema;
+		this.channel = params.channel;
+		this.createdAt = /* @__PURE__ */ new Date();
+	}
+	async execute(databaseClient) {
+		const result = await databaseClient.query(fragment`
+            SELECT * FROM ${ref(this.schema)}."channel_release"(
+                $1
+            )
+        `.value, [this.channel]).then((res) => res.rows[0]);
+		if (result.result_code === 9) return { resultType: "CHANNEL_NOT_FOUND" };
+		else if (result.result_code === 10) return { resultType: "CHANNEL_RELEASED" };
+		else throw new Error("Unexpected result");
+	}
+};
+//#endregion
+//#region src/command/channel/set.ts
+var Set = class {
+	schema;
+	channel;
+	maxConcurrency;
+	maxSize;
+	releaseIntervalMs;
+	createdAt;
+	constructor(params) {
+		this.schema = params.schema;
+		this.channel = params.channel;
+		if (!Number.isInteger(params.maxConcurrency) || params.maxConcurrency < 1 || params.maxConcurrency > 2147483647) throw new Error(`maxConcurrency must be an integer between 1 and ${INTEGER_MAX}`);
+		if (!Number.isInteger(params.maxSize) || params.maxSize < 1 || params.maxSize > 2147483647) throw new Error(`maxSize must be an integer between 1 and ${INTEGER_MAX}`);
+		if (!Number.isInteger(params.releaseIntervalMs) || params.releaseIntervalMs < 0 || params.releaseIntervalMs > 2147483647) throw new Error(`releaseIntervalMs must be an integer between 0 and ${INTEGER_MAX}`);
+		this.maxConcurrency = params.maxConcurrency;
+		this.maxSize = params.maxSize;
+		this.releaseIntervalMs = params.releaseIntervalMs;
+		this.createdAt = /* @__PURE__ */ new Date();
+	}
+	async execute(databaseClient) {
+		await databaseClient.query(fragment`
+            SELECT 1 FROM ${ref(this.schema)}."channel_set"(
+                $1,
+                $2::INTEGER,
+                $3::INTEGER,
+                $4::INTEGER
+            )
+        `.value, [
+			this.channel,
+			this.maxConcurrency,
+			this.maxSize,
+			this.releaseIntervalMs
+		]);
+	}
+};
+//#endregion
+//#region src/command/message/create.ts
+var Create = class {
+	schema;
+	channel;
+	content;
+	dequeueAt;
+	constructor(params) {
+		this.schema = params.schema;
+		this.channel = params.channel;
+		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.channel,
+			this.content,
+			this.dequeueAt
+		]).then((res) => res.rows[0]);
+		if (result.result_code === 0) return {
+			resultType: "MESSAGE_CREATED",
+			id: BigInt(result.metadata.id)
+		};
+		else if (result.result_code === 1) return { resultType: "MESSAGE_DROPPED" };
+		else if (result.result_code === 9) return { resultType: "CHANNEL_NOT_FOUND" };
+		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),
+			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/complete.ts
+var Complete = 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_complete"(
+                $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_COMPLETED" };
+		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/release.ts
+const release = (params) => {
+	return [fragment`
+            CREATE FUNCTION ${ref(params.schema)}."channel_release" (
+                p_text TEXT
+            ) RETURNS TABLE (
+                result_code INTEGER
+            ) AS $$
+            DECLARE
+                v_channel RECORD;
+            BEGIN
+                SELECT
+                    "channel"."id",
+                    "channel"."current_size"
+                FROM ${ref(params.schema)}."channel"
+                WHERE "name" = p_text
+                AND NOT "released"
+                FOR UPDATE
+                INTO v_channel;
+
+                IF v_channel."id" IS NULL THEN
+                    RETURN QUERY SELECT
+                        ${value(9)};
+                    RETURN;
+                END IF;
+
+                IF v_channel."current_size" = 0 THEN
+                    DELETE FROM ${ref(params.schema)}."channel"
+                    WHERE "id" = v_channel."id";
+                ELSE
+                    UPDATE ${ref(params.schema)}."channel" SET
+                        "released" = TRUE
+                    WHERE "id" = v_channel."id";
+                END IF;
+
+                RETURN QUERY SELECT
+                    ${value(10)};
+                RETURN;
+            END;
+            $$ LANGUAGE plpgsql;
+        `];
+};
+//#endregion
+//#region src/install/function/channel/set.ts
+const set = (params) => {
+	return [fragment`
+            CREATE FUNCTION ${ref(params.schema)}."channel_set" (
+                p_text TEXT,
+                p_max_concurrency INTEGER,
+                p_max_size INTEGER,
+                p_release_interval_ms INTEGER
+            ) RETURNS VOID AS $$
+            BEGIN
+                INSERT INTO ${ref(params.schema)}."channel" (
+                    "name",
+                    "max_concurrency",
+                    "max_size",
+                    "current_concurrency",
+                    "current_size",
+                    "release_interval_ms",
+                    "released",
+                    "dequeue_prev_at"
+                ) VALUES (
+                    p_text,
+                    p_max_concurrency,
+                    p_max_size,
+                    0,
+                    0,
+                    p_release_interval_ms,
+                    FALSE,
+                    0
+                ) ON CONFLICT ("name") WHERE NOT "released" DO UPDATE SET
+                    "max_concurrency" = EXCLUDED."max_concurrency",
+                    "max_size" = EXCLUDED."max_size",
+                    "release_interval_ms" = EXCLUDED."release_interval_ms",
+                    "released" = EXCLUDED."released",
+                    "dequeue_next_at" = CASE
+                        WHEN "channel"."message_id" IS NULL THEN NULL
+                        ELSE GREATEST(
+                            "channel"."message_dequeue_at",
+                            "channel"."dequeue_prev_at" + EXCLUDED."release_interval_ms"
+                        )
+                    END;
+            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 RECORD;
+                    v_message RECORD;
+                BEGIN
+                    v_now := ${ref(params.schema)}."epoch"();
+                    v_dequeue_at := COALESCE(p_dequeue_at, v_now);
+
+                    SELECT 
+                        "channel"."id",
+                        "channel"."current_concurrency",
+                        "channel"."current_size",
+                        "channel"."max_concurrency",
+                        "channel"."max_size",
+                        "channel"."release_interval_ms",
+                        "channel"."dequeue_prev_at",
+                        "channel"."message_id",
+                        "channel"."message_dequeue_at"
+                    FROM ${ref(params.schema)}."channel"
+                    WHERE "name" = p_channel
+                    AND NOT "released"
+                    FOR UPDATE
+                    INTO v_channel;
+
+                    IF v_channel."id" IS NULL THEN
+                        RETURN QUERY SELECT
+                            ${value(9)},
+                            NULL::JSON;
+                        RETURN;
+                    END IF;
+
+                    IF v_channel."current_size" >= v_channel."max_size" THEN
+                        RETURN QUERY SELECT
+                            ${value(1)},
+                            NULL::JSON;
+                        RETURN;
+                    END IF;
+
+                    INSERT INTO ${ref(params.schema)}."message" (
+                        "channel_id",
+                        "content",
+                        "num_attempts",
+                        "dequeue_at"
+                    ) VALUES (
+                        v_channel."id",
+                        p_content,
+                        0,
+                        v_dequeue_at
+                    ) RETURNING
+                        "id"
+                    INTO v_message;
+
+                    IF 
+                        v_channel."message_id" IS NULL OR
+                        v_dequeue_at < v_channel."message_dequeue_at" OR
+                        v_dequeue_at = v_channel."message_dequeue_at" AND v_message."id" < v_channel."message_id"
+                    THEN
+                        UPDATE ${ref(params.schema)}."channel" SET
+                            "current_size" = v_channel."current_size" + 1,
+                            "message_id" = v_message."id",
+                            "message_dequeue_at" = v_dequeue_at,
+                            "dequeue_next_at" = GREATEST(
+                                v_channel."dequeue_prev_at" + v_channel."release_interval_ms",
+                                v_dequeue_at
+                            )
+                        WHERE "id" = v_channel."id";
+                    ELSE
+                        UPDATE ${ref(params.schema)}."channel" SET
+                            "current_size" = v_channel."current_size" + 1
+                        WHERE "id" = v_channel."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
+	                        );
+                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 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"."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 v_message."unlock_at" IS NULL OR v_message."num_attempts" <> p_num_attempts THEN
+                        RETURN QUERY SELECT
+                            ${value(5)};
+                        RETURN;
+                    END IF;
+
+                    SELECT
+                        "channel"."current_concurrency",
+                        "channel"."release_interval_ms",
+                        "channel"."message_id",
+                        "channel"."message_dequeue_at",
+                        "channel"."dequeue_prev_at"
+                    FROM ${ref(params.schema)}."channel"
+                    WHERE "id" = v_message."channel_id"
+                    FOR UPDATE
+                    INTO v_channel;
+
+                    v_dequeue_at := COALESCE(p_dequeue_at, v_now);
+
+                    IF 
+                        v_channel."message_id" IS NULL OR 
+                        v_dequeue_at < v_channel."message_dequeue_at" OR
+                        v_dequeue_at = v_channel."message_dequeue_at" AND v_message."id" < v_channel."message_id"
+                    THEN
+                        UPDATE ${ref(params.schema)}."channel" SET
+                            "current_concurrency" = v_channel."current_concurrency" - 1,
+                            "message_id" = v_message."id",
+                            "message_dequeue_at" = v_dequeue_at,
+                            "dequeue_next_at" = GREATEST(
+                                v_channel."dequeue_prev_at" + v_channel."release_interval_ms",
+                                v_dequeue_at
+                            )
+                        WHERE "id" = v_message."channel_id";
+                    ELSE
+                        UPDATE ${ref(params.schema)}."channel" SET
+                            "current_concurrency" = v_channel."current_concurrency" - 1
+                        WHERE "id" = v_message."channel_id";
+                    END IF;
+
+                    UPDATE ${ref(params.schema)}."message" SET
+                        "state" = p_state,
+                        "unlock_at" = NULL,
+                        "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 "unlock_at" IS NOT NULL
+    AND "unlock_at" <= ${params.now}
+    ORDER BY "unlock_at" ASC
+`;
+const queryNextChannel = (params) => fragment`
+    SELECT
+        "channel"."id",
+        "channel"."release_interval_ms",
+        "channel"."message_id",
+        "channel"."dequeue_next_at",
+        "channel"."dequeue_prev_at",
+        "channel"."current_concurrency"
+    FROM ${ref(params.schema)}."channel"
+    WHERE "message_id" IS NOT NULL
+    AND "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 "unlock_at" IS NULL
+    AND "channel_id" = ${params.channel}
+    ORDER BY "dequeue_at" ASC, "id" ASC
+`;
+const dequeue = (params) => {
+	const nextLockedMessage = queryNextLockedMessage({
+		now: fragment`v_now`,
+		schema: params.schema
+	});
+	const nextChannelMessage = queryNextChannelMessage({
+		channel: fragment`v_channel."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 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,
+                                'num_attempts', v_message_locked."num_attempts" + 1
+                            );
+                        RETURN;
+                    END IF;
+
+                    ${nextChannel}
+                    FOR UPDATE
+	                    SKIP LOCKED
+	                    LIMIT 1
+	                    INTO v_channel;
+
+	                    IF v_channel."id" IS NULL OR v_channel."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."message_id"
+	                    INTO v_message_dequeue;
+
+                    UPDATE ${ref(params.schema)}."message" SET
+                        "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" SET
+	                            "current_concurrency" = v_channel."current_concurrency" + 1,
+	                            "dequeue_prev_at" = v_now,
+	                            "message_id" = NULL
+	                        WHERE "id" = v_channel."id";
+	                    ELSE
+	                        UPDATE ${ref(params.schema)}."channel" SET
+	                            "current_concurrency" = v_channel."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 + v_channel."release_interval_ms"
+	                            )
+	                        WHERE "id" = v_channel."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,
+                            '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"."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 v_message."unlock_at" IS NULL 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/complete.ts
+const complete = (params) => {
+	return [fragment`
+                CREATE FUNCTION ${ref(params.schema)}."message_complete" (
+                    p_id BIGINT,
+                    p_num_attempts BIGINT
+                )
+                RETURNS TABLE (
+                    result_code INTEGER
+                ) AS $$
+                DECLARE
+                    v_channel RECORD;
+                    v_message RECORD;
+                BEGIN
+                    SELECT
+                        "message"."id",
+                        "message"."channel_id",
+                        "message"."num_attempts",
+                        "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 v_message."unlock_at" IS NULL OR v_message."num_attempts" <> p_num_attempts THEN
+                        RETURN QUERY SELECT
+                            ${value(5)};
+                        RETURN;
+                    END IF;
+
+                    SELECT
+                        "channel"."id",
+                        "channel"."released",
+                        "channel"."current_size",
+                        "channel"."current_concurrency"
+                    FROM ${ref(params.schema)}."channel"
+                    WHERE "id" = v_message."channel_id"
+                    FOR UPDATE
+                    INTO v_channel;
+
+                    IF v_channel."released" AND v_channel."current_size" = 1 THEN
+                        DELETE FROM ${ref(params.schema)}."channel"
+                        WHERE "id" = v_channel."id";
+                    ELSE
+                        UPDATE ${ref(params.schema)}."channel" SET
+                            "current_concurrency" = v_channel."current_concurrency" - 1,
+                            "current_size" = v_channel."current_size" - 1
+                        WHERE "id" = v_channel."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.ts
+const channel = (params) => {
+	const dequeueIndex = [params.schema, "channel_dequeue_ix"].join("_");
+	const nameIndex = [params.schema, "channel_name_ix"].join("_");
+	return [
+		fragment`
+            CREATE TABLE ${ref(params.schema)}."channel" (
+                "id" BIGSERIAL NOT NULL,
+                "name" TEXT NOT NULL,
+                "released" BOOLEAN NOT NULL,
+                "max_concurrency" INTEGER NOT NULL,
+                "max_size" INTEGER NOT NULL,
+                "release_interval_ms" INTEGER NOT NULL,
+                "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 UNIQUE INDEX ${ref(nameIndex)}
+            ON ${ref(params.schema)}."channel" (
+                "name"
+            ) WHERE NOT "released";
+        `,
+		fragment`
+            CREATE INDEX ${ref(dequeueIndex)}
+            ON ${ref(params.schema)}."channel" (
+                "dequeue_next_at" ASC
+            ) WHERE "message_id" IS NOT NULL
+            AND "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" BIGINT NOT NULL,
+                "content" BYTEA NOT NULL,
+                "state" BYTEA,
+                "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 "unlock_at" IS NULL;
+        `,
+		fragment`
+            CREATE INDEX "message_locked_dequeue_ix"
+            ON ${ref(params.schema)}."message" (
+                "unlock_at" ASC
+            ) WHERE "unlock_at" IS NOT NULL;
+        `
+	];
+};
+//#endregion
+//#region src/queue/module/channel/message.ts
+var Message$1 = class {
+	schema;
+	channel;
+	adaptor;
+	constructor(params) {
+		this.schema = params.schema;
+		this.adaptor = params.adaptor;
+		this.channel = params.channel;
+	}
+	async create(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return await new Create({
+			schema: this.schema,
+			channel: this.channel,
+			content: params.content,
+			dequeueAt: params.dequeueAt ?? null
+		}).execute(adaptedClient);
+	}
+};
+//#endregion
+//#region src/queue/module/channel/index.ts
+var Channel = class {
+	schema;
+	adaptor;
+	channel;
+	message;
+	constructor(params) {
+		this.schema = params.schema;
+		this.adaptor = params.adaptor;
+		this.channel = params.channel;
+		this.message = new Message$1({
+			schema: params.schema,
+			adaptor: params.adaptor,
+			channel: params.channel
+		});
+	}
+	set(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return new Set({
+			schema: this.schema,
+			channel: this.channel,
+			maxConcurrency: params.maxConcurrency ?? 2147483647,
+			maxSize: params.maxSize ?? 2147483647,
+			releaseIntervalMs: params.releaseIntervalMs ?? 0
+		}).execute(adaptedClient);
+	}
+	release(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return new Release({
+			schema: this.schema,
+			channel: this.channel
+		}).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_COMPLETED",
+		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;
+	content;
+	state;
+	numAttempts;
+	constructor(params) {
+		this.schema = params.schema;
+		this.adaptor = params.adaptor;
+		this.id = params.id;
+		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 complete(params) {
+		const adaptedClient = this.adaptor(params.databaseClient);
+		return new Complete({
+			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;
+	lockMs;
+	adaptor;
+	constructor(params) {
+		this.schema = params.schema;
+		this.lockMs = params.lockMs;
+		this.adaptor = params.adaptor ? params.adaptor : (x) => x;
+	}
+	async dequeue(params) {
+		const dequeue = new Dequeue({
+			schema: this.schema,
+			lockMs: this.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,
+				isUnlocked: result.isUnlocked,
+				content: result.content,
+				state: result.state,
+				numAttempts: result.numAttempts
+			})
+		};
+		else return result;
+	}
+	channel(channel) {
+		return new Channel({
+			adaptor: this.adaptor,
+			schema: this.schema,
+			channel
+		});
+	}
+	install(params = {}) {
+		return [
+			channel,
+			message,
+			epoch,
+			set,
+			release,
+			create,
+			dequeue,
+			complete,
+			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 };