@hazeljs/prisma 0.2.0-alpha.1

package/dist/base.repository.d.ts

@@ -0,0 +1,45 @@
+import { PrismaService } from './prisma.service';
+export type PrismaModel = {
+    id: number;
+    [key: string]: unknown;
+};
+export type WhereUniqueInput = {
+    id?: number;
+    [key: string]: unknown;
+};
+export type UpdateInput = {
+    [key: string]: unknown;
+};
+type PrismaModelDelegate = {
+    findMany: () => Promise<unknown[]>;
+    findUnique: (args: {
+        where: WhereUniqueInput;
+    }) => Promise<unknown | null>;
+    create: (args: {
+        data: unknown;
+    }) => Promise<unknown>;
+    update: (args: {
+        where: WhereUniqueInput;
+        data: UpdateInput;
+    }) => Promise<unknown>;
+    delete: (args: {
+        where: WhereUniqueInput;
+    }) => Promise<unknown>;
+    count: (args?: unknown) => Promise<number>;
+};
+export declare abstract class BaseRepository<T extends PrismaModel> {
+    protected readonly prisma: PrismaService;
+    protected readonly model: string;
+    constructor(prisma: PrismaService, model: string);
+    protected get prismaClient(): PrismaService;
+    protected get modelDelegate(): PrismaModelDelegate;
+    protected handleError(error: unknown): never;
+    findMany(): Promise<T[]>;
+    findOne(where: WhereUniqueInput): Promise<T | null>;
+    create(data: Omit<T, 'id'>): Promise<T>;
+    update(where: WhereUniqueInput, data: UpdateInput): Promise<T>;
+    delete(where: WhereUniqueInput): Promise<T>;
+    count(args?: unknown): Promise<number>;
+}
+export {};
+//# sourceMappingURL=base.repository.d.ts.map

package/dist/base.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.repository.d.ts","sourceRoot":"","sources":["../src/base.repository.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKjD,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,mBAAmB,GAAG;IACzB,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IACnC,UAAU,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,gBAAgB,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IAC3E,MAAM,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACtD,MAAM,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,gBAAgB,CAAC;QAAC,IAAI,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACnF,MAAM,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,gBAAgB,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAChE,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAC5C,CAAC;AAEF,8BACsB,cAAc,CAAC,CAAC,SAAS,WAAW;IAItD,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,aAAa;IAH1C,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;gBAGZ,MAAM,EAAE,aAAa,EACxC,KAAK,EAAE,MAAM;IAKf,SAAS,KAAK,YAAY,IAAI,aAAa,CAE1C;IAED,SAAS,KAAK,aAAa,IAAI,mBAAmB,CAEjD;IAED,SAAS,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK;IA4BtC,QAAQ,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAKxB,OAAO,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAKnD,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAKvC,MAAM,CAAC,KAAK,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC;IAK9D,MAAM,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC;IAK3C,KAAK,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CAG7C"}

package/dist/base.repository.js

