@dismissible/nestjs-postgres-storage 0.0.2-canary.585db17.0

package/prisma/generated/prisma/models.ts

@@ -0,0 +1,12 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This is a barrel export file for all models and their related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+export type * from './models/DismissibleItem'
+export type * from './commonInputTypes'

package/prisma/migrations/20251219094936_init/migration.sql

@@ -0,0 +1,12 @@
+-- CreateTable
+CREATE TABLE "dismissible_items" (
+    "id" TEXT NOT NULL,
+    "user_id" TEXT NOT NULL,
+    "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "dismissed_at" TIMESTAMP(3),
+
+    CONSTRAINT "dismissible_items_pkey" PRIMARY KEY ("user_id","id")
+);
+
+-- CreateIndex
+CREATE INDEX "dismissible_items_user_id_idx" ON "dismissible_items"("user_id");

package/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "postgresql"

package/prisma/schema.prisma

@@ -0,0 +1,23 @@
+// Prisma schema for Dismissible PostgreSQL storage
+// https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client"
+  output   = "./generated/prisma"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model DismissibleItem {
+  id String
+  userId String @map("user_id")
+  createdAt DateTime @default(now()) @map("created_at")
+  dismissedAt DateTime? @map("dismissed_at")
+
+  @@id([userId, id])
+  @@index([userId])
+  @@map("dismissible_items")
+}
+

package/prisma.config.mjs

@@ -0,0 +1,33 @@
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { defineConfig } from 'prisma/config';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const prismaDir = join(__dirname, 'prisma');
+
+/**
+ * Prisma configuration for @dismissible/nestjs-postgres-storage.
+ *
+ * This config is used by the dismissible-prisma CLI and can be used directly
+ * by consumers who need to extend or customize the configuration.
+ *
+ * For consumers who want to use the base config in their own prisma.config.mjs:
+ *
+ * @example
+ * ```javascript
+ * import { defineConfig } from 'prisma/config';
+ * import { basePrismaConfig } from '@dismissible/nestjs-postgres-storage';
+ *
+ * export default defineConfig(basePrismaConfig);
+ * ```
+ */
+export default defineConfig({
+  schema: join(prismaDir, 'schema.prisma'),
+  migrations: {
+    path: join(prismaDir, 'migrations'),
+  },
+  datasource: {
+    url:
+      process.env.DATABASE_URL ?? process.env.DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING ?? '',
+  },
+});

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './postgres-storage.adapter';
+export * from './postgres-storage.config';
+export * from './postgres-storage.module';
+export * from './prisma.service';
+export * from './prisma-config';
+export * from './schema-path';

package/src/postgres-storage.adapter.spec.ts

