version 5.0.0 (#6)

release v5.0.0

* add repository create entity method

* repository map to entity model

* refactor and clean repository

* refactor repository

* update sample

* update README.md

Author: ifaim

.npmignore

@@ -5,4 +5,5 @@ package-lock.json
 tslint.json
 tsconfig.json
 .prettierrc
-sample
+sample
+.github

README.md

@@ -31,7 +31,7 @@ Express Cassandra utilities module for [NestJS](https://github.com/nestjs/nest)
 ## Installation
 
 ```bash
-$ npm i --save @iaminfinity/express-cassandra express-cassandra
+$ npm i --save @iaminfinity/express-cassandra
 ```
 ## Usage
 
@@ -160,6 +160,42 @@ export class PersonService {
 
 ## Using Repository
 
+```typescript
+import { Module } from '@nestjs/common';
+import { ExpressCassandraModule } from '@iaminfinity/express-cassandra';
+import { PhotoService } from './photo.service';
+import { PhotoController } from './photo.controller';
+import { PhotoEntity } from './photo.entity';
+
+@Module({
+  imports: [ExpressCassandraModule.forFeature([PhotoEntity])],
+  providers: [PhotoService],
+  controllers: [PhotoController],
+})
+export class PhotoModule {}
+```
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { InjectRepository, Repository } from '@iaminfinity/express-cassandra';
+import { PhotoEntity } from './photo.entity';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class PersonService {
+  constructor(
+    @InjectRepository(PhotoEntity)
+    private readonly photoRepository: Repository<PhotoEntity>,
+  ) {}
+
+  getById(id: id): Observable<PhotoEntity> {
+    return this.photoRepository.findOne({id});
+  }
+}
+```
+
+## Using Custom Repository
+
 Let's create a repository:
 
 ```typescript
@@ -170,7 +206,7 @@ import { Observable } from 'rxjs';
 @EntityRepository(PhotoEntity)
 export class PhotoRepository extends Repository<PhotoEntity> {
   findById(id: any): Observable<PhotoEntity> {
-    return this.findOne({ id: id }, { raw: true });
+    return this.findOne({ id: id });
   }
 }
 ```
@@ -209,7 +245,7 @@ export class PersonService {
     private readonly photoRepository: PhotoRepository,
   ) {}
 
-  getById(id: id): Observable<PhotoEntity> {
+  getById(id: any): Observable<PhotoEntity> {
     return this.photoRepository.findById(id);
   }
 }

lib/express-casandra-core.module.ts

@@ -68,6 +68,7 @@ export class ExpressCassandraCoreModule implements OnModuleDestroy {
     }
     Logger.log('Closing connection', 'ExpressCassandraModule');
     const connection = this.moduleRef.get(getConnectionToken(this.options));
+    // tslint:disable-next-line:no-unused-expression
     connection && (await connection.closeAsync());
   }
 

lib/express-cassandra.providers.ts

@@ -3,41 +3,48 @@ import {
   getConnectionToken,
   getRepositoryToken,
 } from './utils/cassandra-orm.utils';
-import { EXPRESS_CASSANDRA_MODULE_OPTIONS } from './express-cassandra.constant';
 import { defer } from 'rxjs';
 import { loadModel, Repository } from './orm';
 import { getEntity } from './orm/utils/decorator.utils';
+import { Provider } from '@nestjs/common';
+import { RepositoryFactory } from './orm/repositories/repository.factory';
 
 export function createExpressCassandraProviders(
   entities?: Function[],
   connection?: string | any,
 ) {
   const providerModel = entity => ({
     provide: getModelToken(entity),
-    useFactory: async (client: any, options) => {
+    useFactory: async (client: any) => {
       return await defer(() => loadModel(client, entity)).toPromise();
     },
-    inject: [getConnectionToken(connection), EXPRESS_CASSANDRA_MODULE_OPTIONS],
+    inject: [getConnectionToken(connection)],
   });
 
-  const provideRepository = EntityRepository => {
-    const entitySchema = getEntity(EntityRepository);
+  const provideRepository = entity => ({
+    provide: getRepositoryToken(entity),
+    useFactory: async (model: any) => RepositoryFactory.create(entity, model),
+    inject: [getModelToken(entity)],
+  });
+
+  const provideCustomRepository = EntityRepository => {
+    const entity = getEntity(EntityRepository);
     return {
       provide: getRepositoryToken(EntityRepository),
-      useFactory: async model => createRepository(EntityRepository, model),
-      inject: [getModelToken(entitySchema)],
+      useFactory: async model =>
+        RepositoryFactory.create(entity, model, EntityRepository),
+      inject: [getModelToken(entity)],
     };
   };
 
-  const models = (entities || []).map(entity => {
+  const providers: Provider[] = [];
+  (entities || []).forEach(entity => {
     if (entity.prototype instanceof Repository) {
-      return provideRepository(entity);
+      providers.push(provideCustomRepository(entity));
+      return;
     }
-    return providerModel(entity);
+    providers.push(providerModel(entity), provideRepository(entity));
   });
-  return [...models];
-}
 
-const createRepository = (EntityRepository, model: any): Repository => {
-  return Object.assign(new EntityRepository(), { entity: model });
-};
+  return [...providers];
+}

lib/index.ts

@@ -1,31 +1,23 @@
 import { types } from 'cassandra-driver';
-
-export { doBatchAsync, doBatch } from 'express-cassandra';
 export * from 'cassandra-driver';
-
 export * from './interfaces';
 export * from './express-cassandra.module';
 export * from './utils/express-cassandra.decorator';
 export * from './orm';
 
-export function uuid(id?): types.Uuid {
+export const uuid = (id?: any): types.Uuid => {
   if (!id) {
     return types.Uuid.random();
   }
   if (typeof id === 'string') {
     return types.Uuid.fromString(id);
   }
-  if (id instanceof types.Uuid) {
-    return id;
-  }
   return id;
-}
+};
 
-export function isUuid(id): boolean {
-  return id && id instanceof types.Uuid ? true : false;
-}
+export const isUuid = (id: any): boolean => id && id instanceof types.Uuid;
 
-export function timeuuid(idOrDate?: string | Date): types.TimeUuid {
+export const timeuuid = (idOrDate?: string | Date): types.TimeUuid => {
   if (!idOrDate) {
     return new types.TimeUuid();
   }
@@ -36,15 +28,7 @@ export function timeuuid(idOrDate?: string | Date): types.TimeUuid {
     return types.TimeUuid.fromDate(idOrDate);
   }
   return idOrDate;
-}
-
-export function isTimeUuid(id): boolean {
-  return id && id instanceof types.TimeUuid ? true : false;
-}
-
-export declare function doBatchAsync(queries: string[]): Promise<any>;
+};
 
-export declare function doBatch(
-  queries: string[],
-  callback: (err: Error) => void,
-): void;
+export const isTimeUuid = (id: any): boolean =>
+  id && id instanceof types.TimeUuid;

lib/orm/decorators/column.decorator.ts

@@ -3,7 +3,6 @@ import { addAttribute } from '../utils/decorator.utils';
 
 export function Column(options: ColumnOptions): PropertyDecorator {
   return (target: object, propertyName: string) => {
-    // Reflect.defineMetadata(COLUMN_METADATA, options, target);
     addAttribute(target, propertyName, options);
   };
 }

lib/orm/decorators/entity.decorator.ts

@@ -23,6 +23,5 @@ export function Entity(
 
     setEntityName(target.prototype, name);
     addOptions(target.prototype, options);
-    // Reflect.defineMetadata(ENTITY_METADATA, options, target);
   };
 }