@lti-tool/postgresql 1.0.0 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @lti-tool/postgresql
 
+## 1.0.1
+
+### Patch Changes
+
+- 834b75e: Add README file
+
 ## 1.0.0
 
 ### Major Changes

package/README.md

@@ -0,0 +1,294 @@
+# @lti-tool/postgresql
+
+<p align="center">Production-ready PostgreSQL storage adapter for LTI 1.3. Includes caching and optimized for AWS Lambda.</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@lti-tool/postgresql"><img alt="npm" src="https://img.shields.io/npm/v/%40lti-tool%2Fpostgresql" /></a>
+</p>
+
+## Installation
+
+```bash
+npm install @lti-tool/postgresql
+```
+
+## Quick Start
+
+```typescript
+import { PostgresStorage } from '@lti-tool/postgresql';
+import { LTITool } from '@lti-tool/core';
+
+const storage = new PostgresStorage({
+  connectionUrl: process.env.DATABASE_URL!,
+});
+
+const ltiTool = new LTITool({
+  storage,
+  // ... other config
+});
+```
+
+## Features
+
+- **Production Ready** - Handles high-scale LTI deployments
+- **Built-in Caching** - LRU cache for frequently accessed data
+- **Type-safe** - Uses Drizzle ORM for database operations
+- **Transaction Support** - Handles data integrity on deletes
+- **Tuned Connection Pool Defaults** - Connection pool defaults based on hosting environment
+
+## API Reference
+
+- [API Reference](https://docs.lti-tool.dev/modules/_lti-tool_postgresql.html) - Complete API documentation
+
+## Configuration
+
+### Using Drizzle Kit Push (Recommended for Development)
+
+```bash
+# Set your DATABASE_URL
+export DATABASE_URL="postgresql://user:password@host:port/database"
+
+# Push schema to database
+npx drizzle-kit push
+```
+
+### Using Migrations (Recommended for Production)
+
+```bash
+# Apply migrations
+npx drizzle-kit migrate
+```
+
+### PostgresStorageConfig
+
+- **connectionUrl** (required): PostgreSQL connection URL
+  Format: `postgresql://user:password@host:port/database`
+- **poolOptions** (optional): postgres.js connection options
+  - `max`: Max connections (auto: 1 for serverless, 10 for servers)
+  - `idleTimeout`: Idle timeout in seconds before connection is closed (default: 20)
+- **nonceExpirationSeconds** (optional): Nonce TTL in seconds (default: 600)
+
+- **logger** (optional): Pino logger for debugging
+
+## Database Schema
+
+The adapter uses these tables:
+
+- **clients**: LTI platform clients
+  Unique constraint: `(iss, clientId)`
+- **deployments**: Platform deployments (many-to-one with clients)
+  Unique constraint: `(clientId, deploymentId)`
+- **sessions**: LTI sessions with expiration
+  Indexed: `expiresAt`
+- **nonces**: One-time use nonces
+  Primary key: `nonce`
+  Indexed: `expiresAt`
+- **registration_sessions**: Dynamic registration sessions
+  Indexed: `expiresAt`
+
+All tables use native PostgreSQL UUIDs for primary keys and include indexes for performance.
+
+### clients
+
+| Column     | Type         | Constraints           | Description                    |
+| ---------- | ------------ | --------------------- | ------------------------------ |
+| `id`       | UUID         | PRIMARY KEY, NOT NULL | Internal UUID for the client   |
+| `name`     | VARCHAR(255) | NOT NULL              | Human-readable platform name   |
+| `iss`      | VARCHAR(255) | NOT NULL              | Issuer URL (LMS platform)      |
+| `clientId` | VARCHAR(255) | NOT NULL              | LMS-provided client identifier |
+| `authUrl`  | TEXT         | NOT NULL              | OAuth2 authorization endpoint  |
+| `tokenUrl` | TEXT         | NOT NULL              | OAuth2 token endpoint          |
+| `jwksUrl`  | TEXT         | NOT NULL              | JWKS endpoint for public keys  |
+
+**Indexes:**
+
+- `issuer_client_idx`: `(clientId, iss)` - For fast client lookups
+- `iss_client_id_unique`: `(iss, clientId)` - Unique constraint preventing duplicate clients
+
+### deployments
+
+| Column         | Type         | Constraints           | Description                        |
+| -------------- | ------------ | --------------------- | ---------------------------------- |
+| `id`           | UUID         | PRIMARY KEY, NOT NULL | Internal UUID for the deployment   |
+| `deploymentId` | VARCHAR(255) | NOT NULL              | LMS-provided deployment identifier |
+| `name`         | VARCHAR(255) | NULL                  | Optional human-readable name       |
+| `description`  | TEXT         | NULL                  | Optional description               |
+| `clientId`     | UUID         | NOT NULL, FOREIGN KEY | References `clients.id`            |
+
+**Indexes:**
+
+- `deployment_id_idx`: `(deploymentId)` - For fast deployment lookups
+- `client_deployment_unique`: `(clientId, deploymentId)` - Unique constraint per client
+
+### sessions
+
+| Column      | Type                     | Constraints           | Description                  |
+| ----------- | ------------------------ | --------------------- | ---------------------------- |
+| `id`        | UUID                     | PRIMARY KEY, NOT NULL | Session UUID                 |
+| `data`      | JSONB                    | NOT NULL              | Complete LTI session data    |
+| `expiresAt` | TIMESTAMP WITH TIME ZONE | NOT NULL              | Session expiration timestamp |
+
+**Indexes:**
+
+- `sessions_expires_at_idx`: `(expiresAt)` - For cleanup queries and expiration checks
+
+### nonces
+
+| Column      | Type                     | Constraints           | Description                |
+| ----------- | ------------------------ | --------------------- | -------------------------- |
+| `nonce`     | VARCHAR(255)             | PRIMARY KEY, NOT NULL | One-time use nonce value   |
+| `expiresAt` | TIMESTAMP WITH TIME ZONE | NOT NULL              | Nonce expiration timestamp |
+
+### registration_sessions
+
+| Column      | Type                     | Constraints           | Description                       |
+| ----------- | ------------------------ | --------------------- | --------------------------------- |
+| `id`        | UUID                     | PRIMARY KEY, NOT NULL | Registration session UUID         |
+| `data`      | JSONB                    | NOT NULL              | Dynamic registration session data |
+| `expiresAt` | TIMESTAMP WITH TIME ZONE | NOT NULL              | Session expiration timestamp      |
+
+**Indexes:**
+
+- `reg_sessions_expires_at_idx`: `(expiresAt)` - For cleanup queries and expiration checks
+
+## Connection Pool Behavior
+
+The adapter automatically detects your deployment environment:
+
+- **Serverless** (Lambda, Cloud Functions, Vercel, Netlify): `max: 1`
+- **Traditional Servers** (EC2, containers, VMs): `max: 10`
+
+### How Connection Pooling Works
+
+- Starts with **0 connections**
+- Creates connections **on-demand** when queries execute
+- Reuses idle connections before creating new ones
+- Increases to `max` based on concurrent load
+- Closes idle connections after `idleTimeout` seconds (default: 20)
+
+### Manual Override
+
+```typescript
+const storage = new PostgresStorage({
+  connectionUrl: process.env.DATABASE_URL!,
+  poolOptions: {
+    max: 20, // Override auto-detection
+    idleTimeout: 30, // Keep connections alive longer
+  },
+});
+```
+
+## Deployment Patterns
+
+### Long-Running Servers
+
+```typescript
+import { PostgresStorage } from '@lti-tool/postgresql';
+
+export const storage = new PostgresStorage({
+  connectionUrl: process.env.DATABASE_URL!,
+});
+
+// Optional: Graceful shutdown
+const shutdown = async () => {
+  await storage.close();
+  process.exit(0);
+};
+
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+```
+
+**Connection Limits:**
+
+- Low traffic: `5-10 connections`
+- Medium traffic: `10-20 connections`
+- High traffic: `20-50 connections`
+- Never exceed PostgreSQL `max_connections`
+
+### AWS Lambda / Serverless
+
+```typescript
+import { PostgresStorage } from '@lti-tool/postgresql';
+
+let storage: PostgresStorage | undefined;
+
+export const handler = async (event) => {
+  if (!storage) {
+    storage = new PostgresStorage({
+      connectionUrl: process.env.DATABASE_URL!,
+      // Auto-detects Lambda, uses max: 1
+    });
+  }
+
+  // Use storage...
+};
+```
+
+**Why `max: 1`?**
+Lambda containers handle one request at a time. The connection is reused across warm invocations.
+
+**Do I need `close()`?**
+No! Lambda freezes containers efficiently. Calling `close()` destroys reusable connections.
+
+### Edge Runtime Warning
+
+⚠️ **Not supported!**
+
+## Periodic Cleanup
+
+The adapter requires periodic cleanup of expired nonces and sessions.
+
+```typescript
+// Example - AWS Lambda with EventBridge (every 30 minutes)
+export const handler = async () => {
+  const result = await storage.cleanup();
+  console.log('Cleanup:', result);
+  // { noncesDeleted: 42, sessionsDeleted: 15, registrationSessionsDeleted: 3 }
+};
+```
+
+## Development & Testing
+
+### Start Local PostgreSQL
+
+```bash
+# Using Docker
+docker-compose up -d
+
+# Using Podman
+podman-compose up -d
+
+# Or Podman directly
+podman run -d \
+  --name lti-postgres \
+  -e POSTGRES_PASSWORD=postgres \
+  -e POSTGRES_DB=lti_test \
+  -e POSTGRES_USER=lti_user \
+  -p 5432:5432 \
+  postgres:16
+```
+
+### Run Tests
+
+```bash
+DATABASE_URL="postgresql://lti_user:postgres@localhost:5432/lti_test" npm test
+```
+
+**Important:** Always close the pool after tests:
+
+```typescript
+afterAll(async () => {
+  await storage.close();
+});
+```
+
+## Environment Detection
+
+Auto-detects serverless by checking:
+
+- AWS Lambda: `AWS_LAMBDA_FUNCTION_NAME`, `AWS_EXECUTION_ENV`
+- Google Cloud: `FUNCTION_NAME`, `K_SERVICE`
+- Azure: `FUNCTIONS_WORKER_RUNTIME`
+- Vercel: `VERCEL`
+- Netlify: `NETLIFY`

package/dist/cacheConfig.d.ts

@@ -0,0 +1,11 @@
+import type { LTILaunchConfig, LTISession } from '@lti-tool/core';
+import { LRUCache } from 'lru-cache';
+export declare const LAUNCH_CONFIG_CACHE: LRUCache<string, LTILaunchConfig | typeof undefinedLaunchConfigValue, unknown>;
+export declare const SESSION_CACHE: LRUCache<string, LTISession | typeof undefinedSessionValue, unknown>;
+export declare const SESSION_TTL: number;
+export declare const NONCE_TTL: number;
+export declare const undefinedLaunchConfigValue: unique symbol;
+export type undefinedLaunchConfig = typeof undefinedLaunchConfigValue;
+export declare const undefinedSessionValue: unique symbol;
+export type undefinedSession = typeof undefinedSessionValue;
+//# sourceMappingURL=cacheConfig.d.ts.map

package/dist/cacheConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheConfig.d.ts","sourceRoot":"","sources":["../src/cacheConfig.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,eAAO,MAAM,mBAAmB,gFAM9B,CAAC;AACH,eAAO,MAAM,aAAa,sEAGxB,CAAC;AAEH,eAAO,MAAM,WAAW,QAAe,CAAC;AACxC,eAAO,MAAM,SAAS,QAAU,CAAC;AAGjC,eAAO,MAAM,0BAA0B,eAAkC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,OAAO,0BAA0B,CAAC;AACtE,eAAO,MAAM,qBAAqB,eAA6B,CAAC;AAChE,MAAM,MAAM,gBAAgB,GAAG,OAAO,qBAAqB,CAAC"}

package/dist/cacheConfig.js

@@ -0,0 +1,14 @@
+import { LRUCache } from 'lru-cache';
+export const LAUNCH_CONFIG_CACHE = new LRUCache({
+    max: 1000,
+    ttl: 1000 * 60 * 15, // 15 minutes
+});
+export const SESSION_CACHE = new LRUCache({
+    max: 1000,
+    ttl: 1000 * 60 * 5, // 5 minutes (shorter than clients)
+});
+export const SESSION_TTL = 60 * 60 * 24; // session ttl is one day
+export const NONCE_TTL = 60 * 15; // nonce ttl is fifteen minutes
+// we need an undefined value to handle cache misses and cache them
+export const undefinedLaunchConfigValue = Symbol('undefinedLaunchConfig');
+export const undefinedSessionValue = Symbol('undefinedSession');

package/dist/db/schema/clients.schema.d.ts

@@ -0,0 +1,133 @@
+export declare const clientsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "clients";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "clients";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "clients";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        iss: import("drizzle-orm/pg-core").PgColumn<{
+            name: "iss";
+            tableName: "clients";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        clientId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "client_id";
+            tableName: "clients";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        authUrl: import("drizzle-orm/pg-core").PgColumn<{
+            name: "auth_url";
+            tableName: "clients";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tokenUrl: import("drizzle-orm/pg-core").PgColumn<{
+            name: "token_url";
+            tableName: "clients";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        jwksUrl: import("drizzle-orm/pg-core").PgColumn<{
+            name: "jwks_url";
+            tableName: "clients";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=clients.schema.d.ts.map

package/dist/db/schema/clients.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clients.schema.d.ts","sourceRoot":"","sources":["../../../src/db/schema/clients.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAexB,CAAC"}

package/dist/db/schema/clients.schema.js

@@ -0,0 +1,13 @@
+import { index, pgTable, text, uniqueIndex, uuid, varchar } from 'drizzle-orm/pg-core';
+export const clientsTable = pgTable('clients', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    name: varchar('name', { length: 255 }).notNull(),
+    iss: varchar('iss', { length: 255 }).notNull(),
+    clientId: varchar('client_id', { length: 255 }).notNull(),
+    authUrl: text('auth_url').notNull(),
+    tokenUrl: text('token_url').notNull(),
+    jwksUrl: text('jwks_url').notNull(),
+}, (table) => [
+    index('issuer_client_idx').on(table.clientId, table.iss),
+    uniqueIndex('iss_client_id_unique').on(table.iss, table.clientId),
+]);

package/dist/db/schema/deployments.schema.d.ts

@@ -0,0 +1,97 @@
+export declare const deploymentsTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "deployments";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "deployments";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deploymentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "deployment_id";
+            tableName: "deployments";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "deployments";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "deployments";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        clientId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "client_id";
+            tableName: "deployments";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=deployments.schema.d.ts.map

package/dist/db/schema/deployments.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deployments.schema.d.ts","sourceRoot":"","sources":["../../../src/db/schema/deployments.schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe5B,CAAC"}

package/dist/db/schema/deployments.schema.js

@@ -0,0 +1,14 @@
+import { index, pgTable, text, uniqueIndex, uuid, varchar } from 'drizzle-orm/pg-core';
+import { clientsTable } from './clients.schema';
+export const deploymentsTable = pgTable('deployments', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    deploymentId: varchar('deployment_id', { length: 255 }).notNull(),
+    name: varchar('name', { length: 255 }),
+    description: text('description'),
+    clientId: uuid('client_id')
+        .notNull()
+        .references(() => clientsTable.id),
+}, (table) => [
+    index('deployment_id_idx').on(table.deploymentId),
+    uniqueIndex('client_deployment_unique').on(table.clientId, table.deploymentId),
+]);

package/dist/db/schema/index.d.ts

@@ -0,0 +1,6 @@
+export * from './clients.schema';
+export * from './deployments.schema';
+export * from './nonces.schema';
+export * from './registrationSessions.schema';
+export * from './sessions.schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/db/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/db/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mBAAmB,CAAC"}

package/dist/db/schema/index.js

@@ -0,0 +1,5 @@
+export * from './clients.schema';
+export * from './deployments.schema';
+export * from './nonces.schema';
+export * from './registrationSessions.schema';
+export * from './sessions.schema';

package/dist/db/schema/nonces.schema.d.ts

@@ -0,0 +1,44 @@
+export declare const noncesTable: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "nonces";
+    schema: undefined;
+    columns: {
+        nonce: import("drizzle-orm/pg-core").PgColumn<{
+            name: "nonce";
+            tableName: "nonces";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "nonces";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+//# sourceMappingURL=nonces.schema.d.ts.map

package/dist/db/schema/nonces.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nonces.schema.d.ts","sourceRoot":"","sources":["../../../src/db/schema/nonces.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGtB,CAAC"}

package/dist/db/schema/nonces.schema.js

@@ -0,0 +1,5 @@
+import { pgTable, timestamp, varchar } from 'drizzle-orm/pg-core';
+export const noncesTable = pgTable('nonces', {
+    nonce: varchar('nonce', { length: 255 }).primaryKey(),
+    expiresAt: timestamp('expires_at', { withTimezone: true }).notNull(),
+});