@@ -0,0 +1,160 @@
+import { mock } from 'ts-jest-mocker';
+import { PostgresStorageAdapter } from './postgres-storage.adapter';
+import { PrismaService } from './prisma.service';
+import { IDismissibleLogger } from '@dismissible/nestjs-logger';
+import { DismissibleItemDto, DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
+
+describe('PostgresStorageAdapter', () => {
+  let adapter: PostgresStorageAdapter;
+  let mockPrismaService: PrismaService;
+  let mockLogger: jest.Mocked<IDismissibleLogger>;
+  let mockItemFactory: DismissibleItemFactory;
+  let mockDismissibleItem: {
+    findUnique: jest.Mock;
+    create: jest.Mock;
+    update: jest.Mock;
+  };
+
+  beforeEach(() => {
+    mockLogger = mock<IDismissibleLogger>({ failIfMockNotProvided: false });
+
+    mockItemFactory = new DismissibleItemFactory();
+
+    mockDismissibleItem = {
+      findUnique: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+    };
+
+    mockPrismaService = {
+      dismissibleItem: mockDismissibleItem,
+    } as unknown as PrismaService;
+
+    adapter = new PostgresStorageAdapter(mockPrismaService, mockLogger, mockItemFactory);
+  });
+
+  describe('get', () => {
+    it('should return null when item is not found', async () => {
+      mockDismissibleItem.findUnique.mockResolvedValue(null);
+
+      const result = await adapter.get('user-123', 'item-456');
+
+      expect(result).toBeNull();
+      expect(mockDismissibleItem.findUnique).toHaveBeenCalledWith({
+        where: {
+          userId_id: {
+            userId: 'user-123',
+            id: 'item-456',
+          },
+        },
+      });
+      expect(mockLogger.debug).toHaveBeenCalledWith('PostgreSQL storage miss', {
+        userId: 'user-123',
+        itemId: 'item-456',
+      });
+    });
+
+    it('should return the item when found', async () => {
+      const dbItem = {
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+        dismissedAt: null,
+      };
+      mockDismissibleItem.findUnique.mockResolvedValue(dbItem);
+
+      const result = await adapter.get('user-123', 'item-456');
+
+      expect(result).toEqual({
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+        dismissedAt: undefined,
+      });
+      expect(mockLogger.debug).toHaveBeenCalledWith('PostgreSQL storage hit', {
+        userId: 'user-123',
+        itemId: 'item-456',
+      });
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new item', async () => {
+      const item: DismissibleItemDto = {
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+      };
+      const dbItem = {
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+        dismissedAt: null,
+      };
+      mockDismissibleItem.create.mockResolvedValue(dbItem);
+
+      const result = await adapter.create(item);
+
+      expect(result).toEqual({
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+        dismissedAt: undefined,
+      });
+      expect(mockDismissibleItem.create).toHaveBeenCalledWith({
+        data: {
+          id: 'item-456',
+          userId: 'user-123',
+          createdAt: new Date('2024-01-15T10:30:00.000Z'),
+          dismissedAt: null,
+        },
+      });
+      expect(mockLogger.debug).toHaveBeenCalledWith('PostgreSQL storage create', {
+        userId: 'user-123',
+        itemId: 'item-456',
+      });
+    });
+  });
+
+  describe('update', () => {
+    it('should update an existing item', async () => {
+      const item: DismissibleItemDto = {
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+        dismissedAt: new Date('2024-01-15T12:00:00.000Z'),
+      };
+      const dbItem = {
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+        dismissedAt: new Date('2024-01-15T12:00:00.000Z'),
+      };
+      mockDismissibleItem.update.mockResolvedValue(dbItem);
+
+      const result = await adapter.update(item);
+
+      expect(result).toEqual({
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+        dismissedAt: new Date('2024-01-15T12:00:00.000Z'),
+      });
+      expect(mockDismissibleItem.update).toHaveBeenCalledWith({
+        where: {
+          userId_id: {
+            userId: 'user-123',
+            id: 'item-456',
+          },
+        },
+        data: {
+          dismissedAt: new Date('2024-01-15T12:00:00.000Z'),
+        },
+      });
+      expect(mockLogger.debug).toHaveBeenCalledWith('PostgreSQL storage update', {
+        userId: 'user-123',
+        itemId: 'item-456',
+      });
+    });
+  });
+});

package/src/postgres-storage.adapter.ts

@@ -0,0 +1,90 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { DISMISSIBLE_LOGGER, IDismissibleLogger } from '@dismissible/nestjs-logger';
+import { IDismissibleStorage } from '@dismissible/nestjs-storage';
+import { DismissibleItemDto, DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
+import { PrismaService } from './prisma.service';
+
+/**
+ * PostgreSQL storage adapter for dismissible items using Prisma.
+ * Implements IDismissibleStorage for persistent database storage.
+ */
+@Injectable()
+export class PostgresStorageAdapter implements IDismissibleStorage {
+  constructor(
+    private readonly prisma: PrismaService,
+    @Inject(DISMISSIBLE_LOGGER) private readonly logger: IDismissibleLogger,
+    private readonly itemFactory: DismissibleItemFactory,
+  ) {}
+
+  async get(userId: string, itemId: string): Promise<DismissibleItemDto | null> {
+    this.logger.debug('PostgreSQL storage get', { userId, itemId });
+
+    const item = await this.prisma.dismissibleItem.findUnique({
+      where: {
+        userId_id: {
+          userId,
+          id: itemId,
+        },
+      },
+    });
+
+    if (!item) {
+      this.logger.debug('PostgreSQL storage miss', { userId, itemId });
+      return null;
+    }
+
+    this.logger.debug('PostgreSQL storage hit', { userId, itemId });
+
+    return this.mapToDto(item);
+  }
+
+  async create(item: DismissibleItemDto): Promise<DismissibleItemDto> {
+    this.logger.debug('PostgreSQL storage create', { userId: item.userId, itemId: item.id });
+
+    const created = await this.prisma.dismissibleItem.create({
+      data: {
+        id: item.id,
+        userId: item.userId,
+        createdAt: item.createdAt,
+        dismissedAt: item.dismissedAt ?? null,
+      },
+    });
+
+    return this.mapToDto(created);
+  }
+
+  async update(item: DismissibleItemDto): Promise<DismissibleItemDto> {
+    this.logger.debug('PostgreSQL storage update', { userId: item.userId, itemId: item.id });
+
+    const updated = await this.prisma.dismissibleItem.update({
+      where: {
+        userId_id: {
+          userId: item.userId,
+          id: item.id,
+        },
+      },
+      data: {
+        dismissedAt: item.dismissedAt ?? null,
+      },
+    });
+
+    return this.mapToDto(updated);
+  }
+
+  /**
+   * Map a Prisma model to a DismissibleItemDto.
+   */
+  private mapToDto(item: {
+    id: string;
+    userId: string;
+    createdAt: Date;
+    dismissedAt: Date | null;
+  }): DismissibleItemDto {
+    return this.itemFactory.create({
+      id: item.id,
+      userId: item.userId,
+      createdAt: item.createdAt,
+      dismissedAt: item.dismissedAt ?? undefined,
+    });
+  }
+}

package/src/postgres-storage.config.ts

@@ -0,0 +1,11 @@
+import { IsString } from 'class-validator';
+
+/**
+ * Injection token for the PostgresStorage configuration.
+ */
+export const DISMISSIBLE_POSTGRES_STORAGE_CONFIG = Symbol('DISMISSIBLE_POSTGRES_STORAGE_CONFIG');
+
+export class PostgresStorageConfig {
+  @IsString()
+  public readonly connectionString!: string;
+}

package/src/postgres-storage.module.ts

@@ -0,0 +1,79 @@
+import { DynamicModule, Module, ModuleMetadata } from '@nestjs/common';
+import { DISMISSIBLE_STORAGE_ADAPTER } from '@dismissible/nestjs-storage';
+import { PostgresStorageAdapter } from './postgres-storage.adapter';
+import { PrismaService } from './prisma.service';
+import { DismissibleItemModule } from '@dismissible/nestjs-dismissible-item';
+import { DISMISSIBLE_LOGGER, IDismissibleLogger } from '@dismissible/nestjs-logger';
+import {
+  PostgresStorageConfig,
+  DISMISSIBLE_POSTGRES_STORAGE_CONFIG,
+} from './postgres-storage.config';
+
+export interface PostgresStorageModuleOptions {
+  connectionString: string;
+}
+
+export interface PostgresStorageModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+  inject?: any[];
+  useFactory: (
+    ...args: any[]
+  ) => PostgresStorageModuleOptions | Promise<PostgresStorageModuleOptions>;
+}
+
+@Module({})
+export class PostgresStorageModule {
+  static forRoot(options: PostgresStorageModuleOptions): DynamicModule {
+    return {
+      module: PostgresStorageModule,
+      imports: [DismissibleItemModule],
+      providers: [
+        {
+          provide: DISMISSIBLE_POSTGRES_STORAGE_CONFIG,
+          useValue: {
+            connectionString: options.connectionString,
+          },
+        },
+        {
+          provide: PrismaService,
+          useFactory(config: PostgresStorageConfig, logger: IDismissibleLogger) {
+            return new PrismaService(config, logger);
+          },
+          inject: [DISMISSIBLE_POSTGRES_STORAGE_CONFIG, DISMISSIBLE_LOGGER],
+        },
+        PostgresStorageAdapter,
+        {
+          provide: DISMISSIBLE_STORAGE_ADAPTER,
+          useExisting: PostgresStorageAdapter,
+        },
+      ],
+      exports: [DISMISSIBLE_STORAGE_ADAPTER, PrismaService],
+    };
+  }
+
+  static forRootAsync(options: PostgresStorageModuleAsyncOptions): DynamicModule {
+    return {
+      module: PostgresStorageModule,
+      imports: [...(options.imports || []), DismissibleItemModule],
+      providers: [
+        {
+          provide: DISMISSIBLE_POSTGRES_STORAGE_CONFIG,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        },
+        {
+          provide: PrismaService,
+          useFactory(config: PostgresStorageConfig, logger: IDismissibleLogger) {
+            return new PrismaService(config, logger);
+          },
+          inject: [DISMISSIBLE_POSTGRES_STORAGE_CONFIG, DISMISSIBLE_LOGGER],
+        },
+        PostgresStorageAdapter,
+        {
+          provide: DISMISSIBLE_STORAGE_ADAPTER,
+          useExisting: PostgresStorageAdapter,
+        },
+      ],
+      exports: [DISMISSIBLE_STORAGE_ADAPTER, PrismaService],
+    };
+  }
+}

package/src/prisma-config.spec.ts

@@ -0,0 +1,93 @@
+import { join } from 'path';
+
+describe('prisma-config', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    jest.resetModules();
+    process.env = { ...originalEnv };
+    delete process.env.DATABASE_URL;
+    delete process.env.DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING;
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  describe('createPrismaConfig', () => {
+    it('should return config with schema path relative to package', async () => {
+      const { createPrismaConfig } = await import('./prisma-config');
+      const config = createPrismaConfig();
+
+      expect(config.schema).toContain('schema.prisma');
+      expect(config.schema).toMatch(/postgres-storage.*prisma.*schema\.prisma$/);
+    });
+
+    it('should return config with migrations path relative to package', async () => {
+      const { createPrismaConfig } = await import('./prisma-config');
+      const config = createPrismaConfig();
+
+      expect(config.migrations.path).toContain('migrations');
+      expect(config.migrations.path).toMatch(/postgres-storage.*prisma.*migrations$/);
+    });
+
+    it('should use DATABASE_URL when set', async () => {
+      process.env.DATABASE_URL = 'postgres://test:test@localhost/test';
+
+      const { createPrismaConfig } = await import('./prisma-config');
+      const config = createPrismaConfig();
+
+      expect(config.datasource.url).toBe('postgres://test:test@localhost/test');
+    });
+
+    it('should fall back to DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING when DATABASE_URL is not set', async () => {
+      process.env.DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING =
+        'postgres://fallback:fallback@localhost/fallback';
+
+      const { createPrismaConfig } = await import('./prisma-config');
+      const config = createPrismaConfig();
+
+      expect(config.datasource.url).toBe('postgres://fallback:fallback@localhost/fallback');
+    });
+
+    it('should prefer DATABASE_URL over DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING', async () => {
+      process.env.DATABASE_URL = 'postgres://primary:primary@localhost/primary';
+      process.env.DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING =
+        'postgres://fallback:fallback@localhost/fallback';
+
+      const { createPrismaConfig } = await import('./prisma-config');
+      const config = createPrismaConfig();
+
+      expect(config.datasource.url).toBe('postgres://primary:primary@localhost/primary');
+    });
+
+    it('should return empty string when no database URL is set', async () => {
+      const { createPrismaConfig } = await import('./prisma-config');
+      const config = createPrismaConfig();
+
+      expect(config.datasource.url).toBe('');
+    });
+  });
+
+  describe('basePrismaConfig', () => {
+    it('should be exported and have the expected structure', async () => {
+      const { basePrismaConfig } = await import('./prisma-config');
+
+      expect(basePrismaConfig).toBeDefined();
+      expect(basePrismaConfig).toHaveProperty('schema');
+      expect(basePrismaConfig).toHaveProperty('migrations');
+      expect(basePrismaConfig).toHaveProperty('datasource');
+      expect(basePrismaConfig.migrations).toHaveProperty('path');
+      expect(basePrismaConfig.datasource).toHaveProperty('url');
+    });
+
+    it('should have schema and migrations paths pointing to the same prisma directory', async () => {
+      const { basePrismaConfig } = await import('./prisma-config');
+
+      const schemaDir = join(basePrismaConfig.schema, '..');
+      const migrationsDir = join(basePrismaConfig.migrations.path, '..');
+
+      expect(schemaDir).toBe(migrationsDir);
+    });
+  });
+});

