lonnymq 1.1.0 → 1.2.0

package/dist/index.mjs

@@ -1,4 +1,5 @@
-import { randomUUID } from "node:crypto";
+const INTEGER_MAX = 2147483647;
+//#endregion
 //#region src/util/sql.ts
 const value = (value) => ({
 	nodeType: "VALUE",
@@ -54,54 +55,57 @@ const dedent = (value) => {
 	return lines.map((line) => line.slice(minIndent)).join("\n").trim();
 };
 //#endregion
-//#region src/command/channel-policy/clear.ts
-var Clear = class {
+//#region src/command/channel/release.ts
+var Release = class {
 	schema;
-	channelId;
+	channel;
 	createdAt;
 	constructor(params) {
 		this.schema = params.schema;
-		this.channelId = params.channelId;
+		this.channel = params.channel;
 		this.createdAt = /* @__PURE__ */ new Date();
 	}
 	async execute(databaseClient) {
-		await databaseClient.query(fragment`
-            SELECT 1 FROM ${ref(this.schema)}."channel_policy_clear"(
+		const result = await databaseClient.query(fragment`
+            SELECT * FROM ${ref(this.schema)}."channel_release"(
                 $1
             )
-        `.value, [this.channelId]);
+        `.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-policy/set.ts
+//#region src/command/channel/set.ts
 var Set = class {
 	schema;
-	channelId;
+	channel;
 	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.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_policy_set"(
+            SELECT 1 FROM ${ref(this.schema)}."channel_set"(
                 $1,
                 $2::INTEGER,
                 $3::INTEGER,
                 $4::INTEGER
             )
         `.value, [
-			this.channelId,
+			this.channel,
 			this.maxConcurrency,
 			this.maxSize,
 			this.releaseIntervalMs
@@ -112,12 +116,12 @@ var Set = class {
 //#region src/command/message/create.ts
 var Create = class {
 	schema;
-	channelId;
+	channel;
 	content;
 	dequeueAt;
 	constructor(params) {
 		this.schema = params.schema;
-		this.channelId = params.channelId;
+		this.channel = params.channel;
 		this.content = params.content;
 		this.dequeueAt = params.dequeueAt;
 	}
@@ -132,16 +136,16 @@ var Create = class {
                 $3::BIGINT
             )
         `.value, [
-			this.channelId,
+			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),
-			channelSize: result.metadata.channel_size
+			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");
 	}
 };
@@ -167,7 +171,6 @@ var Dequeue = class {
 		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,
@@ -177,8 +180,8 @@ var Dequeue = class {
 	}
 };
 //#endregion
-//#region src/command/message/retire.ts
-var Retire = class {
+//#region src/command/message/complete.ts
+var Complete = class {
 	schema;
 	id;
 	numAttempts;
@@ -189,14 +192,14 @@ var Retire = class {
 	}
 	async execute(databaseClient) {
 		const result = await databaseClient.query(fragment`
-            SELECT * FROM ${ref(this.schema)}."message_retire"(
+            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_RETIRED" };
+		else if (result.result_code === 6) return { resultType: "MESSAGE_COMPLETED" };
 		else throw new Error("Unexpected result");
 	}
 };
@@ -284,70 +287,89 @@ const epoch = (params) => {
         `];
 };
 //#endregion
-//#region src/install/function/channel-policy/clear.ts
-const clear = (params) => {
+//#region src/install/function/channel/release.ts
+const release = (params) => {
 	return [fragment`
-            CREATE FUNCTION ${ref(params.schema)}."channel_policy_clear" (
-                p_id TEXT
-            ) RETURNS VOID AS $$
+            CREATE FUNCTION ${ref(params.schema)}."channel_release" (
+                p_text TEXT
+            ) RETURNS TABLE (
+                result_code INTEGER
+            ) AS $$
             DECLARE
-                v_channel_state RECORD;
+                v_channel 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
+                    "channel"."id",
+                    "channel"."current_size"
+                FROM ${ref(params.schema)}."channel"
+                WHERE "name" = p_text
+                AND NOT "released"
                 FOR UPDATE
-                INTO v_channel_state;
+                INTO v_channel;
 
-                IF v_channel_state."current_size" = 0 THEN
-                    DELETE FROM ${ref(params.schema)}."channel_state"
-                    WHERE "id" = v_channel_state."id";
+                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_state" SET
-                        "max_concurrency" = NULL,
-                        "release_interval_ms" = NULL
-                    WHERE "id" = p_id;
+                    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-policy/set.ts
+//#region src/install/function/channel/set.ts
 const set = (params) => {
 	return [fragment`
-            CREATE FUNCTION ${ref(params.schema)}."channel_policy_set" (
-                p_id TEXT,
+            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_policy" (
-                    "id",
+                INSERT INTO ${ref(params.schema)}."channel" (
+                    "name",
                     "max_concurrency",
                     "max_size",
-                    "release_interval_ms"
+                    "current_concurrency",
+                    "current_size",
+                    "release_interval_ms",
+                    "released",
+                    "dequeue_prev_at"
                 ) VALUES (
-                    p_id,
+                    p_text,
                     p_max_concurrency,
                     p_max_size,
-                    p_release_interval_ms
-                ) ON CONFLICT ("id") DO UPDATE SET
+                    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";
-
-                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;
+                    "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;
         `];
@@ -367,68 +389,36 @@ const create = (params) => {
                 DECLARE
                     v_now BIGINT;
                     v_dequeue_at BIGINT;
-                    v_channel_policy RECORD;
-                    v_channel_state RECORD;
+                    v_channel 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
+                        "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_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;
+                    INTO v_channel;
 
-                        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;
+                    IF v_channel."id" IS NULL THEN
+                        RETURN QUERY SELECT
+                            ${value(9)},
+                            NULL::JSON;
+                        RETURN;
                     END IF;
 
-                    IF v_channel_state."current_size" >= v_channel_state."max_size" THEN
+                    IF v_channel."current_size" >= v_channel."max_size" THEN
                         RETURN QUERY SELECT
                             ${value(1)},
                             NULL::JSON;
@@ -438,13 +428,11 @@ const create = (params) => {
                     INSERT INTO ${ref(params.schema)}."message" (
                         "channel_id",
                         "content",
-                        "is_locked",
                         "num_attempts",
                         "dequeue_at"
                     ) VALUES (
-                        p_channel,
+                        v_channel."id",
                         p_content,
-                        FALSE,
                         0,
                         v_dequeue_at
                     ) RETURNING
@@ -452,23 +440,23 @@ const create = (params) => {
                     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"
+                        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_state" SET
-                            "current_size" = v_channel_state."current_size" + 1,
+                        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_state."dequeue_prev_at" + COALESCE(v_channel_state."release_interval_ms", 0),
+                                v_channel."dequeue_prev_at" + v_channel."release_interval_ms",
                                 v_dequeue_at
                             )
-                        WHERE "id" = v_channel_state."id";
+                        WHERE "id" = v_channel."id";
                     ELSE
-                        UPDATE ${ref(params.schema)}."channel_state" SET
-                            "current_size" = v_channel_state."current_size" + 1
-                        WHERE "id" = v_channel_state."id";
+                        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
@@ -482,12 +470,11 @@ const create = (params) => {
                         );
                     END IF;
 
-                    RETURN QUERY SELECT
-                        ${value(0)},
-                        JSON_BUILD_OBJECT(
-                            'id', v_message."id"::TEXT,
-                            'channel_size', v_channel_state."current_size" + 1
-                        );
+	                    RETURN QUERY SELECT
+	                        ${value(0)},
+	                        JSON_BUILD_OBJECT(
+	                            'id', v_message."id"::TEXT
+	                        );
                 END;
                 $$ LANGUAGE plpgsql;
         `];
@@ -507,7 +494,7 @@ const defer = (params) => {
                 ) AS $$
                 DECLARE
                     v_now BIGINT;
-                    v_channel_state RECORD;
+                    v_channel RECORD;
                     v_message RECORD;
                     v_dequeue_at BIGINT;
                 BEGIN
@@ -517,7 +504,7 @@ const defer = (params) => {
                         "message"."id",
                         "message"."channel_id",
                         "message"."num_attempts",
-                        "message"."is_locked"
+                        "message"."unlock_at"
                     FROM ${ref(params.schema)}."message"
                     WHERE "id" = p_id
                     FOR UPDATE
@@ -527,48 +514,48 @@ const defer = (params) => {
                         RETURN QUERY SELECT
                             ${value(4)};
                         RETURN;
-                    ELSIF NOT v_message."is_locked" OR v_message."num_attempts" <> p_num_attempts THEN
+                    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_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"
+                        "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_state;
+                    INTO v_channel;
 
                     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"
+                        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_state" SET
-                            "current_concurrency" = v_channel_state."current_concurrency" - 1,
+                        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_state."dequeue_prev_at" + COALESCE(v_channel_state."release_interval_ms", 0),
+                                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_state" SET
-                            "current_concurrency" = v_channel_state."current_concurrency" - 1
+                        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,
-                        "is_locked" = FALSE,
+                        "unlock_at" = NULL,
                         "dequeue_at" = v_dequeue_at
                     WHERE "id" = p_id;
 
@@ -601,21 +588,21 @@ const queryNextLockedMessage = (params) => fragment`
         "message"."unlock_at",
         "message"."num_attempts"
     FROM ${ref(params.schema)}."message"
-    WHERE "is_locked"
+    WHERE "unlock_at" IS NOT NULL
     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"
+        "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 ("max_concurrency" IS NULL OR "current_concurrency" < "max_concurrency")
+    AND "current_concurrency" < "max_concurrency"
     ORDER BY "dequeue_next_at" ASC
 `;
 const queryNextChannelMessage = (params) => fragment`
@@ -623,8 +610,8 @@ const queryNextChannelMessage = (params) => fragment`
         "message"."id",
         "message"."dequeue_at"
     FROM ${ref(params.schema)}."message"
-    WHERE NOT "is_locked"
-    AND "channel_id" = ${params.channelId}
+    WHERE "unlock_at" IS NULL
+    AND "channel_id" = ${params.channel}
     ORDER BY "dequeue_at" ASC, "id" ASC
 `;
 const dequeue = (params) => {
@@ -633,7 +620,7 @@ const dequeue = (params) => {
 		schema: params.schema
 	});
 	const nextChannelMessage = queryNextChannelMessage({
-		channelId: fragment`v_channel_state."id"`,
+		channel: fragment`v_channel."id"`,
 		schema: params.schema
 	});
 	const nextChannel = queryNextChannel({ schema: params.schema });
@@ -647,12 +634,12 @@ const dequeue = (params) => {
                     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;
+	                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"();
 
@@ -675,7 +662,6 @@ const dequeue = (params) => {
                             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;
@@ -683,16 +669,16 @@ const dequeue = (params) => {
 
                     ${nextChannel}
                     FOR UPDATE
-                    SKIP LOCKED
-                    LIMIT 1
-                    INTO v_channel_state;
+	                    SKIP LOCKED
+	                    LIMIT 1
+	                    INTO v_channel;
 
-                    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;
+	                    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;
 
@@ -701,39 +687,38 @@ const dequeue = (params) => {
                         "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;
+	                        "message"."state"
+	                    FROM ${ref(params.schema)}."message"
+	                    WHERE "id" = v_channel."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;
+	                    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;
+	                    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)},
@@ -742,7 +727,6 @@ const dequeue = (params) => {
                         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;
@@ -771,7 +755,6 @@ const heartbeat = (params) => {
                     SELECT
                         "message"."id",
                         "message"."num_attempts",
-                        "message"."is_locked",
                         "message"."unlock_at"
                     FROM ${ref(params.schema)}."message"
                     WHERE "id" = p_id
@@ -782,7 +765,7 @@ const heartbeat = (params) => {
                         RETURN QUERY SELECT
                             ${value(4)};
                         RETURN;
-                    ELSIF NOT v_message."is_locked" OR v_message."num_attempts" <> p_num_attempts THEN
+                    ELSIF v_message."unlock_at" IS NULL OR v_message."num_attempts" <> p_num_attempts THEN
                         RETURN QUERY SELECT
                             ${value(5)};
                         RETURN;
@@ -803,10 +786,10 @@ const heartbeat = (params) => {
         `];
 };
 //#endregion
-//#region src/install/function/message/retire.ts
-const retire = (params) => {
+//#region src/install/function/message/complete.ts
+const complete = (params) => {
 	return [fragment`
-                CREATE FUNCTION ${ref(params.schema)}."message_retire" (
+                CREATE FUNCTION ${ref(params.schema)}."message_complete" (
                     p_id BIGINT,
                     p_num_attempts BIGINT
                 )
@@ -814,15 +797,14 @@ const retire = (params) => {
                     result_code INTEGER
                 ) AS $$
                 DECLARE
-                    v_channel_policy RECORD;
-                    v_channel_state RECORD;
+                    v_channel RECORD;
                     v_message RECORD;
                 BEGIN
                     SELECT
                         "message"."id",
                         "message"."channel_id",
                         "message"."num_attempts",
-                        "message"."is_locked"
+                        "message"."unlock_at"
                     FROM ${ref(params.schema)}."message"
                     WHERE "id" = p_id
                     FOR UPDATE
@@ -832,36 +814,30 @@ const retire = (params) => {
                         RETURN QUERY SELECT
                             ${value(4)};
                         RETURN;
-                    ELSIF NOT v_message."is_locked" OR v_message."num_attempts" <> p_num_attempts THEN
+                    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_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"
+                        "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_state;
+                    INTO v_channel;
 
-                    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";
+                    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_state" SET
-                            "current_concurrency" = v_channel_state."current_concurrency" - 1,
-                            "current_size" = v_channel_state."current_size" - 1
-                        WHERE "id" = v_channel_state."id";
+                        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
@@ -885,28 +861,19 @@ const retire = (params) => {
         `];
 };
 //#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,
+//#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,
@@ -915,13 +882,21 @@ const channelState = (params) => {
                 "dequeue_next_at" BIGINT NULL,
                 PRIMARY KEY ("id")
             );
-        `, fragment`
+        `,
+		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_state" (
+            ON ${ref(params.schema)}."channel" (
                 "dequeue_next_at" ASC
             ) WHERE "message_id" IS NOT NULL
-            AND ("max_concurrency" IS NULL OR "current_concurrency" < "max_concurrency");
-        `];
+            AND "current_concurrency" < "max_concurrency";
+        `
+	];
 };
 //#endregion
 //#region src/install/table/message.ts
@@ -930,10 +905,9 @@ const message = (params) => {
 		fragment`
             CREATE TABLE ${ref(params.schema)}."message" (
                 "id" BIGSERIAL NOT NULL,
-                "channel_id" TEXT NOT NULL,
+                "channel_id" BIGINT 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,
@@ -946,100 +920,69 @@ const message = (params) => {
                 "channel_id",
                 "dequeue_at" ASC,
                 "id" ASC
-            ) WHERE NOT "is_locked";
+            ) WHERE "unlock_at" IS NULL;
         `,
 		fragment`
             CREATE INDEX "message_locked_dequeue_ix"
             ON ${ref(params.schema)}."message" (
                 "unlock_at" ASC
-            ) WHERE "is_locked";
+            ) WHERE "unlock_at" IS NOT NULL;
         `
 	];
 };
 //#endregion
 //#region src/queue/module/channel/message.ts
-var Message$2 = class {
+var Message$1 = class {
 	schema;
-	channelId;
+	channel;
 	adaptor;
 	constructor(params) {
 		this.schema = params.schema;
 		this.adaptor = params.adaptor;
-		this.channelId = params.channelId;
+		this.channel = params.channel;
 	}
 	async create(params) {
 		const adaptedClient = this.adaptor(params.databaseClient);
 		return await new Create({
 			schema: this.schema,
-			channelId: this.channelId,
+			channel: this.channel,
 			content: params.content,
 			dequeueAt: params.dequeueAt ?? null
 		}).execute(adaptedClient);
 	}
 };
 //#endregion
-//#region src/queue/module/channel/policy.ts
-var Policy = class {
+//#region src/queue/module/channel/index.ts
+var Channel = class {
 	schema;
 	adaptor;
-	channelId;
+	channel;
+	message;
 	constructor(params) {
 		this.schema = params.schema;
 		this.adaptor = params.adaptor;
-		this.channelId = params.channelId;
+		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,
-			channelId: this.channelId,
-			maxConcurrency: params.maxConcurrency,
-			maxSize: params.maxSize,
-			releaseIntervalMs: params.releaseIntervalMs
+			channel: this.channel,
+			maxConcurrency: params.maxConcurrency ?? 2147483647,
+			maxSize: params.maxSize ?? 2147483647,
+			releaseIntervalMs: params.releaseIntervalMs ?? 0
 		}).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) {
+	release(params) {
 		const adaptedClient = this.adaptor(params.databaseClient);
-		return await new Create({
+		return new Release({
 			schema: this.schema,
-			content: params.content,
-			dequeueAt: params.dequeueAt ?? null,
-			channelId: randomUUID()
+			channel: this.channel
 		}).execute(adaptedClient);
 	}
 };
@@ -1053,7 +996,7 @@ const decode = (payload) => {
 		dequeueAt: Number(parsed.dequeue_at)
 	};
 	else if (parsed.type === 6) return {
-		eventType: "MESSAGE_RETIRED",
+		eventType: "MESSAGE_COMPLETED",
 		id: parsed.id
 	};
 	else if (parsed.type === 7) return {
@@ -1070,7 +1013,6 @@ var Message = class {
 	adaptor;
 	id;
 	isUnlocked;
-	channelId;
 	content;
 	state;
 	numAttempts;
@@ -1078,7 +1020,6 @@ var Message = class {
 		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;
@@ -1094,9 +1035,9 @@ var Message = class {
 			state: params.state ?? null
 		}).execute(adaptedClient);
 	}
-	async retire(params) {
+	async complete(params) {
 		const adaptedClient = this.adaptor(params.databaseClient);
-		return new Retire({
+		return new Complete({
 			schema: this.schema,
 			numAttempts: this.numAttempts,
 			id: this.id
@@ -1116,20 +1057,17 @@ var Message = class {
 //#region src/queue/index.ts
 var Queue = class {
 	schema;
-	message;
+	lockMs;
 	adaptor;
 	constructor(params) {
 		this.schema = params.schema;
+		this.lockMs = params.lockMs;
 		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
+			lockMs: this.lockMs
 		});
 		const adaptedClient = this.adaptor(params.databaseClient);
 		const result = await dequeue.execute(adaptedClient);
@@ -1139,7 +1077,6 @@ var Queue = class {
 				schema: this.schema,
 				adaptor: this.adaptor,
 				id: result.id,
-				channelId: result.channelId,
 				isUnlocked: result.isUnlocked,
 				content: result.content,
 				state: result.state,
@@ -1148,24 +1085,23 @@ var Queue = class {
 		};
 		else return result;
 	}
-	channel(channelId) {
+	channel(channel) {
 		return new Channel({
 			adaptor: this.adaptor,
 			schema: this.schema,
-			channelId
+			channel
 		});
 	}
 	install(params = {}) {
 		return [
-			channelPolicy,
-			channelState,
+			channel,
 			message,
 			epoch,
 			set,
-			clear,
+			release,
 			create,
 			dequeue,
-			retire,
+			complete,
 			defer,
 			heartbeat
 		].flatMap((install) => install({