@dismissible/nestjs-postgres-storage 0.0.2-canary.738340d.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/schema.prisma

@@ -0,0 +1,24 @@
+// 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")
+  metadata Json?
+
+  @@id([userId, id])
+  @@index([userId])
+  @@map("dismissible_items")
+}
+

package/project.json

@@ -0,0 +1,73 @@
+{
+  "name": "postgres-storage",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/postgres-storage/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/postgres-storage",
+        "main": "libs/postgres-storage/src/index.ts",
+        "tsConfig": "libs/postgres-storage/tsconfig.lib.json",
+        "assets": [
+          "libs/postgres-storage/package.json",
+          "libs/postgres-storage/README.md",
+          {
+            "input": "libs/postgres-storage/prisma",
+            "glob": "**/*",
+            "output": "prisma"
+          },
+          {
+            "input": "libs/postgres-storage/bin",
+            "glob": "**/*",
+            "output": "bin"
+          }
+        ],
+        "generatePackageJson": true
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["libs/postgres-storage/**/*.ts"]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/libs/postgres-storage"],
+      "options": {
+        "jestConfig": "libs/postgres-storage/jest.config.ts",
+        "passWithNoTests": true
+      }
+    },
+    "prisma:generate": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "npx prisma generate --schema=libs/postgres-storage/prisma/schema.prisma"
+      }
+    },
+    "prisma:migrate": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "npx prisma migrate dev --schema=libs/postgres-storage/prisma/schema.prisma"
+      }
+    },
+    "prisma:push": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "npx prisma db push --schema=libs/postgres-storage/prisma/schema.prisma"
+      }
+    },
+    "npm-publish": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "npm publish --access public",
+        "cwd": "dist/libs/postgres-storage"
+      }
+    }
+  }
+}

package/src/index.ts

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

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

@@ -0,0 +1,248 @@
+import { mock } from 'ts-jest-mocker';
+import { Prisma } from '../prisma/generated/prisma/client';
+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 });
+
+    // Use real DismissibleItemFactory since it's a simple factory
+    mockItemFactory = new DismissibleItemFactory();
+
+    // Create a mock for the dismissibleItem delegate
+    mockDismissibleItem = {
+      findUnique: jest.fn(),
+      create: jest.fn(),
+      update: jest.fn(),
+    };
+
+    // Create a partial mock of PrismaService with the dismissibleItem property
+    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,
+        metadata: 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,
+        metadata: undefined,
+      });
+      expect(mockLogger.debug).toHaveBeenCalledWith('PostgreSQL storage hit', {
+        userId: 'user-123',
+        itemId: 'item-456',
+      });
+    });
+
+    it('should return item with metadata when present', async () => {
+      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'),
+        metadata: { version: 2, category: 'promotional' },
+      };
+      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: new Date('2024-01-15T12:00:00.000Z'),
+        metadata: { version: 2, category: 'promotional' },
+      });
+    });
+  });
+
+  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,
+        metadata: 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,
+        metadata: undefined,
+      });
+      expect(mockDismissibleItem.create).toHaveBeenCalledWith({
+        data: {
+          id: 'item-456',
+          userId: 'user-123',
+          createdAt: new Date('2024-01-15T10:30:00.000Z'),
+          dismissedAt: null,
+          metadata: Prisma.JsonNull,
+        },
+      });
+      expect(mockLogger.debug).toHaveBeenCalledWith('PostgreSQL storage create', {
+        userId: 'user-123',
+        itemId: 'item-456',
+      });
+    });
+
+    it('should create an item with metadata', async () => {
+      const item: DismissibleItemDto = {
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+        metadata: { version: 2 },
+      };
+      const dbItem = {
+        id: 'item-456',
+        userId: 'user-123',
+        createdAt: new Date('2024-01-15T10:30:00.000Z'),
+        dismissedAt: null,
+        metadata: { version: 2 },
+      };
+      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,
+        metadata: { version: 2 },
+      });
+    });
+  });
+
+  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'),
+        metadata: null,
+      };
+      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'),
+        metadata: undefined,
+      });
+      expect(mockDismissibleItem.update).toHaveBeenCalledWith({
+        where: {
+          userId_id: {
+            userId: 'user-123',
+            id: 'item-456',
+          },
+        },
+        data: {
+          dismissedAt: new Date('2024-01-15T12:00:00.000Z'),
+          metadata: Prisma.JsonNull,
+        },
+      });
+      expect(mockLogger.debug).toHaveBeenCalledWith('PostgreSQL storage update', {
+        userId: 'user-123',
+        itemId: 'item-456',
+      });
+    });
+
+    it('should update an item with metadata', 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'),
+        metadata: { version: 3, updated: true },
+      };
+      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'),
+        metadata: { version: 3, updated: true },
+      };
+      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'),
+        metadata: { version: 3, updated: true },
+      });
+    });
+  });
+});

