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

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

@@ -0,0 +1,44 @@
+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();
+
+    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> {
+    this.logger.debug('Disconnecting from PostgreSQL database');
+    await this.$disconnect();
+    this.logger.debug('Disconnected from PostgreSQL database');
+  }
+}

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]:\\)/);
+    });
+  });
+});

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 { getPrismaSchemaPath } from '@dismissible/nestjs-postgres-storage';
+ * import { execSync } from 'child_process';
+ *
+ * execSync(`npx prisma generate --schema=${getPrismaSchemaPath()}`);
+ * ```
+ */
+export function getPrismaSchemaPath(): string {
+  return join(__dirname, '..', 'prisma', 'schema.prisma');
+}