@dismissible/nestjs-postgres-storage 0.0.2-canary.8976e84.0 → 0.0.2-canary.b0d8bfe.0

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

@@ -15,7 +15,6 @@ model DismissibleItem {
   userId String @map("user_id")
   createdAt DateTime @default(now()) @map("created_at")
   dismissedAt DateTime? @map("dismissed_at")
-  metadata Json?
 
   @@id([userId, id])
   @@index([userId])

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

@@ -2,4 +2,5 @@ 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

@@ -1,5 +1,4 @@
 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';
@@ -19,17 +18,14 @@ describe('PostgresStorageAdapter', () => {
   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;
@@ -64,7 +60,6 @@ describe('PostgresStorageAdapter', () => {
         userId: 'user-123',
         createdAt: new Date('2024-01-15T10:30:00.000Z'),
         dismissedAt: null,
-        metadata: null,
       };
       mockDismissibleItem.findUnique.mockResolvedValue(dbItem);
 
@@ -75,34 +70,12 @@ describe('PostgresStorageAdapter', () => {
         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', () => {
@@ -117,7 +90,6 @@ describe('PostgresStorageAdapter', () => {
         userId: 'user-123',
         createdAt: new Date('2024-01-15T10:30:00.000Z'),
         dismissedAt: null,
-        metadata: null,
       };
       mockDismissibleItem.create.mockResolvedValue(dbItem);
 
@@ -128,7 +100,6 @@ describe('PostgresStorageAdapter', () => {
         userId: 'user-123',
         createdAt: new Date('2024-01-15T10:30:00.000Z'),
         dismissedAt: undefined,
-        metadata: undefined,
       });
       expect(mockDismissibleItem.create).toHaveBeenCalledWith({
         data: {
@@ -136,7 +107,6 @@ describe('PostgresStorageAdapter', () => {
           userId: 'user-123',
           createdAt: new Date('2024-01-15T10:30:00.000Z'),
           dismissedAt: null,
-          metadata: Prisma.JsonNull,
         },
       });
       expect(mockLogger.debug).toHaveBeenCalledWith('PostgreSQL storage create', {
@@ -144,33 +114,6 @@ describe('PostgresStorageAdapter', () => {
         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', () => {
@@ -186,7 +129,6 @@ describe('PostgresStorageAdapter', () => {
         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);
 
@@ -197,7 +139,6 @@ describe('PostgresStorageAdapter', () => {
         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: {
@@ -208,7 +149,6 @@ describe('PostgresStorageAdapter', () => {
         },
         data: {
           dismissedAt: new Date('2024-01-15T12:00:00.000Z'),
-          metadata: Prisma.JsonNull,
         },
       });
       expect(mockLogger.debug).toHaveBeenCalledWith('PostgreSQL storage update', {
@@ -216,33 +156,5 @@ describe('PostgresStorageAdapter', () => {
         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

@@ -1,12 +1,7 @@
 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 { DismissibleItemDto, DismissibleItemFactory } from '@dismissible/nestjs-dismissible-item';
 import { PrismaService } from './prisma.service';
 
 /**
@@ -14,16 +9,14 @@ import { PrismaService } from './prisma.service';
  * Implements IDismissibleStorage for persistent database storage.
  */
 @Injectable()
-export class PostgresStorageAdapter<
-  TMetadata extends BaseMetadata = BaseMetadata,
-> implements IDismissibleStorage<TMetadata> {
+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<TMetadata> | null> {
+  async get(userId: string, itemId: string): Promise<DismissibleItemDto | null> {
     this.logger.debug('PostgreSQL storage get', { userId, itemId });
 
     const item = await this.prisma.dismissibleItem.findUnique({
@@ -45,7 +38,7 @@ export class PostgresStorageAdapter<
     return this.mapToDto(item);
   }
 
-  async create(item: DismissibleItemDto<TMetadata>): Promise<DismissibleItemDto<TMetadata>> {
+  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({
@@ -54,14 +47,13 @@ export class PostgresStorageAdapter<
         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>> {
+  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({
@@ -73,7 +65,6 @@ export class PostgresStorageAdapter<
       },
       data: {
         dismissedAt: item.dismissedAt ?? null,
-        metadata: (item.metadata as Prisma.InputJsonValue) ?? Prisma.JsonNull,
       },
     });
 
@@ -88,14 +79,12 @@ export class PostgresStorageAdapter<
     userId: string;
     createdAt: Date;
     dismissedAt: Date | null;
-    metadata: unknown;
-  }): DismissibleItemDto<TMetadata> {
+  }): DismissibleItemDto {
     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.module.ts

@@ -46,7 +46,7 @@ export class PostgresStorageModule {
           useExisting: PostgresStorageAdapter,
         },
       ],
-      exports: [DISMISSIBLE_STORAGE_ADAPTER],
+      exports: [DISMISSIBLE_STORAGE_ADAPTER, PrismaService],
     };
   }
 
@@ -73,7 +73,7 @@ export class PostgresStorageModule {
           useExisting: PostgresStorageAdapter,
         },
       ],
-      exports: [DISMISSIBLE_STORAGE_ADAPTER],
+      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();

package/src/prisma.service.spec.ts

@@ -0,0 +1,125 @@
+import { mock } from 'ts-jest-mocker';
+import { PrismaService } from './prisma.service';
+import { PostgresStorageConfig } from './postgres-storage.config';
+import { IDismissibleLogger } from '@dismissible/nestjs-logger';
+
+const mockPoolInstance = {};
+const mockPrismaPgInstance = {};
+
+jest.mock('pg', () => ({
+  Pool: jest.fn().mockImplementation(() => mockPoolInstance),
+}));
+
+jest.mock('@prisma/adapter-pg', () => ({
+  PrismaPg: jest.fn().mockImplementation(() => mockPrismaPgInstance),
+}));
+
+const mockPrismaClientMethods = {
+  $connect: jest.fn(),
+  $disconnect: jest.fn(),
+  $queryRaw: jest.fn(),
+};
+
+jest.mock('../prisma/generated/prisma/client', () => {
+  class MockPrismaClient {
+    $connect = jest.fn();
+    $disconnect = jest.fn();
+    $queryRaw = jest.fn();
+  }
+  return {
+    PrismaClient: MockPrismaClient,
+  };
+});
+
+describe('PrismaService', () => {
+  let service: PrismaService;
+  let mockConfig: PostgresStorageConfig;
+  let mockLogger: jest.Mocked<IDismissibleLogger>;
+
+  beforeEach(() => {
+    mockConfig = {
+      connectionString: 'postgresql://user:password@localhost:5432/testdb',
+    };
+    mockLogger = mock<IDismissibleLogger>({ failIfMockNotProvided: false });
+
+    jest.clearAllMocks();
+    mockPrismaClientMethods.$connect.mockClear();
+    mockPrismaClientMethods.$disconnect.mockClear();
+    mockPrismaClientMethods.$queryRaw.mockClear();
+  });
+
+  describe('constructor', () => {
+    it('should create PrismaService with pool and adapter', () => {
+      const { Pool } = require('pg');
+      const { PrismaPg } = require('@prisma/adapter-pg');
+
+      service = new PrismaService(mockConfig, mockLogger);
+
+      expect(service).toBeDefined();
+      expect(Pool).toHaveBeenCalledWith({
+        connectionString: mockConfig.connectionString,
+      });
+      expect(PrismaPg).toHaveBeenCalledWith(mockPoolInstance);
+    });
+  });
+
+  describe('onModuleInit', () => {
+    it('should connect to database and verify connection', async () => {
+      service = new PrismaService(mockConfig, mockLogger);
+      (service as any).$connect.mockResolvedValue(undefined);
+      (service as any).$queryRaw.mockResolvedValue([{ '?column?': 1 }]);
+
+      await service.onModuleInit();
+
+      expect(mockLogger.debug).toHaveBeenCalledWith('Connecting to PostgreSQL database');
+      expect((service as any).$connect).toHaveBeenCalled();
+      expect((service as any).$queryRaw).toHaveBeenCalled();
+      expect(mockLogger.debug).toHaveBeenCalledWith('Connected to PostgreSQL database');
+    });
+
+    it('should throw error when connection fails', async () => {
+      service = new PrismaService(mockConfig, mockLogger);
+      const connectError = new Error('Connection refused');
+      (service as any).$connect = jest.fn().mockRejectedValue(connectError);
+
+      await expect(service.onModuleInit()).rejects.toThrow('Connection refused');
+    });
+
+    it('should throw error when query verification fails', async () => {
+      service = new PrismaService(mockConfig, mockLogger);
+      (service as any).$connect.mockResolvedValue(undefined);
+      (service as any).$queryRaw.mockRejectedValue(new Error('Query failed'));
+
+      await expect(service.onModuleInit()).rejects.toThrow(
+        'Database connection failed: Query failed. Ensure PostgreSQL is running and DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING is configured correctly.',
+      );
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        'Failed to connect to PostgreSQL database',
+        expect.any(Error),
+      );
+    });
+
+    it('should handle non-Error objects in catch block', async () => {
+      service = new PrismaService(mockConfig, mockLogger);
+      (service as any).$connect.mockResolvedValue(undefined);
+      (service as any).$queryRaw.mockRejectedValue('String error');
+
+      await expect(service.onModuleInit()).rejects.toThrow(
+        'Database connection failed: Unknown error. Ensure PostgreSQL is running and DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING is configured correctly.',
+      );
+    });
+  });
+
+  describe('onModuleDestroy', () => {
+    it('should disconnect from database', async () => {
+      service = new PrismaService(mockConfig, mockLogger);
+      (service as any).$disconnect.mockResolvedValue(undefined);
+
+      await service.onModuleDestroy();
+
+      expect(mockLogger.debug).toHaveBeenCalledWith('Disconnecting from PostgreSQL database');
+      expect((service as any).$disconnect).toHaveBeenCalled();
+      expect(mockLogger.debug).toHaveBeenCalledWith('Disconnected from PostgreSQL database');
+    });
+  });
+});

package/src/prisma.service.ts

@@ -23,7 +23,17 @@ export class PrismaService extends PrismaClient implements OnModuleInit, OnModul
   async onModuleInit(): Promise<void> {
     this.logger.debug('Connecting to PostgreSQL database');
     await this.$connect();
-    this.logger.debug('Connected to PostgreSQL database');
+
+    try {
+      await this.$queryRaw`SELECT 1`;
+      this.logger.debug('Connected to PostgreSQL database');
+    } catch (error) {
+      this.logger.error('Failed to connect to PostgreSQL database', error);
+      throw new Error(
+        `Database connection failed: ${error instanceof Error ? error.message : 'Unknown error'}. ` +
+          'Ensure PostgreSQL is running and DISMISSIBLE_POSTGRES_STORAGE_CONNECTION_STRING is configured correctly.',
+      );
+    }
   }
 
   async onModuleDestroy(): Promise<void> {

package/src/schema-path.spec.ts

@@ -0,0 +1,22 @@
+import { getPrismaSchemaPath } from './schema-path';
+import { join } from 'path';
+
+describe('schema-path', () => {
+  describe('getPrismaSchemaPath', () => {
+    it('should return the absolute path to the Prisma schema file', () => {
+      const schemaPath = getPrismaSchemaPath();
+
+      expect(schemaPath).toBeDefined();
+      expect(typeof schemaPath).toBe('string');
+      expect(schemaPath).toContain('prisma');
+      expect(schemaPath).toContain('schema.prisma');
+      expect(schemaPath).toBe(join(__dirname, '..', 'prisma', 'schema.prisma'));
+    });
+
+    it('should return a valid path structure', () => {
+      const schemaPath = getPrismaSchemaPath();
+
+      expect(schemaPath).toMatch(/^(\/|[A-Z]:\\)/);
+    });
+  });
+});