@@ -0,0 +1,82 @@
+"use strict";
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseRepository = void 0;
+const core_1 = require("@hazeljs/core");
+const prisma_service_1 = require("./prisma.service");
+const library_1 = require("@prisma/client/runtime/library");
+const core_2 = __importDefault(require("@hazeljs/core"));
+let BaseRepository = class BaseRepository {
+    constructor(prisma, model) {
+        this.prisma = prisma;
+        this.model = model;
+    }
+    get prismaClient() {
+        return this.prisma;
+    }
+    get modelDelegate() {
+        return this.prismaClient[this.model];
+    }
+    handleError(error) {
+        core_2.default.error('Database error:', error);
+        if (error instanceof library_1.PrismaClientKnownRequestError) {
+            let errorMessage;
+            let target;
+            switch (error.code) {
+                case 'P2002':
+                    target = error.meta?.target;
+                    errorMessage = `Unique constraint violation on field${target ? `s: ${target.join(', ')}` : ''}`;
+                    break;
+                case 'P2025':
+                    errorMessage = 'Record not found';
+                    break;
+                case 'P2003':
+                    errorMessage = 'Foreign key constraint violation';
+                    break;
+                default:
+                    errorMessage = `Database error: ${error.message}`;
+            }
+            throw new Error(errorMessage);
+        }
+        throw new Error(`Database error: ${error.message}`);
+    }
+    async findMany() {
+        const result = await this.modelDelegate.findMany();
+        return result;
+    }
+    async findOne(where) {
+        const result = await this.modelDelegate.findUnique({ where });
+        return result;
+    }
+    async create(data) {
+        const result = await this.modelDelegate.create({ data });
+        return result;
+    }
+    async update(where, data) {
+        const result = await this.modelDelegate.update({ where, data });
+        return result;
+    }
+    async delete(where) {
+        const result = await this.modelDelegate.delete({ where });
+        return result;
+    }
+    async count(args) {
+        return this.modelDelegate.count(args);
+    }
+};
+exports.BaseRepository = BaseRepository;
+exports.BaseRepository = BaseRepository = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [prisma_service_1.PrismaService, String])
+], BaseRepository);

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @hazeljs/prisma - Prisma integration for HazelJS
+ */
+export { PrismaModule } from './prisma.module';
+export { PrismaService } from './prisma.service';
+export { BaseRepository, type PrismaModel, type WhereUniqueInput, type UpdateInput, } from './base.repository';
+export { Repository } from './repository.decorator';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EACL,cAAc,EACd,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * @hazeljs/prisma - Prisma integration for HazelJS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = exports.BaseRepository = exports.PrismaService = exports.PrismaModule = void 0;
+var prisma_module_1 = require("./prisma.module");
+Object.defineProperty(exports, "PrismaModule", { enumerable: true, get: function () { return prisma_module_1.PrismaModule; } });
+var prisma_service_1 = require("./prisma.service");
+Object.defineProperty(exports, "PrismaService", { enumerable: true, get: function () { return prisma_service_1.PrismaService; } });
+var base_repository_1 = require("./base.repository");
+Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return base_repository_1.BaseRepository; } });
+var repository_decorator_1 = require("./repository.decorator");
+Object.defineProperty(exports, "Repository", { enumerable: true, get: function () { return repository_decorator_1.Repository; } });

package/dist/prisma.module.d.ts

@@ -0,0 +1,3 @@
+export declare class PrismaModule {
+}
+//# sourceMappingURL=prisma.module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.module.d.ts","sourceRoot":"","sources":["../src/prisma.module.ts"],"names":[],"mappings":"AAGA,qBAIa,YAAY;CAAG"}

package/dist/prisma.module.js

@@ -0,0 +1,20 @@
+"use strict";
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaModule = void 0;
+const core_1 = require("@hazeljs/core");
+const prisma_service_1 = require("./prisma.service");
+let PrismaModule = class PrismaModule {
+};
+exports.PrismaModule = PrismaModule;
+exports.PrismaModule = PrismaModule = __decorate([
+    (0, core_1.Module)({
+        providers: [prisma_service_1.PrismaService],
+        exports: [prisma_service_1.PrismaService],
+    })
+], PrismaModule);

package/dist/prisma.service.d.ts

@@ -0,0 +1,7 @@
+import { PrismaClient } from '@prisma/client';
+export declare class PrismaService extends PrismaClient {
+    constructor();
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+}
+//# sourceMappingURL=prisma.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prisma.service.d.ts","sourceRoot":"","sources":["../src/prisma.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAwB9C,qBACa,aAAc,SAAQ,YAAY;;IAoCvC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAU7B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;CASvC"}

package/dist/prisma.service.js

