prisma-pgmq 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Prisma PGMQ Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,402 @@
+# Prisma PGMQ
+
+A TypeScript library that provides type-safe methods for PostgreSQL Message Queue (PGMQ) operations in your Prisma-based applications.
+
+## Features
+
+- 🔒 **Type-safe**: Full TypeScript support with proper type definitions
+- 📦 **Easy to use**: Simple API with functional methods
+- 🔌 **Prisma Integration**: Seamless integration with your existing Prisma setup
+
+## Installation
+
+```bash
+npm install prisma-pgmq
+# or
+pnpm add prisma-pgmq
+# or
+yarn add prisma-pgmq
+```
+
+### Prerequisites
+
+- PostgreSQL database with the PGMQ extension installed
+- Prisma Client v5.0.0 or higher
+- Node.js 16+ 
+
+## Quick Start
+
+### Functional API
+
+```typescript
+import { PrismaClient } from '@prisma/client';
+import { pgmq } from 'prisma-pgmq';
+
+const prisma = new PrismaClient();
+
+// Create a queue
+await prisma.$transaction(async (tx) => {
+  await pgmq.createQueue(tx, 'my-work-queue');
+});
+
+// Send a message
+await prisma.$transaction(async (tx) => {
+  const msgId = await pgmq.send(tx, 'my-work-queue', {
+    userId: 123,
+    action: 'send-email',
+    email: 'user@example.com'
+  });
+  console.log('Message sent with ID:', msgId);
+});
+```
+
+## API Reference
+
+### Message Operations
+
+#### `send(queueName, message, delay?)`
+Send a single message to a queue.
+
+```typescript
+// Send immediately
+const msgId = await prisma.$pgmq.send('my-queue', { data: 'hello' });
+
+// Send with delay (seconds)
+const msgId = await prisma.$pgmq.send('my-queue', { data: 'hello' }, 30);
+
+// Send with specific time
+const msgId = await prisma.$pgmq.send('my-queue', { data: 'hello' }, new Date('2024-01-01T10:00:00Z'));
+```
+
+#### `sendBatch(queueName, messages, delay?)`
+Send multiple messages to a queue in a single operation.
+
+```typescript
+const msgIds = await prisma.$pgmq.sendBatch('my-queue', [
+  { id: 1, data: 'message 1' },
+  { id: 2, data: 'message 2' },
+  { id: 3, data: 'message 3' }
+]);
+```
+
+#### `read(queueName, vt, qty?, conditional?)`
+Read messages from a queue with visibility timeout.
+
+```typescript
+// Read up to 5 messages with 30 second visibility timeout
+const messages = await prisma.$pgmq.read('my-queue', 30, 5);
+
+// Read with conditional filtering
+const messages = await prisma.$pgmq.read('my-queue', 30, 5, { priority: 'high' });
+```
+
+#### `readWithPoll(queueName, vt, qty?, maxPollSeconds?, pollIntervalMs?, conditional?)`
+Read messages with polling (wait for messages if none available).
+
+```typescript
+// Poll for up to 10 seconds, checking every 500ms
+const messages = await prisma.$pgmq.readWithPoll('my-queue', 30, 1, 10, 500);
+```
+
+#### `pop(queueName)`
+Read and immediately delete a message (atomic operation).
+
+```typescript
+const messages = await prisma.$pgmq.pop('my-queue');
+```
+
+### Message Management
+
+#### `deleteMessage(queueName, msgId)`
+Delete a specific message.
+
+```typescript
+const deleted = await prisma.$pgmq.deleteMessage('my-queue', 123);
+```
+
+#### `deleteBatch(queueName, msgIds)`
+Delete multiple messages.
+
+```typescript
+const deletedIds = await prisma.$pgmq.deleteBatch('my-queue', [123, 124, 125]);
+```
+
+#### `archive(queueName, msgId)`
+Archive a message (move to archive table).
+
+```typescript
+const archived = await prisma.$pgmq.archive('my-queue', 123);
+```
+
+#### `archiveBatch(queueName, msgIds)`
+Archive multiple messages.
+
+```typescript
+const archivedIds = await prisma.$pgmq.archiveBatch('my-queue', [123, 124, 125]);
+```
+
+### Queue Management
+
+#### `createQueue(queueName)`
+Create a new queue.
+
+```typescript
+await prisma.$pgmq.createQueue('my-new-queue');
+```
+
+#### `createPartitionedQueue(queueName, partitionInterval?, retentionInterval?)`
+Create a partitioned queue for high-throughput scenarios.
+
+```typescript
+await prisma.$pgmq.createPartitionedQueue('high-volume-queue', '10000', '100000');
+```
+
+#### `createUnloggedQueue(queueName)`
+Create an unlogged queue (better performance, less durability).
+
+```typescript
+await prisma.$pgmq.createUnloggedQueue('temp-queue');
+```
+
+#### `dropQueue(queueName)`
+Delete a queue and all its messages.
+
+```typescript
+const dropped = await prisma.$pgmq.dropQueue('old-queue');
+```
+
+#### `purgeQueue(queueName)`
+Remove all messages from a queue.
+
+```typescript
+const messageCount = await prisma.$pgmq.purgeQueue('my-queue');
+```
+
+### Utilities
+
+#### `setVt(queueName, msgId, vtOffset)`
+Set visibility timeout for a specific message.
+
+```typescript
+const message = await prisma.$pgmq.setVt('my-queue', 123, 60); // 60 seconds
+```
+
+#### `listQueues()`
+Get information about all queues.
+
+```typescript
+const queues = await prisma.$pgmq.listQueues();
+console.log(queues); // [{ queue_name: 'my-queue', created_at: ..., is_partitioned: false }]
+```
+
+#### `metrics(queueName)`
+Get metrics for a specific queue.
+
+```typescript
+const metrics = await prisma.$pgmq.metrics('my-queue');
+console.log(metrics);
+// {
+//   queue_name: 'my-queue',
+//   queue_length: 5n,
+//   newest_msg_age_sec: 10,
+//   oldest_msg_age_sec: 300,
+//   total_messages: 1000n,
+//   scrape_time: 2024-01-01T10:00:00.000Z
+// }
+```
+
+#### `metricsAll()`
+Get metrics for all queues.
+
+```typescript
+const allMetrics = await prisma.$pgmq.metricsAll();
+```
+
+## Type Definitions
+
+### `Task`
+```typescript
+type Task = Record<string, unknown>;
+```
+
+### `MessageRecord`
+```typescript
+interface MessageRecord {
+  msg_id: number;
+  read_ct: number;
+  enqueued_at: Date;
+  vt: Date;
+  message: Task;
+}
+```
+
+### `QueueMetrics`
+```typescript
+interface QueueMetrics {
+  queue_name: string;
+  queue_length: number;
+  newest_msg_age_sec: number | null;
+  oldest_msg_age_sec: number | null;
+  total_messages: number;
+  scrape_time: Date;
+}
+```
+
+### `QueueInfo`
+```typescript
+interface QueueInfo {
+  queue_name: string;
+  created_at: Date;
+  is_partitioned: boolean;
+  is_unlogged: boolean;
+}
+```
+
+## Best Practices
+
+### 1. Use Appropriate Visibility Timeouts
+Choose visibility timeouts based on your message processing time:
+
+```typescript
+// For quick operations (30 seconds)
+const messages = await prisma.$pgmq.read('quick-tasks', 30);
+
+// For longer operations (5 minutes)
+const messages = await prisma.$pgmq.read('heavy-tasks', 300);
+```
+
+### 2. Handle Message Processing Failures
+Always delete or archive messages after successful processing:
+
+```typescript
+const messages = await prisma.$pgmq.read('my-queue', 30, 10);
+
+for (const message of messages) {
+  try {
+    await processMessage(message.message);
+    await prisma.$pgmq.deleteMessage('my-queue', message.msg_id);
+  } catch (error) {
+    // Handle error - message will become visible again after timeout
+    console.error('Failed to process message:', error);
+    // Optionally archive failed messages
+    await prisma.$pgmq.archive('my-queue', message.msg_id);
+  }
+}
+```
+
+## Examples
+
+### Basic Worker Pattern
+
+```typescript
+import { PrismaClient } from '@prisma/client';
+import { pgmq } from 'prisma-pgmq';
+
+const prisma = new PrismaClient();
+
+// Producer
+async function sendTask(taskData: any) {
+  await prisma.$transaction(async (tx) => {
+    await pgmq.send(tx, 'work-queue', {
+      type: 'process-user-data',
+      data: taskData,
+      timestamp: Date.now()
+    });
+  });
+}
+
+// Consumer
+async function processMessages() {
+  while (true) {
+    await prisma.$transaction(async (tx) => {
+      const messages = await pgmq.readWithPoll(tx, 'work-queue', 30, 5, 10, 1000);
+      for (const message of messages) {
+        try {
+          // Process the message
+          await handleTask(message.message);
+          // Delete on success
+          await pgmq.deleteMessage(tx, 'work-queue', message.msg_id);
+        } catch (error) {
+          console.error('Task failed:', error);
+          // Archive failed messages for later analysis
+          await pgmq.archive(tx, 'work-queue', message.msg_id);
+        }
+      }
+    });
+  }
+}
+
+async function handleTask(task: any) {
+  // Your business logic here
+  console.log('Processing task:', task.type);
+}
+```
+
+### Delayed Message Scheduling
+
+```typescript
+// Schedule a message for later processing
+const futureDate = new Date(Date.now() + 24 * 60 * 60 * 1000); // 24 hours
+
+await prisma.$pgmq.send('scheduled-tasks', {
+  type: 'send-reminder',
+  userId: 123,
+  reminder: 'Your subscription expires tomorrow'
+}, futureDate);
+```
+
+### Priority Queue Pattern
+
+```typescript
+// Send high-priority message
+await prisma.$pgmq.send('tasks', {
+  priority: 'high',
+  type: 'urgent-processing',
+  data: urgentData
+});
+
+// Read high-priority messages first
+const highPriorityMessages = await prisma.$pgmq.read('tasks', 30, 10, { priority: 'high' });
+
+if (highPriorityMessages.length === 0) {
+  // Fall back to normal priority
+  const normalMessages = await prisma.$pgmq.read('tasks', 30, 10, { priority: 'normal' });
+}
+```
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'feat: add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/your-username/prisma-pgmq.git
+cd prisma-pgmq
+
+# Install dependencies
+pnpm install
+
+# Run tests
+pnpm test
+
+# Build the library
+pnpm build
+
+# Watch for changes during development
+pnpm dev
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Acknowledgments
+
+- [PGMQ](https://github.com/pgmq/pgmq) - PostgreSQL Message Queue extension
+- [Prisma](https://www.prisma.io/) - Next-generation ORM for TypeScript & Node.js

package/dist/index.d.mts

@@ -0,0 +1,72 @@
+import { Prisma } from '@prisma/client/extension';
+
+type Task = Record<string, unknown>;
+interface MessageRecord {
+    msg_id: number;
+    read_ct: number;
+    enqueued_at: Date;
+    vt: Date;
+    message: Task;
+}
+interface QueueMetrics {
+    queue_name: string;
+    queue_length: number;
+    newest_msg_age_sec: number | null;
+    oldest_msg_age_sec: number | null;
+    total_messages: number;
+    scrape_time: Date;
+}
+interface QueueInfo {
+    queue_name: string;
+    created_at: Date;
+    is_partitioned: boolean;
+    is_unlogged: boolean;
+}
+declare function send(tx: Prisma.TransactionClient, queueName: string, msg: Task, delay?: number | Date): Promise<number>;
+declare function sendBatch(tx: Prisma.TransactionClient, queueName: string, msgs: Task[], delay?: number | Date): Promise<number[]>;
+declare function read(tx: Prisma.TransactionClient, queueName: string, vt: number, qty?: number, conditional?: Task): Promise<MessageRecord[]>;
+declare function readWithPoll(tx: Prisma.TransactionClient, queueName: string, vt: number, qty?: number, maxPollSeconds?: number, pollIntervalMs?: number, conditional?: Task): Promise<MessageRecord[]>;
+declare function pop(tx: Prisma.TransactionClient, queueName: string): Promise<MessageRecord[]>;
+declare function deleteMessage(tx: Prisma.TransactionClient, queueName: string, msgId: number): Promise<boolean>;
+declare function deleteBatch(tx: Prisma.TransactionClient, queueName: string, msgIds: number[]): Promise<number[]>;
+declare function purgeQueue(tx: Prisma.TransactionClient, queueName: string): Promise<number>;
+declare function archive(tx: Prisma.TransactionClient, queueName: string, msgId: number): Promise<boolean>;
+declare function archiveBatch(tx: Prisma.TransactionClient, queueName: string, msgIds: number[]): Promise<number[]>;
+declare function createQueue(tx: Prisma.TransactionClient, queueName: string): Promise<void>;
+declare function createPartitionedQueue(tx: Prisma.TransactionClient, queueName: string, partitionInterval?: string, retentionInterval?: string): Promise<void>;
+declare function createUnloggedQueue(tx: Prisma.TransactionClient, queueName: string): Promise<void>;
+declare function detachArchive(tx: Prisma.TransactionClient, queueName: string): Promise<void>;
+declare function dropQueue(tx: Prisma.TransactionClient, queueName: string): Promise<boolean>;
+declare function setVt(tx: Prisma.TransactionClient, queueName: string, msgId: number, vtOffset: number): Promise<MessageRecord>;
+declare function listQueues(tx: Prisma.TransactionClient): Promise<QueueInfo[]>;
+declare function metrics(tx: Prisma.TransactionClient, queueName: string): Promise<QueueMetrics>;
+declare function metricsAll(tx: Prisma.TransactionClient): Promise<QueueMetrics[]>;
+
+type pgmq_MessageRecord = MessageRecord;
+type pgmq_QueueInfo = QueueInfo;
+type pgmq_QueueMetrics = QueueMetrics;
+type pgmq_Task = Task;
+declare const pgmq_archive: typeof archive;
+declare const pgmq_archiveBatch: typeof archiveBatch;
+declare const pgmq_createPartitionedQueue: typeof createPartitionedQueue;
+declare const pgmq_createQueue: typeof createQueue;
+declare const pgmq_createUnloggedQueue: typeof createUnloggedQueue;
+declare const pgmq_deleteBatch: typeof deleteBatch;
+declare const pgmq_deleteMessage: typeof deleteMessage;
+declare const pgmq_detachArchive: typeof detachArchive;
+declare const pgmq_dropQueue: typeof dropQueue;
+declare const pgmq_listQueues: typeof listQueues;
+declare const pgmq_metrics: typeof metrics;
+declare const pgmq_metricsAll: typeof metricsAll;
+declare const pgmq_pop: typeof pop;
+declare const pgmq_purgeQueue: typeof purgeQueue;
+declare const pgmq_read: typeof read;
+declare const pgmq_readWithPoll: typeof readWithPoll;
+declare const pgmq_send: typeof send;
+declare const pgmq_sendBatch: typeof sendBatch;
+declare const pgmq_setVt: typeof setVt;
+declare namespace pgmq {
+  export { type pgmq_MessageRecord as MessageRecord, type pgmq_QueueInfo as QueueInfo, type pgmq_QueueMetrics as QueueMetrics, type pgmq_Task as Task, pgmq_archive as archive, pgmq_archiveBatch as archiveBatch, pgmq_createPartitionedQueue as createPartitionedQueue, pgmq_createQueue as createQueue, pgmq_createUnloggedQueue as createUnloggedQueue, pgmq_deleteBatch as deleteBatch, pgmq_deleteMessage as deleteMessage, pgmq_detachArchive as detachArchive, pgmq_dropQueue as dropQueue, pgmq_listQueues as listQueues, pgmq_metrics as metrics, pgmq_metricsAll as metricsAll, pgmq_pop as pop, pgmq_purgeQueue as purgeQueue, pgmq_read as read, pgmq_readWithPoll as readWithPoll, pgmq_send as send, pgmq_sendBatch as sendBatch, pgmq_setVt as setVt };
+}
+
+export { type MessageRecord, type QueueInfo, type QueueMetrics, type Task, pgmq };

package/dist/index.d.ts

@@ -0,0 +1,72 @@
+import { Prisma } from '@prisma/client/extension';
+
+type Task = Record<string, unknown>;
+interface MessageRecord {
+    msg_id: number;
+    read_ct: number;
+    enqueued_at: Date;
+    vt: Date;
+    message: Task;
+}
+interface QueueMetrics {
+    queue_name: string;
+    queue_length: number;
+    newest_msg_age_sec: number | null;
+    oldest_msg_age_sec: number | null;
+    total_messages: number;
+    scrape_time: Date;
+}
+interface QueueInfo {
+    queue_name: string;
+    created_at: Date;
+    is_partitioned: boolean;
+    is_unlogged: boolean;
+}
+declare function send(tx: Prisma.TransactionClient, queueName: string, msg: Task, delay?: number | Date): Promise<number>;
+declare function sendBatch(tx: Prisma.TransactionClient, queueName: string, msgs: Task[], delay?: number | Date): Promise<number[]>;
+declare function read(tx: Prisma.TransactionClient, queueName: string, vt: number, qty?: number, conditional?: Task): Promise<MessageRecord[]>;
+declare function readWithPoll(tx: Prisma.TransactionClient, queueName: string, vt: number, qty?: number, maxPollSeconds?: number, pollIntervalMs?: number, conditional?: Task): Promise<MessageRecord[]>;
+declare function pop(tx: Prisma.TransactionClient, queueName: string): Promise<MessageRecord[]>;
+declare function deleteMessage(tx: Prisma.TransactionClient, queueName: string, msgId: number): Promise<boolean>;
+declare function deleteBatch(tx: Prisma.TransactionClient, queueName: string, msgIds: number[]): Promise<number[]>;
+declare function purgeQueue(tx: Prisma.TransactionClient, queueName: string): Promise<number>;
+declare function archive(tx: Prisma.TransactionClient, queueName: string, msgId: number): Promise<boolean>;
+declare function archiveBatch(tx: Prisma.TransactionClient, queueName: string, msgIds: number[]): Promise<number[]>;
+declare function createQueue(tx: Prisma.TransactionClient, queueName: string): Promise<void>;
+declare function createPartitionedQueue(tx: Prisma.TransactionClient, queueName: string, partitionInterval?: string, retentionInterval?: string): Promise<void>;
+declare function createUnloggedQueue(tx: Prisma.TransactionClient, queueName: string): Promise<void>;
+declare function detachArchive(tx: Prisma.TransactionClient, queueName: string): Promise<void>;
+declare function dropQueue(tx: Prisma.TransactionClient, queueName: string): Promise<boolean>;
+declare function setVt(tx: Prisma.TransactionClient, queueName: string, msgId: number, vtOffset: number): Promise<MessageRecord>;
+declare function listQueues(tx: Prisma.TransactionClient): Promise<QueueInfo[]>;
+declare function metrics(tx: Prisma.TransactionClient, queueName: string): Promise<QueueMetrics>;
+declare function metricsAll(tx: Prisma.TransactionClient): Promise<QueueMetrics[]>;
+
+type pgmq_MessageRecord = MessageRecord;
+type pgmq_QueueInfo = QueueInfo;
+type pgmq_QueueMetrics = QueueMetrics;
+type pgmq_Task = Task;
+declare const pgmq_archive: typeof archive;
+declare const pgmq_archiveBatch: typeof archiveBatch;
+declare const pgmq_createPartitionedQueue: typeof createPartitionedQueue;
+declare const pgmq_createQueue: typeof createQueue;
+declare const pgmq_createUnloggedQueue: typeof createUnloggedQueue;
+declare const pgmq_deleteBatch: typeof deleteBatch;
+declare const pgmq_deleteMessage: typeof deleteMessage;
+declare const pgmq_detachArchive: typeof detachArchive;
+declare const pgmq_dropQueue: typeof dropQueue;
+declare const pgmq_listQueues: typeof listQueues;
+declare const pgmq_metrics: typeof metrics;
+declare const pgmq_metricsAll: typeof metricsAll;
+declare const pgmq_pop: typeof pop;
+declare const pgmq_purgeQueue: typeof purgeQueue;
+declare const pgmq_read: typeof read;
+declare const pgmq_readWithPoll: typeof readWithPoll;
+declare const pgmq_send: typeof send;
+declare const pgmq_sendBatch: typeof sendBatch;
+declare const pgmq_setVt: typeof setVt;
+declare namespace pgmq {
+  export { type pgmq_MessageRecord as MessageRecord, type pgmq_QueueInfo as QueueInfo, type pgmq_QueueMetrics as QueueMetrics, type pgmq_Task as Task, pgmq_archive as archive, pgmq_archiveBatch as archiveBatch, pgmq_createPartitionedQueue as createPartitionedQueue, pgmq_createQueue as createQueue, pgmq_createUnloggedQueue as createUnloggedQueue, pgmq_deleteBatch as deleteBatch, pgmq_deleteMessage as deleteMessage, pgmq_detachArchive as detachArchive, pgmq_dropQueue as dropQueue, pgmq_listQueues as listQueues, pgmq_metrics as metrics, pgmq_metricsAll as metricsAll, pgmq_pop as pop, pgmq_purgeQueue as purgeQueue, pgmq_read as read, pgmq_readWithPoll as readWithPoll, pgmq_send as send, pgmq_sendBatch as sendBatch, pgmq_setVt as setVt };
+}
+
+export { type MessageRecord, type QueueInfo, type QueueMetrics, type Task, pgmq };

package/dist/index.js

@@ -0,0 +1,157 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  pgmq: () => pgmq_exports
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/pgmq.ts
+var pgmq_exports = {};
+__export(pgmq_exports, {
+  archive: () => archive,
+  archiveBatch: () => archiveBatch,
+  createPartitionedQueue: () => createPartitionedQueue,
+  createQueue: () => createQueue,
+  createUnloggedQueue: () => createUnloggedQueue,
+  deleteBatch: () => deleteBatch,
+  deleteMessage: () => deleteMessage,
+  detachArchive: () => detachArchive,
+  dropQueue: () => dropQueue,
+  listQueues: () => listQueues,
+  metrics: () => metrics,
+  metricsAll: () => metricsAll,
+  pop: () => pop,
+  purgeQueue: () => purgeQueue,
+  read: () => read,
+  readWithPoll: () => readWithPoll,
+  send: () => send,
+  sendBatch: () => sendBatch,
+  setVt: () => setVt
+});
+var import_extension = require("@prisma/client/extension");
+var PrismaAny = import_extension.Prisma;
+async function send(tx, queueName, msg, delay) {
+  const delayRepr = typeof delay === "number" ? PrismaAny.sql`${delay}::integer` : PrismaAny.sql`${delay}`;
+  const delaySql = delay ? PrismaAny.sql`, ${delayRepr}` : PrismaAny.sql``;
+  const result = await tx.$queryRaw`SELECT pgmq.send(${queueName}, ${msg}${delaySql})`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.send");
+  }
+  return firstResult.send;
+}
+async function sendBatch(tx, queueName, msgs, delay) {
+  const delayRepr = typeof delay === "number" ? PrismaAny.sql`${delay}::integer` : PrismaAny.sql`${delay}`;
+  const delaySql = delay ? PrismaAny.sql`, ${delayRepr}` : PrismaAny.sql``;
+  const result = await tx.$queryRaw`SELECT pgmq.send_batch(${queueName}, ${msgs}${delaySql})`;
+  return result.map((a) => a.send_batch);
+}
+function read(tx, queueName, vt, qty = 1, conditional = {}) {
+  return tx.$queryRaw`SELECT * FROM pgmq.read(${queueName}, ${vt}::integer, ${qty}::integer, ${conditional})`;
+}
+function readWithPoll(tx, queueName, vt, qty = 1, maxPollSeconds = 5, pollIntervalMs = 100, conditional = {}) {
+  return tx.$queryRaw`SELECT * FROM pgmq.read_with_poll(${queueName}, ${vt}::integer, ${qty}::integer, ${maxPollSeconds}::integer, ${pollIntervalMs}::integer, ${conditional})`;
+}
+function pop(tx, queueName) {
+  return tx.$queryRaw`SELECT * FROM pgmq.pop(${queueName})`;
+}
+async function deleteMessage(tx, queueName, msgId) {
+  const result = await tx.$queryRaw`SELECT pgmq.delete(${queueName}, ${msgId}::integer)`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.delete");
+  }
+  return firstResult.delete;
+}
+async function deleteBatch(tx, queueName, msgIds) {
+  const result = await tx.$queryRaw`SELECT pgmq.delete(${queueName}, ${msgIds}::integer[])`;
+  return result.map((a) => a.delete);
+}
+async function purgeQueue(tx, queueName) {
+  const result = await tx.$queryRaw`SELECT pgmq.purge_queue(${queueName})`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.purge_queue");
+  }
+  return firstResult.purge_queue;
+}
+async function archive(tx, queueName, msgId) {
+  const result = await tx.$queryRaw`SELECT pgmq.archive(${queueName}, ${msgId}::integer)`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.archive");
+  }
+  return firstResult.archive;
+}
+async function archiveBatch(tx, queueName, msgIds) {
+  const result = await tx.$queryRaw`SELECT pgmq.archive(${queueName}, ${msgIds}::integer[])`;
+  return result.map((a) => a.archive);
+}
+async function createQueue(tx, queueName) {
+  await tx.$executeRaw`SELECT pgmq.create(${queueName})`;
+}
+async function createPartitionedQueue(tx, queueName, partitionInterval = "10000", retentionInterval = "100000") {
+  await tx.$executeRaw`SELECT pgmq.create_partitioned(${queueName}, ${partitionInterval}, ${retentionInterval})`;
+}
+async function createUnloggedQueue(tx, queueName) {
+  await tx.$executeRaw`SELECT pgmq.create_unlogged(${queueName})`;
+}
+async function detachArchive(tx, queueName) {
+  await tx.$executeRaw`SELECT pgmq.detach_archive(${queueName})`;
+}
+async function dropQueue(tx, queueName) {
+  const result = await tx.$queryRaw`SELECT pgmq.drop_queue(${queueName})`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.drop_queue");
+  }
+  return firstResult.drop_queue;
+}
+async function setVt(tx, queueName, msgId, vtOffset) {
+  const result = await tx.$queryRaw`SELECT * FROM pgmq.set_vt(${queueName}, ${msgId}::integer, ${vtOffset}::integer)`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.set_vt");
+  }
+  return firstResult;
+}
+async function listQueues(tx) {
+  const result = await tx.$queryRaw`SELECT * FROM pgmq.list_queues()`;
+  return result;
+}
+async function metrics(tx, queueName) {
+  const result = await tx.$queryRaw`SELECT * FROM pgmq.metrics(${queueName})`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.metrics");
+  }
+  return firstResult;
+}
+async function metricsAll(tx) {
+  const result = await tx.$queryRaw`SELECT * FROM pgmq.metrics_all()`;
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pgmq
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/pgmq.ts"],"sourcesContent":["export { \n  Task,\n  MessageRecord,\n  QueueInfo,\n  QueueMetrics,\n } from './pgmq';\n \nexport * as pgmq from './pgmq';","import { Prisma } from '@prisma/client/extension';\n\nexport type Task = Record<string, unknown>;\n\n// Message record type based on PGMQ documentation\nexport interface MessageRecord {\n  msg_id: number;\n  read_ct: number;\n  enqueued_at: Date;\n  vt: Date;\n  message: Task;\n}\n\n// Queue metrics type\nexport interface QueueMetrics {\n  queue_name: string;\n  queue_length: number;\n  newest_msg_age_sec: number | null;\n  oldest_msg_age_sec: number | null;\n  total_messages: number;\n  scrape_time: Date;\n}\n\n// Queue info type\nexport interface QueueInfo {\n  queue_name: string;\n  created_at: Date;\n  is_partitioned: boolean;\n  is_unlogged: boolean;\n}\n\n// I expect that Prisma has `sql` defined\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst PrismaAny = Prisma as any;\n\nexport async function send(tx: Prisma.TransactionClient, queueName: string, msg: Task, delay?: number | Date): Promise<number> {\n    const delayRepr = typeof delay === 'number' ? PrismaAny.sql`${delay}::integer` : PrismaAny.sql`${delay}`;\n    const delaySql = delay ? PrismaAny.sql`, ${delayRepr}` : PrismaAny.sql``;\n    const result: { send: number }[] = await tx.$queryRaw`SELECT pgmq.send(${queueName}, ${msg}${delaySql})`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.send');\n    }\n    return firstResult.send;\n}\n\nexport async function sendBatch(tx: Prisma.TransactionClient, queueName: string, msgs: Task[], delay?: number | Date): Promise<number[]> {\n    const delayRepr = typeof delay === 'number' ? PrismaAny.sql`${delay}::integer` : PrismaAny.sql`${delay}`;\n    const delaySql = delay ? PrismaAny.sql`, ${delayRepr}` : PrismaAny.sql``;\n    const result: { send_batch: number }[] = await tx.$queryRaw`SELECT pgmq.send_batch(${queueName}, ${msgs}${delaySql})`;\n    return result.map(a => a.send_batch);\n}\n\n// Reading Messages\n\nexport function read(\n    tx: Prisma.TransactionClient, \n    queueName: string, \n    vt: number, \n    qty: number = 1, \n    conditional: Task = {}\n): Promise<MessageRecord[]> {\n    return tx.$queryRaw`SELECT * FROM pgmq.read(${queueName}, ${vt}::integer, ${qty}::integer, ${conditional})` as Promise<MessageRecord[]>;\n}\n\nexport function readWithPoll(\n    tx: Prisma.TransactionClient,\n    queueName: string,\n    vt: number,\n    qty: number = 1,\n    maxPollSeconds: number = 5,\n    pollIntervalMs: number = 100,\n    conditional: Task = {}\n): Promise<MessageRecord[]> {\n    return tx.$queryRaw`SELECT * FROM pgmq.read_with_poll(${queueName}, ${vt}::integer, ${qty}::integer, ${maxPollSeconds}::integer, ${pollIntervalMs}::integer, ${conditional})` as Promise<MessageRecord[]>;\n}\n\nexport function pop(tx: Prisma.TransactionClient, queueName: string): Promise<MessageRecord[]> {\n    return tx.$queryRaw`SELECT * FROM pgmq.pop(${queueName})` as Promise<MessageRecord[]>;\n}\n\n// Deleting/Archiving Messages\n\nexport async function deleteMessage(tx: Prisma.TransactionClient, queueName: string, msgId: number): Promise<boolean> {\n    const result: { delete: boolean }[] = await tx.$queryRaw`SELECT pgmq.delete(${queueName}, ${msgId}::integer)`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.delete');\n    }\n    return firstResult.delete;\n}\n\nexport async function deleteBatch(tx: Prisma.TransactionClient, queueName: string, msgIds: number[]): Promise<number[]> {\n    const result: { delete: number }[] = await tx.$queryRaw`SELECT pgmq.delete(${queueName}, ${msgIds}::integer[])`;\n    return result.map(a => a.delete);\n}\n\nexport async function purgeQueue(tx: Prisma.TransactionClient, queueName: string): Promise<number> {\n    const result: { purge_queue: number }[] = await tx.$queryRaw`SELECT pgmq.purge_queue(${queueName})`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.purge_queue');\n    }\n    return firstResult.purge_queue;\n}\n\nexport async function archive(tx: Prisma.TransactionClient, queueName: string, msgId: number): Promise<boolean> {\n    const result: { archive: boolean }[] = await tx.$queryRaw`SELECT pgmq.archive(${queueName}, ${msgId}::integer)`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.archive');\n    }\n    return firstResult.archive;\n}\n\nexport async function archiveBatch(tx: Prisma.TransactionClient, queueName: string, msgIds: number[]): Promise<number[]> {\n    const result: { archive: number }[] = await tx.$queryRaw`SELECT pgmq.archive(${queueName}, ${msgIds}::integer[])`;\n    return result.map(a => a.archive);\n}\n\n// Queue Management\n\nexport async function createQueue(tx: Prisma.TransactionClient, queueName: string): Promise<void> {\n    await tx.$executeRaw`SELECT pgmq.create(${queueName})`;\n}\n\nexport async function createPartitionedQueue(\n    tx: Prisma.TransactionClient, \n    queueName: string, \n    partitionInterval: string = '10000', \n    retentionInterval: string = '100000'\n): Promise<void> {\n    await tx.$executeRaw`SELECT pgmq.create_partitioned(${queueName}, ${partitionInterval}, ${retentionInterval})`;\n}\n\nexport async function createUnloggedQueue(tx: Prisma.TransactionClient, queueName: string): Promise<void> {\n    await tx.$executeRaw`SELECT pgmq.create_unlogged(${queueName})`;\n}\n\nexport async function detachArchive(tx: Prisma.TransactionClient, queueName: string): Promise<void> {\n    await tx.$executeRaw`SELECT pgmq.detach_archive(${queueName})`;\n}\n\nexport async function dropQueue(tx: Prisma.TransactionClient, queueName: string): Promise<boolean> {\n    const result: { drop_queue: boolean }[] = await tx.$queryRaw`SELECT pgmq.drop_queue(${queueName})`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.drop_queue');\n    }\n    return firstResult.drop_queue;\n}\n\n// Utilities\n\nexport async function setVt(\n    tx: Prisma.TransactionClient, \n    queueName: string, \n    msgId: number, \n    vtOffset: number\n): Promise<MessageRecord> {\n    const result: MessageRecord[] = await tx.$queryRaw`SELECT * FROM pgmq.set_vt(${queueName}, ${msgId}::integer, ${vtOffset}::integer)`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.set_vt');\n    }\n    return firstResult;\n}\n\nexport async function listQueues(tx: Prisma.TransactionClient): Promise<QueueInfo[]> {\n    const result: QueueInfo[] = await tx.$queryRaw`SELECT * FROM pgmq.list_queues()`;\n    return result;\n}\n\nexport async function metrics(tx: Prisma.TransactionClient, queueName: string): Promise<QueueMetrics> {\n    const result: QueueMetrics[] = await tx.$queryRaw`SELECT * FROM pgmq.metrics(${queueName})`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.metrics');\n    }\n    return firstResult;\n}\n\nexport async function metricsAll(tx: Prisma.TransactionClient): Promise<QueueMetrics[]> {\n    const result: QueueMetrics[] = await tx.$queryRaw`SELECT * FROM pgmq.metrics_all()`;\n    return result;\n}"],"mappings":"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","names":[]}

package/dist/index.mjs

@@ -0,0 +1,136 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/pgmq.ts
+var pgmq_exports = {};
+__export(pgmq_exports, {
+  archive: () => archive,
+  archiveBatch: () => archiveBatch,
+  createPartitionedQueue: () => createPartitionedQueue,
+  createQueue: () => createQueue,
+  createUnloggedQueue: () => createUnloggedQueue,
+  deleteBatch: () => deleteBatch,
+  deleteMessage: () => deleteMessage,
+  detachArchive: () => detachArchive,
+  dropQueue: () => dropQueue,
+  listQueues: () => listQueues,
+  metrics: () => metrics,
+  metricsAll: () => metricsAll,
+  pop: () => pop,
+  purgeQueue: () => purgeQueue,
+  read: () => read,
+  readWithPoll: () => readWithPoll,
+  send: () => send,
+  sendBatch: () => sendBatch,
+  setVt: () => setVt
+});
+import { Prisma } from "@prisma/client/extension";
+var PrismaAny = Prisma;
+async function send(tx, queueName, msg, delay) {
+  const delayRepr = typeof delay === "number" ? PrismaAny.sql`${delay}::integer` : PrismaAny.sql`${delay}`;
+  const delaySql = delay ? PrismaAny.sql`, ${delayRepr}` : PrismaAny.sql``;
+  const result = await tx.$queryRaw`SELECT pgmq.send(${queueName}, ${msg}${delaySql})`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.send");
+  }
+  return firstResult.send;
+}
+async function sendBatch(tx, queueName, msgs, delay) {
+  const delayRepr = typeof delay === "number" ? PrismaAny.sql`${delay}::integer` : PrismaAny.sql`${delay}`;
+  const delaySql = delay ? PrismaAny.sql`, ${delayRepr}` : PrismaAny.sql``;
+  const result = await tx.$queryRaw`SELECT pgmq.send_batch(${queueName}, ${msgs}${delaySql})`;
+  return result.map((a) => a.send_batch);
+}
+function read(tx, queueName, vt, qty = 1, conditional = {}) {
+  return tx.$queryRaw`SELECT * FROM pgmq.read(${queueName}, ${vt}::integer, ${qty}::integer, ${conditional})`;
+}
+function readWithPoll(tx, queueName, vt, qty = 1, maxPollSeconds = 5, pollIntervalMs = 100, conditional = {}) {
+  return tx.$queryRaw`SELECT * FROM pgmq.read_with_poll(${queueName}, ${vt}::integer, ${qty}::integer, ${maxPollSeconds}::integer, ${pollIntervalMs}::integer, ${conditional})`;
+}
+function pop(tx, queueName) {
+  return tx.$queryRaw`SELECT * FROM pgmq.pop(${queueName})`;
+}
+async function deleteMessage(tx, queueName, msgId) {
+  const result = await tx.$queryRaw`SELECT pgmq.delete(${queueName}, ${msgId}::integer)`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.delete");
+  }
+  return firstResult.delete;
+}
+async function deleteBatch(tx, queueName, msgIds) {
+  const result = await tx.$queryRaw`SELECT pgmq.delete(${queueName}, ${msgIds}::integer[])`;
+  return result.map((a) => a.delete);
+}
+async function purgeQueue(tx, queueName) {
+  const result = await tx.$queryRaw`SELECT pgmq.purge_queue(${queueName})`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.purge_queue");
+  }
+  return firstResult.purge_queue;
+}
+async function archive(tx, queueName, msgId) {
+  const result = await tx.$queryRaw`SELECT pgmq.archive(${queueName}, ${msgId}::integer)`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.archive");
+  }
+  return firstResult.archive;
+}
+async function archiveBatch(tx, queueName, msgIds) {
+  const result = await tx.$queryRaw`SELECT pgmq.archive(${queueName}, ${msgIds}::integer[])`;
+  return result.map((a) => a.archive);
+}
+async function createQueue(tx, queueName) {
+  await tx.$executeRaw`SELECT pgmq.create(${queueName})`;
+}
+async function createPartitionedQueue(tx, queueName, partitionInterval = "10000", retentionInterval = "100000") {
+  await tx.$executeRaw`SELECT pgmq.create_partitioned(${queueName}, ${partitionInterval}, ${retentionInterval})`;
+}
+async function createUnloggedQueue(tx, queueName) {
+  await tx.$executeRaw`SELECT pgmq.create_unlogged(${queueName})`;
+}
+async function detachArchive(tx, queueName) {
+  await tx.$executeRaw`SELECT pgmq.detach_archive(${queueName})`;
+}
+async function dropQueue(tx, queueName) {
+  const result = await tx.$queryRaw`SELECT pgmq.drop_queue(${queueName})`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.drop_queue");
+  }
+  return firstResult.drop_queue;
+}
+async function setVt(tx, queueName, msgId, vtOffset) {
+  const result = await tx.$queryRaw`SELECT * FROM pgmq.set_vt(${queueName}, ${msgId}::integer, ${vtOffset}::integer)`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.set_vt");
+  }
+  return firstResult;
+}
+async function listQueues(tx) {
+  const result = await tx.$queryRaw`SELECT * FROM pgmq.list_queues()`;
+  return result;
+}
+async function metrics(tx, queueName) {
+  const result = await tx.$queryRaw`SELECT * FROM pgmq.metrics(${queueName})`;
+  const firstResult = result[0];
+  if (!firstResult) {
+    throw new Error("No result returned from pgmq.metrics");
+  }
+  return firstResult;
+}
+async function metricsAll(tx) {
+  const result = await tx.$queryRaw`SELECT * FROM pgmq.metrics_all()`;
+  return result;
+}
+export {
+  pgmq_exports as pgmq
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/pgmq.ts"],"sourcesContent":["import { Prisma } from '@prisma/client/extension';\n\nexport type Task = Record<string, unknown>;\n\n// Message record type based on PGMQ documentation\nexport interface MessageRecord {\n  msg_id: number;\n  read_ct: number;\n  enqueued_at: Date;\n  vt: Date;\n  message: Task;\n}\n\n// Queue metrics type\nexport interface QueueMetrics {\n  queue_name: string;\n  queue_length: number;\n  newest_msg_age_sec: number | null;\n  oldest_msg_age_sec: number | null;\n  total_messages: number;\n  scrape_time: Date;\n}\n\n// Queue info type\nexport interface QueueInfo {\n  queue_name: string;\n  created_at: Date;\n  is_partitioned: boolean;\n  is_unlogged: boolean;\n}\n\n// I expect that Prisma has `sql` defined\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst PrismaAny = Prisma as any;\n\nexport async function send(tx: Prisma.TransactionClient, queueName: string, msg: Task, delay?: number | Date): Promise<number> {\n    const delayRepr = typeof delay === 'number' ? PrismaAny.sql`${delay}::integer` : PrismaAny.sql`${delay}`;\n    const delaySql = delay ? PrismaAny.sql`, ${delayRepr}` : PrismaAny.sql``;\n    const result: { send: number }[] = await tx.$queryRaw`SELECT pgmq.send(${queueName}, ${msg}${delaySql})`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.send');\n    }\n    return firstResult.send;\n}\n\nexport async function sendBatch(tx: Prisma.TransactionClient, queueName: string, msgs: Task[], delay?: number | Date): Promise<number[]> {\n    const delayRepr = typeof delay === 'number' ? PrismaAny.sql`${delay}::integer` : PrismaAny.sql`${delay}`;\n    const delaySql = delay ? PrismaAny.sql`, ${delayRepr}` : PrismaAny.sql``;\n    const result: { send_batch: number }[] = await tx.$queryRaw`SELECT pgmq.send_batch(${queueName}, ${msgs}${delaySql})`;\n    return result.map(a => a.send_batch);\n}\n\n// Reading Messages\n\nexport function read(\n    tx: Prisma.TransactionClient, \n    queueName: string, \n    vt: number, \n    qty: number = 1, \n    conditional: Task = {}\n): Promise<MessageRecord[]> {\n    return tx.$queryRaw`SELECT * FROM pgmq.read(${queueName}, ${vt}::integer, ${qty}::integer, ${conditional})` as Promise<MessageRecord[]>;\n}\n\nexport function readWithPoll(\n    tx: Prisma.TransactionClient,\n    queueName: string,\n    vt: number,\n    qty: number = 1,\n    maxPollSeconds: number = 5,\n    pollIntervalMs: number = 100,\n    conditional: Task = {}\n): Promise<MessageRecord[]> {\n    return tx.$queryRaw`SELECT * FROM pgmq.read_with_poll(${queueName}, ${vt}::integer, ${qty}::integer, ${maxPollSeconds}::integer, ${pollIntervalMs}::integer, ${conditional})` as Promise<MessageRecord[]>;\n}\n\nexport function pop(tx: Prisma.TransactionClient, queueName: string): Promise<MessageRecord[]> {\n    return tx.$queryRaw`SELECT * FROM pgmq.pop(${queueName})` as Promise<MessageRecord[]>;\n}\n\n// Deleting/Archiving Messages\n\nexport async function deleteMessage(tx: Prisma.TransactionClient, queueName: string, msgId: number): Promise<boolean> {\n    const result: { delete: boolean }[] = await tx.$queryRaw`SELECT pgmq.delete(${queueName}, ${msgId}::integer)`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.delete');\n    }\n    return firstResult.delete;\n}\n\nexport async function deleteBatch(tx: Prisma.TransactionClient, queueName: string, msgIds: number[]): Promise<number[]> {\n    const result: { delete: number }[] = await tx.$queryRaw`SELECT pgmq.delete(${queueName}, ${msgIds}::integer[])`;\n    return result.map(a => a.delete);\n}\n\nexport async function purgeQueue(tx: Prisma.TransactionClient, queueName: string): Promise<number> {\n    const result: { purge_queue: number }[] = await tx.$queryRaw`SELECT pgmq.purge_queue(${queueName})`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.purge_queue');\n    }\n    return firstResult.purge_queue;\n}\n\nexport async function archive(tx: Prisma.TransactionClient, queueName: string, msgId: number): Promise<boolean> {\n    const result: { archive: boolean }[] = await tx.$queryRaw`SELECT pgmq.archive(${queueName}, ${msgId}::integer)`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.archive');\n    }\n    return firstResult.archive;\n}\n\nexport async function archiveBatch(tx: Prisma.TransactionClient, queueName: string, msgIds: number[]): Promise<number[]> {\n    const result: { archive: number }[] = await tx.$queryRaw`SELECT pgmq.archive(${queueName}, ${msgIds}::integer[])`;\n    return result.map(a => a.archive);\n}\n\n// Queue Management\n\nexport async function createQueue(tx: Prisma.TransactionClient, queueName: string): Promise<void> {\n    await tx.$executeRaw`SELECT pgmq.create(${queueName})`;\n}\n\nexport async function createPartitionedQueue(\n    tx: Prisma.TransactionClient, \n    queueName: string, \n    partitionInterval: string = '10000', \n    retentionInterval: string = '100000'\n): Promise<void> {\n    await tx.$executeRaw`SELECT pgmq.create_partitioned(${queueName}, ${partitionInterval}, ${retentionInterval})`;\n}\n\nexport async function createUnloggedQueue(tx: Prisma.TransactionClient, queueName: string): Promise<void> {\n    await tx.$executeRaw`SELECT pgmq.create_unlogged(${queueName})`;\n}\n\nexport async function detachArchive(tx: Prisma.TransactionClient, queueName: string): Promise<void> {\n    await tx.$executeRaw`SELECT pgmq.detach_archive(${queueName})`;\n}\n\nexport async function dropQueue(tx: Prisma.TransactionClient, queueName: string): Promise<boolean> {\n    const result: { drop_queue: boolean }[] = await tx.$queryRaw`SELECT pgmq.drop_queue(${queueName})`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.drop_queue');\n    }\n    return firstResult.drop_queue;\n}\n\n// Utilities\n\nexport async function setVt(\n    tx: Prisma.TransactionClient, \n    queueName: string, \n    msgId: number, \n    vtOffset: number\n): Promise<MessageRecord> {\n    const result: MessageRecord[] = await tx.$queryRaw`SELECT * FROM pgmq.set_vt(${queueName}, ${msgId}::integer, ${vtOffset}::integer)`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.set_vt');\n    }\n    return firstResult;\n}\n\nexport async function listQueues(tx: Prisma.TransactionClient): Promise<QueueInfo[]> {\n    const result: QueueInfo[] = await tx.$queryRaw`SELECT * FROM pgmq.list_queues()`;\n    return result;\n}\n\nexport async function metrics(tx: Prisma.TransactionClient, queueName: string): Promise<QueueMetrics> {\n    const result: QueueMetrics[] = await tx.$queryRaw`SELECT * FROM pgmq.metrics(${queueName})`;\n    const firstResult = result[0];\n    if (!firstResult) {\n        throw new Error('No result returned from pgmq.metrics');\n    }\n    return firstResult;\n}\n\nexport async function metricsAll(tx: Prisma.TransactionClient): Promise<QueueMetrics[]> {\n    const result: QueueMetrics[] = await tx.$queryRaw`SELECT * FROM pgmq.metrics_all()`;\n    return result;\n}"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "prisma-pgmq",
+  "version": "0.1.0",
+  "description": "A Prisma PGMQ implementation providing type-safe message queue operations",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "prisma",
+    "postgresql",
+    "message-queue",
+    "pgmq",
+    "queue",
+    "background-jobs",
+    "database",
+    "typescript"
+  ],
+  "author": "Dan Volkov <volkv.dan@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dvlkv/prisma-pgmq.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dvlkv/prisma-pgmq/issues"
+  },
+  "homepage": "https://github.com/dvlkv/prisma-pgmq#readme",
+  "peerDependencies": {
+    "@prisma/client": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.29.0",
+    "@prisma/client": "^5.0.0",
+    "@types/node": "^24.0.4",
+    "@typescript-eslint/eslint-plugin": "^8.35.0",
+    "@typescript-eslint/parser": "^8.35.0",
+    "eslint": "^9.29.0",
+    "prisma": "^5.0.0",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.35.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "build:watch": "tsup --watch",
+    "lint": "eslint --ext .ts,.tsx",
+    "lint:fix": "eslint --ext .ts,.tsx --fix",
+    "typecheck": "tsc --noEmit",
+    "dev": "pnpm build:watch",
+    "clean": "rimraf dist"
+  }
+}