feat: add partial

Author: tiagompalte

.prettierrc

@@ -1,5 +1,7 @@
 {
+  "tabWidth": 2,
+  "printWidth": 80,
   "singleQuote": true,
-  "trailingComma": "all",
+  "trailingComma": "none",
   "semi": false
 }

src/protocols/filter/comparator-operator-enum.ts

@@ -16,5 +16,5 @@ export enum ComparatorOperatorEnum {
   OP_AND = 'OP_AND',
   OP_NOT = 'OP_NOT',
   OP_NOR = 'OP_NOR',
-  OP_OR = 'OP_OR',
+  OP_OR = 'OP_OR'
 }

src/protocols/filter/comparator.ts

@@ -10,7 +10,7 @@ export class Comparator {
     private readonly _operator: ComparatorOperatorEnum,
     private readonly _key: string,
     private readonly _value: any | any[],
-    private readonly _options?: OptionsComparator,
+    private readonly _options?: OptionsComparator
   ) {}
 
   get operator(): ComparatorOperatorEnum {
@@ -48,7 +48,7 @@ export class Comparator {
     operator: ComparatorOperatorEnum,
     key: string,
     value: any | any[],
-    options?: OptionsComparator,
+    options?: OptionsComparator
   ): Comparator => {
     return new Comparator(operator, key, value, options)
   }
@@ -83,7 +83,7 @@ export class Comparator {
   static in = (
     key: string,
     value: any[],
-    options?: OptionsFilter,
+    options?: OptionsFilter
   ): Comparator =>
     Comparator.builder(ComparatorOperatorEnum.IN, key, value, options)
 

src/protocols/filter/filter.ts

@@ -14,7 +14,7 @@ export class Filter {
 
   private addCommand(
     comparator: Comparator | Comparator[],
-    operator: LogicalOperatorEnum,
+    operator: LogicalOperatorEnum
   ): void {
     this._command.push({ comparator, operator })
   }

src/protocols/filter/logical-operator-enum.ts

@@ -2,5 +2,5 @@ export enum LogicalOperatorEnum {
   AND = 'AND',
   NOT = 'NOT',
   NOR = 'NOR',
-  OR = 'OR',
+  OR = 'OR'
 }

src/protocols/repository/base-entity.ts

@@ -1,5 +1,5 @@
 export interface BaseEntity<T> {
-  id?: T
+  id: T
   ativo?: boolean
   dataInclusao?: Date
   dataAtualizacao?: Date

src/protocols/repository/direction-enum.ts

@@ -1,4 +1,4 @@
 export enum DirectionEnum {
   ASC = 1,
-  DESC = -1,
+  DESC = -1
 }

src/protocols/repository/repository.ts

@@ -1,63 +1,83 @@
 import { ResultPaged } from './result-paged'
 import { BaseEntity } from './base-entity'
-import { Filter } from '../filter/filter'
+import { Filter } from '../filter'
 import { Sort } from './sort'
 
 export interface Repository<U, T extends BaseEntity<U>> {
   fieldId(): string
+
   fieldVersion(): string
+
   fieldCreatedAt(): string
+
   fieldUpdatedAt(): string
+
   fieldActive(): string
+
   find(
     filter?: Filter,
     populate?: string | string[],
     sort?: Sort | Sort[],
     includeAll?: boolean,
+    limit?: number
   ): Promise<T[]>
+
   findOne(
     filter?: Filter,
     populate?: string | string[],
     sort?: Sort | Sort[],
-    includeAll?: boolean,
+    includeAll?: boolean
   ): Promise<T>
+
   findById(
     id: U,
     populate?: string | string[],
-    includeAll?: boolean,
+    includeAll?: boolean
   ): Promise<T>
+
   paged(
     first?: number,
     pageSize?: number,
     filter?: Filter,
     populate?: string | string[],
     sort?: Sort | Sort[],
-    includeAll?: boolean,
+    includeAll?: boolean
   ): Promise<ResultPaged<T>>
-  insert(doc: T, populate?: string | string[]): Promise<T>
-  insertMany(docs: T[], populate?: string | string[]): Promise<T[]>
+
+  insert(doc: Partial<T>, populate?: string | string[]): Promise<T>
+
+  insertMany(docs: Partial<T>[], populate?: string | string[]): Promise<T[]>
+
   update(
     id: U,
-    doc: T,
+    doc: Partial<T>,
     populate?: string | string[],
-    includeAll?: boolean,
+    includeAll?: boolean
   ): Promise<T>
+
   updateMany(
     filter: Filter,
-    doc: T,
+    doc: Partial<T>[],
     populate?: string | string[],
-    includeAll?: boolean,
+    includeAll?: boolean
   ): Promise<T[]>
+
   delete(id: U, includeAll?: boolean): Promise<void>
+
   deleteMany(filter?: Filter, includeAll?: boolean): Promise<void>
+
   exists(filter?: Filter, includeAll?: boolean): Promise<boolean>
+
   upsert(
-    doc: T,
+    doc: Partial<T>,
     filter?: Filter,
     populate?: string | string[],
-    includeAll?: boolean,
+    includeAll?: boolean
   ): Promise<T>
+
   count(filter?: Filter, includeAll?: boolean): Promise<number>
-  logicDelete(id: U): Promise<void>
-  logicActive(id: U): Promise<void>
+
+  logicDelete(id: U): Promise<T>
+
+  logicActive(id: U): Promise<T>
 }