@hazeljs/prisma 0.2.0-beta.55 → 0.2.0-beta.56

package/dist/__mocks__/@prisma/client/runtime/library.d.ts

@@ -0,0 +1,10 @@
+export declare class PrismaClientKnownRequestError extends Error {
+    code: string;
+    meta?: Record<string, unknown>;
+    clientVersion: string;
+    constructor(message: string, { code, meta }: {
+        code: string;
+        meta?: Record<string, unknown>;
+    });
+}
+//# sourceMappingURL=library.d.ts.map

package/dist/__mocks__/@prisma/client/runtime/library.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library.d.ts","sourceRoot":"","sources":["../../../../../src/__mocks__/@prisma/client/runtime/library.ts"],"names":[],"mappings":"AAAA,qBAAa,6BAA8B,SAAQ,KAAK;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;gBAEV,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE;CAO9F"}

package/dist/__mocks__/@prisma/client/runtime/library.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaClientKnownRequestError = void 0;
+class PrismaClientKnownRequestError extends Error {
+    constructor(message, { code, meta }) {
+        super(message);
+        this.name = 'PrismaClientKnownRequestError';
+        this.code = code;
+        this.meta = meta;
+        this.clientVersion = '5.0.0';
+    }
+}
+exports.PrismaClientKnownRequestError = PrismaClientKnownRequestError;

package/dist/__mocks__/@prisma/client.d.ts

