@hazeljs/typeorm 0.2.0-beta.53 → 0.2.0-beta.55

package/README.md

@@ -85,12 +85,12 @@ export class UserEntity {
 
 ### 4. Create a repository
 
+`@Repository` implies `@Injectable()` — no need to add both decorators.
+
 ```typescript
-import { Injectable } from '@hazeljs/core';
 import { BaseRepository, Repository, TypeOrmService } from '@hazeljs/typeorm';
 import { UserEntity } from './user.entity';
 
-@Injectable()
 @Repository({ model: 'User' })
 export class UserRepository extends BaseRepository<UserEntity> {
   constructor(typeOrm: TypeOrmService) {
@@ -105,12 +105,14 @@ export class UserRepository extends BaseRepository<UserEntity> {
 
 ### 5. Use in a service
 
+Use `@Service` for service classes — it is the correct decorator for business-logic classes in HazelJS (not `@Injectable`).
+
 ```typescript
-import { Injectable } from '@hazeljs/core';
+import { Service } from '@hazeljs/core';
 import { InjectRepository } from '@hazeljs/typeorm';
 import { UserRepository } from './user.repository';
 
-@Injectable()
+@Service()
 export class UserService {
   constructor(
     @InjectRepository()
@@ -132,9 +134,10 @@ export class UserService {
 Use `TypeOrmService.dataSource` for transactions:
 
 ```typescript
+import { Service } from '@hazeljs/core';
 import { TypeOrmService } from '@hazeljs/typeorm';
 
-@Injectable()
+@Service()
 export class TransferService {
   constructor(private readonly typeOrm: TypeOrmService) {}
 

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

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

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

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

package/dist/base.repository.test.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_repository_1 = require("./base.repository");
+const typeorm_service_1 = require("./typeorm.service");
+class TestEntity {
+}
+class TestRepository extends base_repository_1.BaseRepository {
+    constructor(typeOrm) {
+        super(typeOrm, TestEntity);
+    }
+}
+describe('BaseRepository', () => {
+    let typeOrm;
+    let repo;
+    beforeAll(() => {
+        const mockRepository = {
+            find: jest.fn().mockResolvedValue([]),
+            findOne: jest.fn().mockResolvedValue(null),
+            create: jest.fn(),
+            save: jest.fn(),
+            update: jest.fn().mockResolvedValue(undefined),
+            delete: jest.fn().mockResolvedValue(undefined),
+            count: jest.fn().mockResolvedValue(0),
+        };
+        const dataSource = {
+            isInitialized: true,
+            getRepository: jest.fn(() => mockRepository),
+        };
+        typeOrm = new typeorm_service_1.TypeOrmService({ dataSource });
+        repo = new TestRepository(typeOrm);
+    });
+    it('should expose repository getter', () => {
+        expect(repo['repository']).toBeDefined();
+        expect(repo['repository'].find).toBeDefined();
+    });
+    it('should delegate find to TypeORM repository', async () => {
+        const result = await repo.find({});
+        expect(Array.isArray(result)).toBe(true);
+    });
+    it('should delegate count to TypeORM repository', async () => {
+        const result = await repo.count({});
+        expect(typeof result).toBe('number');
+        expect(result).toBe(0);
+    });
+    describe('handleError', () => {
+        it('should throw on generic error', () => {
+            expect(() => repo['handleError'](new Error('db error'))).toThrow('Database error: db error');
+        });
+        it('should map unique constraint code 23505', () => {
+            const err = new Error('duplicate');
+            err.code = '23505';
+            expect(() => repo['handleError'](err)).toThrow(/Unique constraint/);
+        });
+        it('should map foreign key code 23503', () => {
+            const err = new Error('fk');
+            err.code = '23503';
+            expect(() => repo['handleError'](err)).toThrow('Foreign key constraint violation');
+        });
+    });
+});

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

@@ -1 +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,CAK9E;AAED,wBAAgB,gBAAgB,IAAI,kBAAkB,CAyBrD"}
+{"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,CAyBrD"}

package/dist/repository.decorator.js

@@ -7,6 +7,12 @@ 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() {

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

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=repository.decorator.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repository.decorator.test.d.ts","sourceRoot":"","sources":["../src/repository.decorator.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/repository.decorator.test.js

@@ -0,0 +1,88 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const repository_decorator_1 = require("./repository.decorator");
+describe('Repository decorator', () => {
+    it('should store options with object', () => {
+        let UserRepo = class UserRepo {
+        };
+        UserRepo = __decorate([
+            (0, repository_decorator_1.Repository)({ model: 'User' })
+        ], UserRepo);
+        const meta = Reflect.getMetadata('hazel:repository', UserRepo);
+        expect(meta).toEqual({ model: 'User' });
+    });
+    it('should store options with string shorthand', () => {
+        let PostRepo = class PostRepo {
+        };
+        PostRepo = __decorate([
+            (0, repository_decorator_1.Repository)('Post')
+        ], PostRepo);
+        const meta = Reflect.getMetadata('hazel:repository', PostRepo);
+        expect(meta).toEqual({ model: 'Post' });
+    });
+    it('should implicitly apply @Injectable so @Injectable() is not needed separately', () => {
+        let OrderRepo = class OrderRepo {
+        };
+        OrderRepo = __decorate([
+            (0, repository_decorator_1.Repository)({ model: 'Order' })
+        ], OrderRepo);
+        const injectable = Reflect.getMetadata('hazel:injectable', OrderRepo);
+        expect(injectable).toBeDefined();
+    });
+    it('should forward scope from RepositoryOptions to injectable metadata', () => {
+        let SessionRepo = class SessionRepo {
+        };
+        SessionRepo = __decorate([
+            (0, repository_decorator_1.Repository)({ model: 'Session', scope: 'transient' })
+        ], SessionRepo);
+        const scope = Reflect.getMetadata('hazel:scope', SessionRepo);
+        expect(scope).toBe('transient');
+    });
+});
+describe('InjectRepository', () => {
+    it('should push repository metadata onto target', () => {
+        let UserRepo = class UserRepo {
+        };
+        UserRepo = __decorate([
+            (0, repository_decorator_1.Repository)({ model: 'User' })
+        ], UserRepo);
+        let Consumer = class Consumer {
+            constructor(_repo) { }
+        };
+        Consumer = __decorate([
+            __param(0, (0, repository_decorator_1.InjectRepository)()),
+            __metadata("design:paramtypes", [UserRepo])
+        ], Consumer);
+        const repos = Reflect.getMetadata('hazel:repositories', Consumer);
+        expect(repos).toHaveLength(1);
+        expect(repos[0]).toEqual({ index: 0, model: 'User' });
+    });
+    it('should throw when target repository is not decorated', () => {
+        class NotARepo {
+        }
+        expect(() => {
+            // Class exists only to trigger InjectRepository(); the decorator throws during definition
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            let Consumer = class Consumer {
+                constructor(_repo) { }
+            };
+            Consumer = __decorate([
+                __param(0, (0, repository_decorator_1.InjectRepository)()),
+                __metadata("design:paramtypes", [NotARepo])
+            ], Consumer);
+        }).toThrow(/not decorated with @Repository/);
+    });
+});

package/dist/typeorm.module.test.d.ts

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

package/dist/typeorm.module.test.d.ts.map

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

package/dist/typeorm.module.test.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_module_1 = require("./typeorm.module");
+const typeorm_service_1 = require("./typeorm.service");
+describe('TypeOrmModule', () => {
+    it('should export TypeOrmModule class', () => {
+        expect(typeorm_module_1.TypeOrmModule).toBeDefined();
+    });
+    describe('forRoot', () => {
+        it('should return dynamic module with module, providers, exports', () => {
+            const result = typeorm_module_1.TypeOrmModule.forRoot({
+                type: 'sqlite',
+                database: ':memory:',
+                synchronize: true,
+            });
+            expect(result).toHaveProperty('module', typeorm_module_1.TypeOrmModule);
+            expect(result).toHaveProperty('providers');
+            expect(result).toHaveProperty('exports');
+            expect(Array.isArray(result.providers)).toBe(true);
+            expect(result.providers).toHaveLength(1);
+            expect(result.providers[0]).toMatchObject({
+                provide: typeorm_service_1.TypeOrmService,
+                useFactory: expect.any(Function),
+            });
+            expect(result.exports).toContain(typeorm_service_1.TypeOrmService);
+        });
+        it('should provide TypeOrmService via useFactory returning new DataSource', () => {
+            const result = typeorm_module_1.TypeOrmModule.forRoot({
+                type: 'postgres',
+                host: 'localhost',
+                port: 5432,
+                username: 'u',
+                password: 'p',
+                database: 'd',
+            });
+            const provider = result.providers[0];
+            expect(provider.useFactory).toBeDefined();
+            // useFactory creates DataSource(options) and TypeOrmService; skip calling it to avoid requiring pg driver
+            expect(typeof provider.useFactory).toBe('function');
+        });
+    });
+});

package/dist/typeorm.service.test.d.ts

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

package/dist/typeorm.service.test.d.ts.map

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

package/dist/typeorm.service.test.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_service_1 = require("./typeorm.service");
+describe('TypeOrmService', () => {
+    describe('with provided DataSource', () => {
+        it('should use provided DataSource and initialize/destroy', async () => {
+            const mockDs = {
+                isInitialized: false,
+                initialize: async () => {
+                    mockDs.isInitialized = true;
+                },
+                destroy: async () => {
+                    mockDs.isInitialized = false;
+                },
+                getRepository: jest.fn(() => ({ find: jest.fn() })),
+            };
+            const dataSource = mockDs;
+            const service = new typeorm_service_1.TypeOrmService({ dataSource });
+            expect(service.dataSource).toBe(dataSource);
+            await service.onModuleInit();
+            expect(dataSource.isInitialized).toBe(true);
+            await service.onModuleDestroy();
+            expect(dataSource.isInitialized).toBe(false);
+        });
+        it('should expose getRepository', () => {
+            const mockRepo = { find: jest.fn(), findOne: jest.fn() };
+            const dataSource = {
+                isInitialized: true,
+                getRepository: jest.fn(() => mockRepo),
+            };
+            const service = new typeorm_service_1.TypeOrmService({ dataSource });
+            const repo = service.getRepository('dummy');
+            expect(repo).toBe(mockRepo);
+            expect(typeof repo.find).toBe('function');
+        });
+    });
+    describe('without options or dataSource', () => {
+        const origEnv = process.env.DATABASE_URL;
+        afterEach(() => {
+            process.env.DATABASE_URL = origEnv;
+        });
+        it('should throw when DATABASE_URL is not set', () => {
+            delete process.env.DATABASE_URL;
+            expect(() => new typeorm_service_1.TypeOrmService()).toThrow(/DATABASE_URL|options|dataSource/);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/typeorm",
-  "version": "0.2.0-beta.53",
+  "version": "0.2.0-beta.55",
   "description": "TypeORM integration for HazelJS framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,5 +49,5 @@
   "peerDependencies": {
     "@hazeljs/core": ">=0.2.0-beta.0"
   },
-  "gitHead": "84311f65083627fa53bf2a22f96cd212c196873c"
+  "gitHead": "f2e54f346eea552595a44607999454a9e388cb9e"
 }