@dismissible/nestjs-postgres-storage 0.0.2-canary.c91edbc.0 → 0.0.2-canary.d2f56d7.0

package/prisma.config.mjs

@@ -0,0 +1,35 @@
+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';
@@ -64,7 +63,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 +73,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 +93,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 +103,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 +110,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 +117,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 +132,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 +142,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 +152,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 +159,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,131 @@
+import { mock } from 'ts-jest-mocker';
+import { PrismaService } from './prisma.service';
+import { PostgresStorageConfig } from './postgres-storage.config';
+import { IDismissibleLogger } from '@dismissible/nestjs-logger';
+
+// Mock the modules before importing PrismaService
+const mockPoolInstance = {};
+const mockPrismaPgInstance = {};
+
+jest.mock('pg', () => ({
+  Pool: jest.fn().mockImplementation(() => mockPoolInstance),
+}));
+
+jest.mock('@prisma/adapter-pg', () => ({
+  PrismaPg: jest.fn().mockImplementation(() => mockPrismaPgInstance),
+}));
+
+// Mock PrismaClient to avoid actual initialization
+const mockPrismaClientMethods = {
+  $connect: jest.fn(),
+  $disconnect: jest.fn(),
+  $queryRaw: jest.fn(),
+};
+
+jest.mock('../prisma/generated/prisma/client', () => {
+  // Create a mock PrismaClient class inside the factory
+  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 });
+
+    // Clear all mocks
+    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);
+
+      // $connect() is called before the try-catch, so errors propagate directly
+      await expect(service.onModuleInit()).rejects.toThrow('Connection refused');
+      // Note: $connect errors are not logged because they're outside the try-catch
+    });
+
+    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/schema-path.spec.ts

@@ -0,0 +1,24 @@
+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');
+      // Verify it uses join to construct the path
+      expect(schemaPath).toBe(join(__dirname, '..', 'prisma', 'schema.prisma'));
+    });
+
+    it('should return a valid path structure', () => {
+      const schemaPath = getPrismaSchemaPath();
+
+      // Path should be absolute (starts with / on Unix, or C:\ on Windows)
+      expect(schemaPath).toMatch(/^(\/|[A-Z]:\\)/);
+    });
+  });
+});

package/src/schema-path.ts

@@ -6,12 +6,12 @@ import { join } from 'path';
  *
  * @example
  * ```typescript
- * import { getSchemaPath } from '@dismissible/nestjs-postgres-storage';
+ * import { getPrismaSchemaPath } from '@dismissible/nestjs-postgres-storage';
  * import { execSync } from 'child_process';
  *
- * execSync(`npx prisma generate --schema=${getSchemaPath()}`);
+ * execSync(`npx prisma generate --schema=${getPrismaSchemaPath()}`);
  * ```
  */
-export function getSchemaPath(): string {
+export function getPrismaSchemaPath(): string {
   return join(__dirname, '..', 'prisma', 'schema.prisma');
 }

package/jest.config.ts

@@ -1,10 +0,0 @@
-export default {
-  displayName: 'postgres-storage',
-  preset: '../../jest.preset.js',
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/libs/postgres-storage',
-};