@@ -0,0 +1,7 @@
+export declare class PrismaClient {
+    $on: jest.Mock<any, any, any>;
+    $connect: jest.Mock<any, any, any>;
+    $disconnect: jest.Mock<any, any, any>;
+    constructor(_options?: unknown);
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/__mocks__/@prisma/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/__mocks__/@prisma/client.ts"],"names":[],"mappings":"AAAA,qBAAa,YAAY;IACvB,GAAG,2BAAa;IAChB,QAAQ,2BAA0C;IAClD,WAAW,2BAA0C;gBAEzC,QAAQ,CAAC,EAAE,OAAO;CAC/B"}

package/dist/__mocks__/@prisma/client.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaClient = void 0;
+class PrismaClient {
+    constructor(_options) {
+        this.$on = jest.fn();
+        this.$connect = jest.fn().mockResolvedValue(undefined);
+        this.$disconnect = jest.fn().mockResolvedValue(undefined);
+    }
+}
+exports.PrismaClient = PrismaClient;

package/dist/prisma.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prisma.test.d.ts.map

package/dist/prisma.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.test.d.ts","sourceRoot":"","sources":["../src/prisma.test.ts"],"names":[],"mappings":""}

package/dist/prisma.test.js

@@ -0,0 +1,271 @@
+"use strict";
+/// <reference types="jest" />
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    Injectable: () => () => undefined,
+    HazelModule: () => () => undefined,
+    Module: () => () => undefined,
+    RepositoryOptions: class {
+    },
+    logger: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+    default: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const core_1 = __importDefault(require("@hazeljs/core"));
+const prisma_service_1 = require("./prisma.service");
+const base_repository_1 = require("./base.repository");
+const repository_decorator_1 = require("./repository.decorator");
+const library_1 = require("./__mocks__/@prisma/client/runtime/library");
+// ─── PrismaService ────────────────────────────────────────────────────────────
+describe('PrismaService', () => {
+    let service;
+    let $onMock;
+    beforeEach(() => {
+        service = new prisma_service_1.PrismaService();
+        $onMock = service.$on;
+    });
+    it('instantiates without error', () => {
+        expect(service).toBeDefined();
+    });
+    it('registers $on handler for query events', () => {
+        expect($onMock).toHaveBeenCalledWith('query', expect.any(Function));
+    });
+    it('registers $on handler for error events', () => {
+        expect($onMock).toHaveBeenCalledWith('error', expect.any(Function));
+    });
+    it('query event callback logs valid query events', () => {
+        const queryCallback = $onMock.mock.calls.find(([evt]) => evt === 'query')?.[1];
+        expect(queryCallback).toBeDefined();
+        queryCallback({ query: 'SELECT 1', params: '[]', duration: 5 });
+        expect(core_1.default.debug).toHaveBeenCalled();
+    });
+    it('query event callback ignores non-query events', () => {
+        const queryCallback = $onMock.mock.calls.find(([evt]) => evt === 'query')?.[1];
+        jest.clearAllMocks();
+        queryCallback({ message: 'not a query event' });
+        expect(core_1.default.debug).not.toHaveBeenCalled();
+    });
+    it('error event callback logs prisma error events', () => {
+        const errorCallback = $onMock.mock.calls.find(([evt]) => evt === 'error')?.[1];
+        expect(errorCallback).toBeDefined();
+        errorCallback({ message: 'some error' });
+        expect(core_1.default.error).toHaveBeenCalled();
+    });
+    it('error event callback ignores events without message', () => {
+        const errorCallback = $onMock.mock.calls.find(([evt]) => evt === 'error')?.[1];
+        jest.clearAllMocks();
+        errorCallback({ query: 'SELECT 1', params: '[]', duration: 2 });
+        expect(core_1.default.error).not.toHaveBeenCalled();
+    });
+    it('onModuleInit calls $connect and resolves', async () => {
+        await expect(service.onModuleInit()).resolves.toBeUndefined();
+        expect(service.$connect).toHaveBeenCalled();
+    });
+    it('onModuleInit throws and logs when $connect rejects', async () => {
+        service.$connect.mockRejectedValueOnce(new Error('connection refused'));
+        await expect(service.onModuleInit()).rejects.toThrow('connection refused');
+    });
+    it('onModuleDestroy calls $disconnect and resolves', async () => {
+        await expect(service.onModuleDestroy()).resolves.toBeUndefined();
+        expect(service.$disconnect).toHaveBeenCalled();
+    });
+    it('onModuleDestroy throws and logs when $disconnect rejects', async () => {
+        service.$disconnect.mockRejectedValueOnce(new Error('disconnect failed'));
+        await expect(service.onModuleDestroy()).rejects.toThrow('disconnect failed');
+    });
+});
+function buildMockDelegate() {
+    return {
+        findMany: jest.fn(),
+        findUnique: jest.fn(),
+        create: jest.fn(),
+        update: jest.fn(),
+        delete: jest.fn(),
+        count: jest.fn(),
+    };
+}
+class TestRepository extends base_repository_1.BaseRepository {
+    constructor(prisma) {
+        super(prisma, 'testModel');
+    }
+    // Expose protected handleError for testing
+    testHandleError(error) {
+        return this.handleError(error);
+    }
+}
+function buildRepo() {
+    const delegate = buildMockDelegate();
+    const mockPrisma = {
+        $on: jest.fn(),
+        $connect: jest.fn().mockResolvedValue(undefined),
+        $disconnect: jest.fn().mockResolvedValue(undefined),
+        testModel: delegate,
+    };
+    const repo = new TestRepository(mockPrisma);
+    return { repo, delegate };
+}
+describe('BaseRepository', () => {
+    describe('findMany()', () => {
+        it('returns all records', async () => {
+            const { repo, delegate } = buildRepo();
+            const records = [
+                { id: 1, name: 'Alice' },
+                { id: 2, name: 'Bob' },
+            ];
+            delegate.findMany.mockResolvedValue(records);
+            await expect(repo.findMany()).resolves.toEqual(records);
+        });
+    });
+    describe('findOne()', () => {
+        it('returns matching record', async () => {
+            const { repo, delegate } = buildRepo();
+            const record = { id: 1, name: 'Alice' };
+            delegate.findUnique.mockResolvedValue(record);
+            await expect(repo.findOne({ id: 1 })).resolves.toEqual(record);
+            expect(delegate.findUnique).toHaveBeenCalledWith({ where: { id: 1 } });
+        });
+        it('returns null when not found', async () => {
+            const { repo, delegate } = buildRepo();
+            delegate.findUnique.mockResolvedValue(null);
+            await expect(repo.findOne({ id: 99 })).resolves.toBeNull();
+        });
+    });
+    describe('create()', () => {
+        it('creates and returns a record', async () => {
+            const { repo, delegate } = buildRepo();
+            const created = { id: 3, name: 'Charlie' };
+            delegate.create.mockResolvedValue(created);
+            await expect(repo.create({ name: 'Charlie' })).resolves.toEqual(created);
+            expect(delegate.create).toHaveBeenCalledWith({ data: { name: 'Charlie' } });
+        });
+    });
+    describe('update()', () => {
+        it('updates and returns the updated record', async () => {
+            const { repo, delegate } = buildRepo();
+            const updated = { id: 1, name: 'Updated' };
+            delegate.update.mockResolvedValue(updated);
+            await expect(repo.update({ id: 1 }, { name: 'Updated' })).resolves.toEqual(updated);
+            expect(delegate.update).toHaveBeenCalledWith({ where: { id: 1 }, data: { name: 'Updated' } });
+        });
+    });
+    describe('delete()', () => {
+        it('deletes and returns the deleted record', async () => {
+            const { repo, delegate } = buildRepo();
+            const deleted = { id: 1, name: 'Alice' };
+            delegate.delete.mockResolvedValue(deleted);
+            await expect(repo.delete({ id: 1 })).resolves.toEqual(deleted);
+            expect(delegate.delete).toHaveBeenCalledWith({ where: { id: 1 } });
+        });
+    });
+    describe('count()', () => {
+        it('returns record count', async () => {
+            const { repo, delegate } = buildRepo();
+            delegate.count.mockResolvedValue(5);
+            await expect(repo.count()).resolves.toBe(5);
+        });
+        it('passes args to count', async () => {
+            const { repo, delegate } = buildRepo();
+            delegate.count.mockResolvedValue(2);
+            const args = { where: { name: 'Alice' } };
+            await expect(repo.count(args)).resolves.toBe(2);
+            expect(delegate.count).toHaveBeenCalledWith(args);
+        });
+    });
+    describe('prismaClient / modelDelegate getters', () => {
+        it('prismaClient returns the prisma instance', () => {
+            const { repo } = buildRepo();
+            expect(repo.prismaClient).toBeDefined();
+        });
+    });
+    describe('handleError()', () => {
+        it('throws unique constraint error for P2002 with target', () => {
+            const { repo } = buildRepo();
+            const err = new library_1.PrismaClientKnownRequestError('unique', {
+                code: 'P2002',
+                meta: { target: ['email', 'username'] },
+            });
+            expect(() => repo.testHandleError(err)).toThrow('Unique constraint violation on fields: email, username');
+        });
+        it('throws unique constraint error for P2002 without target', () => {
+            const { repo } = buildRepo();
+            const err = new library_1.PrismaClientKnownRequestError('unique', { code: 'P2002' });
+            expect(() => repo.testHandleError(err)).toThrow('Unique constraint violation on field');
+        });
+        it('throws not found error for P2025', () => {
+            const { repo } = buildRepo();
+            const err = new library_1.PrismaClientKnownRequestError('not found', { code: 'P2025' });
+            expect(() => repo.testHandleError(err)).toThrow('Record not found');
+        });
+        it('throws foreign key error for P2003', () => {
+            const { repo } = buildRepo();
+            const err = new library_1.PrismaClientKnownRequestError('fk', { code: 'P2003' });
+            expect(() => repo.testHandleError(err)).toThrow('Foreign key constraint violation');
+        });
+        it('throws generic db error for unknown prisma code', () => {
+            const { repo } = buildRepo();
+            const err = new library_1.PrismaClientKnownRequestError('unknown', { code: 'P9999' });
+            expect(() => repo.testHandleError(err)).toThrow('Database error:');
+        });
+        it('throws wrapped error for non-prisma errors', () => {
+            const { repo } = buildRepo();
+            expect(() => repo.testHandleError(new Error('generic error'))).toThrow('Database error: generic error');
+        });
+    });
+});
+// ─── Repository decorator ─────────────────────────────────────────────────────
+describe('@Repository decorator', () => {
+    it('sets hazel:repository metadata with string shorthand', () => {
+        let UserRepo = class UserRepo {
+        };
+        UserRepo = __decorate([
+            (0, repository_decorator_1.Repository)('user')
+        ], UserRepo);
+        const meta = Reflect.getMetadata('hazel:repository', UserRepo);
+        expect(meta).toEqual({ model: 'user' });
+    });
+    it('sets hazel:repository metadata with options object', () => {
+        let PostRepo = class PostRepo {
+        };
+        PostRepo = __decorate([
+            (0, repository_decorator_1.Repository)({ model: 'post' })
+        ], PostRepo);
+        const meta = Reflect.getMetadata('hazel:repository', PostRepo);
+        expect(meta).toEqual({ model: 'post' });
+    });
+    it('sets hazel:injectable metadata', () => {
+        let CommentRepo = class CommentRepo {
+        };
+        CommentRepo = __decorate([
+            (0, repository_decorator_1.Repository)('comment')
+        ], CommentRepo);
+        const injectable = Reflect.getMetadata('hazel:injectable', CommentRepo);
+        expect(injectable).toEqual({});
+    });
+    it('sets hazel:scope metadata when scope is provided', () => {
+        let SessionRepo = class SessionRepo {
+        };
+        SessionRepo = __decorate([
+            (0, repository_decorator_1.Repository)({ model: 'session', scope: 'REQUEST' })
+        ], SessionRepo);
+        const scope = Reflect.getMetadata('hazel:scope', SessionRepo);
+        expect(scope).toBe('REQUEST');
+    });
+    it('sets hazel:injectable metadata with scope when scope is provided', () => {
+        let LogRepo = class LogRepo {
+        };
+        LogRepo = __decorate([
+            (0, repository_decorator_1.Repository)({ model: 'log', scope: 'TRANSIENT' })
+        ], LogRepo);
+        const injectable = Reflect.getMetadata('hazel:injectable', LogRepo);
+        expect(injectable).toEqual({ scope: 'TRANSIENT' });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/prisma",
-  "version": "0.2.0-beta.55",
+  "version": "0.2.0-beta.56",
   "description": "Prisma ORM integration for HazelJS framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,5 +50,5 @@
   "peerDependencies": {
     "@hazeljs/core": ">=0.2.0-beta.0"
   },
-  "gitHead": "f2e54f346eea552595a44607999454a9e388cb9e"
+  "gitHead": "c2737e90974458a8438eee623726f0a453b66b8b"
 }