package/src/postgres-storage.adapter.ts

@@ -0,0 +1,101 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { DISMISSIBLE_LOGGER, IDismissibleLogger } from '@dismissible/nestjs-logger';
+import { IDismissibleStorage } from '@dismissible/nestjs-storage';
+import {
+  BaseMetadata,
+  DismissibleItemDto,
+  DismissibleItemFactory,
+} from '@dismissible/nestjs-dismissible-item';
+import { Prisma } from '../prisma/generated/prisma/client';
+import { PrismaService } from './prisma.service';
+
+/**
+ * PostgreSQL storage adapter for dismissible items using Prisma.
+ * Implements IDismissibleStorage for persistent database storage.
+ */
+@Injectable()
+export class PostgresStorageAdapter<
+  TMetadata extends BaseMetadata = BaseMetadata,
+> implements IDismissibleStorage<TMetadata> {
+  constructor(
+    private readonly prisma: PrismaService,
+    @Inject(DISMISSIBLE_LOGGER) private readonly logger: IDismissibleLogger,
+    private readonly itemFactory: DismissibleItemFactory,
+  ) {}
+
+  async get(userId: string, itemId: string): Promise<DismissibleItemDto<TMetadata> | 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<TMetadata>): Promise<DismissibleItemDto<TMetadata>> {
+    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,
+        metadata: (item.metadata as Prisma.InputJsonValue) ?? Prisma.JsonNull,
+      },
+    });
+
+    return this.mapToDto(created);
+  }
+
+  async update(item: DismissibleItemDto<TMetadata>): Promise<DismissibleItemDto<TMetadata>> {
+    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,
+        metadata: (item.metadata as Prisma.InputJsonValue) ?? Prisma.JsonNull,
+      },
+    });
+
+    return this.mapToDto(updated);
+  }
+
+  /**
+   * Map a Prisma model to a DismissibleItemDto.
+   */
+  private mapToDto(item: {
+    id: string;
+    userId: string;
+    createdAt: Date;
+    dismissedAt: Date | null;
+    metadata: unknown;
+  }): DismissibleItemDto<TMetadata> {
+    return this.itemFactory.create({
+      id: item.id,
+      userId: item.userId,
+      createdAt: item.createdAt,
+      dismissedAt: item.dismissedAt ?? undefined,
+      metadata: (item.metadata as TMetadata) ?? 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],
+    };
+  }
+
+  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],
+    };
+  }
+}

package/src/prisma.service.ts

@@ -0,0 +1,34 @@
+import { Injectable, OnModuleInit, OnModuleDestroy, Inject } from '@nestjs/common';
+import { PrismaClient } from '../prisma/generated/prisma/client';
+import { PrismaPg } from '@prisma/adapter-pg';
+import { Pool } from 'pg';
+import { DISMISSIBLE_LOGGER, IDismissibleLogger } from '@dismissible/nestjs-logger';
+import { PostgresStorageConfig } from './postgres-storage.config';
+
+/**
+ * PrismaService wraps the PrismaClient and handles connection lifecycle.
+ * It connects to the database on module initialization and disconnects on shutdown.
+ */
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
+  constructor(
+    private readonly config: PostgresStorageConfig,
+    @Inject(DISMISSIBLE_LOGGER) private readonly logger: IDismissibleLogger,
+  ) {
+    const pool = new Pool({ connectionString: config.connectionString });
+    const adapter = new PrismaPg(pool);
+    super({ adapter });
+  }
+
+  async onModuleInit(): Promise<void> {
+    this.logger.debug('Connecting to PostgreSQL database');
+    await this.$connect();
+    this.logger.debug('Connected to PostgreSQL database');
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    this.logger.debug('Disconnecting from PostgreSQL database');
+    await this.$disconnect();
+    this.logger.debug('Disconnected from PostgreSQL database');
+  }
+}

package/src/schema-path.ts

@@ -0,0 +1,17 @@
+import { join } from 'path';
+
+/**
+ * Returns the absolute path to the Prisma schema file.
+ * Useful for consumers who need to run prisma commands programmatically.
+ *
+ * @example
+ * ```typescript
+ * import { getSchemaPath } from '@dismissible/nestjs-postgres-storage';
+ * import { execSync } from 'child_process';
+ *
+ * execSync(`npx prisma generate --schema=${getSchemaPath()}`);
+ * ```
+ */
+export function getSchemaPath(): string {
+  return join(__dirname, '..', 'prisma', 'schema.prisma');
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ],
+  "compilerOptions": {
+    "esModuleInterop": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "module": "commonjs",
+    "types": ["node"],
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2021"
+  },
+  "exclude": ["node_modules", "**/*.spec.ts", "**/*.test.ts"],
+  "include": ["src/**/*.ts"]
+}