@@ -0,0 +1,77 @@
+"use strict";
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaService = void 0;
+const core_1 = require("@hazeljs/core");
+const client_1 = require("@prisma/client");
+const core_2 = __importDefault(require("@hazeljs/core"));
+function isQueryEvent(event) {
+    return 'query' in event && 'params' in event && 'duration' in event;
+}
+function isErrorEvent(event) {
+    return 'message' in event;
+}
+let PrismaService = class PrismaService extends client_1.PrismaClient {
+    constructor() {
+        super({
+            log: [
+                {
+                    emit: 'event',
+                    level: 'query',
+                },
+                {
+                    emit: 'event',
+                    level: 'error',
+                },
+            ],
+        });
+        this.$on('query', (e) => {
+            if (isQueryEvent(e)) {
+                core_2.default.debug(`Query: ${e.query}`);
+                core_2.default.debug(`Params: ${e.params}`);
+                core_2.default.debug(`Duration: ${e.duration}ms`);
+            }
+        });
+        this.$on('error', (e) => {
+            if (isErrorEvent(e)) {
+                core_2.default.error('Prisma Error:', e);
+            }
+        });
+    }
+    async onModuleInit() {
+        try {
+            await this.$connect();
+            core_2.default.info('Connected to database');
+        }
+        catch (error) {
+            core_2.default.error('Failed to connect to database:', error);
+            throw error;
+        }
+    }
+    async onModuleDestroy() {
+        try {
+            await this.$disconnect();
+            core_2.default.info('Disconnected from database');
+        }
+        catch (error) {
+            core_2.default.error('Error disconnecting from database:', error);
+            throw error;
+        }
+    }
+};
+exports.PrismaService = PrismaService;
+exports.PrismaService = PrismaService = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], PrismaService);

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/dist/repository.decorator.d.ts

@@ -0,0 +1,5 @@
+import { RepositoryOptions } from '@hazeljs/core';
+import 'reflect-metadata';
+export declare function Repository(options: RepositoryOptions | string): ClassDecorator;
+export declare function InjectRepository(): ParameterDecorator;
+//# sourceMappingURL=repository.decorator.d.ts.map

package/dist/repository.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.decorator.d.ts","sourceRoot":"","sources":["../src/repository.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,kBAAkB,CAAC;AAE1B,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,GAAG,cAAc,CAW9E;AAED,wBAAgB,gBAAgB,IAAI,kBAAkB,CA0BrD"}

package/dist/repository.decorator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Repository = Repository;
+exports.InjectRepository = InjectRepository;
+require("reflect-metadata");
+function Repository(options) {
+    return function (target) {
+        const opts = typeof options === 'string' ? { model: options } : options;
+        Reflect.defineMetadata('hazel:repository', opts, target);
+        // Implicitly mark the class as injectable — @Injectable() is not needed separately.
+        // Write metadata directly to avoid the ClassDecorator `Function` type constraint.
+        Reflect.defineMetadata('hazel:injectable', opts.scope ? { scope: opts.scope } : {}, target);
+        if (opts.scope) {
+            Reflect.defineMetadata('hazel:scope', opts.scope, target);
+        }
+    };
+}
+function InjectRepository() {
+    return function (target, propertyKey, parameterIndex) {
+        if (!propertyKey) {
+            throw new Error('InjectRepository decorator must be used on a method parameter');
+        }
+        const repositoryType = Reflect.getMetadata('design:paramtypes', target, propertyKey)[parameterIndex];
+        const model = Reflect.getMetadata('hazel:repository:model', repositoryType);
+        if (!model) {
+            throw new Error(`Repository ${repositoryType.name} is not decorated with @Repository`);
+        }
+        const repositories = Reflect.getMetadata('hazel:repositories', target) || [];
+        repositories.push({
+            index: parameterIndex,
+            model,
+        });
+        Reflect.defineMetadata('hazel:repositories', repositories, target);
+    };
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@hazeljs/prisma",
+  "version": "0.2.0-alpha.1",
+  "description": "Prisma ORM integration for HazelJS framework",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --coverage --passWithNoTests",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@prisma/client": "^6.8.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.50",
+    "@typescript-eslint/eslint-plugin": "^8.18.2",
+    "@typescript-eslint/parser": "^8.18.2",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "prisma": "^6.8.2",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hazel-js/hazeljs.git",
+    "directory": "packages/prisma"
+  },
+  "keywords": [
+    "hazeljs",
+    "prisma",
+    "orm",
+    "database"
+  ],
+  "author": "Muhammad Arslan <muhammad.arslan@hazeljs.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/hazeljs/hazel-js/issues"
+  },
+  "homepage": "https://hazeljs.com",
+  "peerDependencies": {
+    "@hazeljs/core": ">=0.2.0-beta.0"
+  },
+  "gitHead": "cbc5ee2c12ced28fd0576faf13c5f078c1e8421e"
+}