package/src/prisma-config.ts

@@ -0,0 +1,63 @@
+import { join } from 'path';
+import { getPrismaSchemaPath } from './schema-path';
+
+/**
+ * Creates a Prisma configuration object with paths resolved relative to
+ * the @dismissible/nestjs-postgres-storage package.
+ *
+ * @returns Prisma configuration object suitable for use with defineConfig()
+ *
+ * @example
+ * ```typescript
+ * // prisma.config.mjs
+ * import { defineConfig } from 'prisma/config';
+ * import { basePrismaConfig } from '@dismissible/nestjs-postgres-storage';
+ *
+ * export default defineConfig(basePrismaConfig);
+ * ```
+ */
+export function createPrismaConfig() {
+  const prismaDir = join(getPrismaSchemaPath(), '..');
+  return {
+    schema: join(prismaDir, 'schema.prisma'),
+    migrations: {
+      path: join(prismaDir, 'migrations'),
+    },
+    datasource: {
+      url:
+        process.env.DATABASE_URL ??
+        process.env.DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING ??
+        '',
+    },
+  };
+}
+
+/**
+ * Base Prisma configuration for @dismissible/nestjs-postgres-storage.
+ *
+ * Use this with Prisma's defineConfig() to create your prisma.config.mjs:
+ *
+ * @example
+ * ```javascript
+ * // prisma.config.mjs
+ * import { defineConfig } from 'prisma/config';
+ * import { basePrismaConfig } from '@dismissible/nestjs-postgres-storage';
+ *
+ * export default defineConfig(basePrismaConfig);
+ * ```
+ *
+ * @example Extending the config
+ * ```javascript
+ * import { defineConfig } from 'prisma/config';
+ * import { basePrismaConfig } from '@dismissible/nestjs-postgres-storage';
+ *
+ * export default defineConfig({
+ *   ...basePrismaConfig,
+ *   migrations: {
+ *     ...basePrismaConfig.migrations,
+ *     seed: 'tsx prisma/seed.ts',
+ *   },
+ * });
+ * ```
+ */
+export const basePrismaConfig = createPrismaConfig();