rotacloud 1.1.1 → 1.2.0

package/src/services/days-off.service.ts

@@ -1,6 +1,6 @@
 import { AxiosResponse } from 'axios';
 import { DaysOff } from '../interfaces/index.js';
-import { Service, Options } from './index.js';
+import { Service, Options, OptionsExtended } from './index.js';
 
 import { DaysOffQueryParams } from '../interfaces/query-params/days-off-query-params.interface.js';
 
@@ -16,25 +16,37 @@ export class DaysOffService extends Service<DaysOff> {
   create(dates: string[], users: number[], options: Options): Promise<number>;
   create(dates: string[], users: number[], options?: Options) {
     return super
-      .fetch({
-        url: this.apiPath,
-        data: {
-          dates,
-          users,
+      .fetch<DaysOff>(
+        {
+          url: this.apiPath,
+          data: {
+            dates,
+            users,
+          },
+          method: 'POST',
         },
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+        options,
+      )
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 
-  async *list(query: DaysOffQueryParams, options?: Options) {
-    for await (const res of super.iterator({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: DaysOffQueryParams): AsyncGenerator<DaysOff>;
+  list<F extends keyof DaysOff>(
+    query: DaysOffQueryParams,
+    options: { fields: F[] } & OptionsExtended<DaysOff>,
+  ): AsyncGenerator<Pick<DaysOff, F>>;
+  list(query?: DaysOffQueryParams, options?: OptionsExtended<DaysOff>): AsyncGenerator<DaysOff>;
+  async *list(query?: DaysOffQueryParams, options?: OptionsExtended<DaysOff>) {
+    yield* super.iterator<DaysOff>({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: DaysOffQueryParams, options?: Options): Promise<DaysOff[]>;
-  async listAll(query: DaysOffQueryParams, options?: Options) {
+  listAll(query?: DaysOffQueryParams): Promise<DaysOff[]>;
+  listAll<F extends keyof DaysOff>(
+    query: DaysOffQueryParams,
+    options: { fields: F[] } & OptionsExtended<DaysOff>,
+  ): Promise<Pick<DaysOff, F>[]>;
+  listAll(query?: DaysOffQueryParams, options?: OptionsExtended<DaysOff>): Promise<DaysOff[]>;
+  async listAll(query?: DaysOffQueryParams, options?: OptionsExtended<DaysOff>) {
     const daysOff = [] as DaysOff[];
     for await (const dayOff of this.list(query, options)) {
       daysOff.push(dayOff);
@@ -42,23 +54,32 @@ export class DaysOffService extends Service<DaysOff> {
     return daysOff;
   }
 
-  listByPage(query: DaysOffQueryParams, options?: Options) {
+  listByPage(query?: DaysOffQueryParams): AsyncGenerator<AxiosResponse<DaysOff[]>>;
+  listByPage<F extends keyof DaysOff>(
+    query: DaysOffQueryParams,
+    options: { fields: F[] } & OptionsExtended<DaysOff>,
+  ): AsyncGenerator<AxiosResponse<Pick<DaysOff, F>[]>>;
+  listByPage(query?: DaysOffQueryParams, options?: OptionsExtended<DaysOff>): AsyncGenerator<AxiosResponse<DaysOff[]>>;
+  listByPage(query?: DaysOffQueryParams, options?: OptionsExtended<DaysOff>) {
     return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   delete(dates: string[], users: number[]): Promise<number>;
-  delete(dates: string[], users: number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(dates: string[], users: number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   delete(dates: string[], users: number[], options: Options): Promise<number>;
   delete(dates: string[], users: number[], options?: Options) {
     return super
-      .fetch({
-        url: this.apiPath,
-        method: 'DELETE',
-        data: {
-          dates,
-          users,
+      .fetch<void>(
+        {
+          url: this.apiPath,
+          method: 'DELETE',
+          data: {
+            dates,
+            users,
+          },
         },
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+        options,
+      )
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

package/src/services/groups.service.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse } from 'axios';
 import { Group } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { GroupsQueryParams } from '../interfaces/query-params/groups-query-params.interface.js';
 
 type RequiredProps = 'name';
 
-export class GroupsService extends Service {
+export class GroupsService extends Service<Group> {
   private apiPath = '/groups';
 
   create(data: RequirementsOf<Group, RequiredProps>): Promise<Group>;
@@ -17,27 +17,41 @@ export class GroupsService extends Service {
   create(data: RequirementsOf<Group, RequiredProps>, options: Options): Promise<Group>;
   create(data: RequirementsOf<Group, RequiredProps>, options?: Options) {
     return super
-      .fetch<Group>({ url: this.apiPath, data, method: 'POST' })
+      .fetch({ url: this.apiPath, data, method: 'POST' })
       .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<Group>;
-  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Group, any>>;
-  get(id: number, options: Options): Promise<Group>;
-  get(id: number, options?: Options) {
+  get<F extends keyof Group>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Group>,
+  ): Promise<AxiosResponse<Pick<Group, F>>>;
+  get<F extends keyof Group>(id: number, options: { fields: F[] } & OptionsExtended<Group>): Promise<Pick<Group, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Group>>;
+  get(id: number, options?: OptionsExtended<Group>): Promise<Group>;
+  get(id: number, options?: OptionsExtended<Group>) {
     return super
       .fetch<Group>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query?: GroupsQueryParams, options?: Options) {
-    for await (const res of super.iterator<Group>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: GroupsQueryParams): AsyncGenerator<Group>;
+  list<F extends keyof Group>(
+    query: GroupsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Group>,
+  ): AsyncGenerator<Pick<Group, F>>;
+  list(query?: GroupsQueryParams, options?: OptionsExtended<Group>): AsyncGenerator<Group>;
+  async *list(query?: GroupsQueryParams, options?: OptionsExtended<Group>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query?: GroupsQueryParams, options?: Options): Promise<Group[]>;
-  async listAll(query: GroupsQueryParams, options?: Options) {
+  listAll(query?: GroupsQueryParams): Promise<Group[]>;
+  listAll<F extends keyof Group>(
+    query: GroupsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Group>,
+  ): Promise<Pick<Group, F>[]>;
+  listAll(query?: GroupsQueryParams, options?: OptionsExtended<Group>): Promise<Group[]>;
+  async listAll(query?: GroupsQueryParams, options?: OptionsExtended<Group>) {
     const groups = [] as Group[];
     for await (const group of this.list(query, options)) {
       groups.push(group);
@@ -45,8 +59,14 @@ export class GroupsService extends Service {
     return groups;
   }
 
-  listByPage(query?: GroupsQueryParams, options?: Options) {
-    return super.iterator<Group>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query?: GroupsQueryParams): AsyncGenerator<AxiosResponse<Group[]>>;
+  listByPage<F extends keyof Group>(
+    query: GroupsQueryParams,
+    options: { fields: F[] } & OptionsExtended<Group>,
+  ): AsyncGenerator<AxiosResponse<Pick<Group, F>[]>>;
+  listByPage(query?: GroupsQueryParams, options?: OptionsExtended<Group>): AsyncGenerator<AxiosResponse<Group[]>>;
+  listByPage(query?: GroupsQueryParams, options?: OptionsExtended<Group>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<Group>): Promise<Group>;
@@ -58,20 +78,20 @@ export class GroupsService extends Service {
   update(id: number, data: Partial<Group>, options: Options): Promise<Group>;
   update(id: number, data: Partial<Group>, options?: Options) {
     return super
-      .fetch<Group>({
+      .fetch({
         url: `${this.apiPath}/${id}`,
         data,
         method: 'POST',
       })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<Group>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

package/src/services/index.ts

@@ -18,6 +18,7 @@ export * from './settings.service.js';
 export * from './shifts.service.js';
 export * from './terminals.service.js';
 export * from './terminals-active.service.js';
+export * from './time-zone.service.js';
 export * from './toil-accruals.service.js';
 export * from './toil-allowance.service.js';
 export * from './users-clock-in.service.js';

package/src/services/leave-embargoes.service.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse } from 'axios';
 import { LeaveEmbargo } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { LeaveEmbargoesQueryParams } from '../rotacloud.js';
 
 type RequiredProps = 'start_date' | 'end_date' | 'users';
 
-export class LeaveEmbargoesService extends Service {
+export class LeaveEmbargoesService extends Service<LeaveEmbargo> {
   private apiPath = '/leave_embargoes';
 
   create(data: RequirementsOf<LeaveEmbargo, RequiredProps>): Promise<LeaveEmbargo>;
@@ -17,27 +17,44 @@ export class LeaveEmbargoesService extends Service {
   create(data: RequirementsOf<LeaveEmbargo, RequiredProps>, options: Options): Promise<LeaveEmbargo>;
   create(data: RequirementsOf<LeaveEmbargo, RequiredProps>, options?: Options) {
     return super
-      .fetch<LeaveEmbargo>({ url: this.apiPath, data, method: 'POST' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<LeaveEmbargo>({ url: this.apiPath, data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<LeaveEmbargo>;
-  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<LeaveEmbargo, any>>;
-  get(id: number, options: Options): Promise<LeaveEmbargo>;
-  get(id: number, options?: Options) {
+  get<F extends keyof LeaveEmbargo>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<LeaveEmbargo>,
+  ): Promise<AxiosResponse<Pick<LeaveEmbargo, F>>>;
+  get<F extends keyof LeaveEmbargo>(
+    id: number,
+    options: { fields: F[] } & OptionsExtended<LeaveEmbargo>,
+  ): Promise<Pick<LeaveEmbargo, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<LeaveEmbargo>>;
+  get(id: number, options?: OptionsExtended<LeaveEmbargo>): Promise<LeaveEmbargo>;
+  get(id: number, options?: OptionsExtended<LeaveEmbargo>) {
     return super
       .fetch<LeaveEmbargo>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query: LeaveEmbargoesQueryParams, options?: Options) {
-    for await (const res of super.iterator<LeaveEmbargo>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: LeaveEmbargoesQueryParams): AsyncGenerator<LeaveEmbargo>;
+  list<F extends keyof LeaveEmbargo>(
+    query: LeaveEmbargoesQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveEmbargo>,
+  ): AsyncGenerator<Pick<LeaveEmbargo, F>>;
+  list(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>): AsyncGenerator<LeaveEmbargo>;
+  async *list(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: LeaveEmbargoesQueryParams, options?: Options): Promise<LeaveEmbargo[]>;
-  async listAll(query: LeaveEmbargoesQueryParams, options?: Options) {
+  listAll(query?: LeaveEmbargoesQueryParams): Promise<LeaveEmbargo[]>;
+  listAll<F extends keyof LeaveEmbargo>(
+    query: LeaveEmbargoesQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveEmbargo>,
+  ): Promise<Pick<LeaveEmbargo, F>[]>;
+  listAll(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>): Promise<LeaveEmbargo[]>;
+  async listAll(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>) {
     const leave = [] as LeaveEmbargo[];
     for await (const leaveEmbargoRecord of this.list(query, options)) {
       leave.push(leaveEmbargoRecord);
@@ -45,8 +62,17 @@ export class LeaveEmbargoesService extends Service {
     return leave;
   }
 
-  listByPage(query: LeaveEmbargoesQueryParams, options?: Options) {
-    return super.iterator<LeaveEmbargo>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query?: LeaveEmbargoesQueryParams): AsyncGenerator<AxiosResponse<LeaveEmbargo[]>>;
+  listByPage<F extends keyof LeaveEmbargo>(
+    query: LeaveEmbargoesQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveEmbargo>,
+  ): AsyncGenerator<AxiosResponse<Pick<LeaveEmbargo, F>[]>>;
+  listByPage(
+    query: LeaveEmbargoesQueryParams,
+    options?: OptionsExtended<LeaveEmbargo>,
+  ): AsyncGenerator<AxiosResponse<LeaveEmbargo[]>>;
+  listByPage(query?: LeaveEmbargoesQueryParams, options?: OptionsExtended<LeaveEmbargo>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<LeaveEmbargo>): Promise<LeaveEmbargo>;
@@ -58,20 +84,23 @@ export class LeaveEmbargoesService extends Service {
   update(id: number, data: Partial<LeaveEmbargo>, options: Options): Promise<LeaveEmbargo>;
   update(id: number, data: Partial<LeaveEmbargo>, options?: Options) {
     return super
-      .fetch<LeaveEmbargo>({
-        url: `${this.apiPath}/${id}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<LeaveEmbargo>(
+        {
+          url: `${this.apiPath}/${id}`,
+          data,
+          method: 'POST',
+        },
+        options,
+      )
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<LeaveEmbargo>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

package/src/services/leave-request.service.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse } from 'axios';
 import { LeaveRequest } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { LeaveRequestsQueryParams } from '../interfaces/query-params/leave-requests-query-params.interface.js';
 
 type RequiredProps = 'start_date' | 'end_date' | 'type' | 'user';
 
-export class LeaveRequestService extends Service {
+export class LeaveRequestService extends Service<LeaveRequest> {
   private apiPath = '/leave_requests';
 
   create(data: RequirementsOf<LeaveRequest, RequiredProps>): Promise<LeaveRequest>;
@@ -25,26 +25,43 @@ export class LeaveRequestService extends Service {
         },
         options,
       )
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   get(id: number): Promise<LeaveRequest>;
-  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<LeaveRequest, any>>;
-  get(id: number, options: Options): Promise<LeaveRequest>;
-  get(id: number, options?: Options) {
+  get<F extends keyof LeaveRequest>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<LeaveRequest>,
+  ): Promise<AxiosResponse<Pick<LeaveRequest, F>>>;
+  get<F extends keyof LeaveRequest>(
+    id: number,
+    options: { fields: F[] } & OptionsExtended<LeaveRequest>,
+  ): Promise<Pick<LeaveRequest, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<LeaveRequest>>;
+  get(id: number, options?: OptionsExtended<LeaveRequest>): Promise<LeaveRequest>;
+  get(id: number, options?: OptionsExtended<LeaveRequest>) {
     return super
       .fetch<LeaveRequest>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query?: LeaveRequestsQueryParams, options?: Options) {
-    for await (const res of super.iterator<LeaveRequest>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: LeaveRequestsQueryParams): AsyncGenerator<LeaveRequest>;
+  list<F extends keyof LeaveRequest>(
+    query: LeaveRequestsQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveRequest>,
+  ): AsyncGenerator<Pick<LeaveRequest, F>>;
+  list(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>): AsyncGenerator<LeaveRequest>;
+  async *list(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query?: LeaveRequestsQueryParams, options?: Options): Promise<LeaveRequest[]>;
-  async listAll(query: LeaveRequestsQueryParams, options?: Options) {
+  listAll(query?: LeaveRequestsQueryParams): Promise<LeaveRequest[]>;
+  listAll<F extends keyof LeaveRequest>(
+    query: LeaveRequestsQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveRequest>,
+  ): Promise<Pick<LeaveRequest, F>[]>;
+  listAll(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>): Promise<LeaveRequest[]>;
+  async listAll(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>) {
     const leave = [] as LeaveRequest[];
     for await (const leaveRequestRecord of this.list(query, options)) {
       leave.push(leaveRequestRecord);
@@ -52,8 +69,17 @@ export class LeaveRequestService extends Service {
     return leave;
   }
 
-  listByPage(query?: LeaveRequestsQueryParams, options?: Options) {
-    return super.iterator<LeaveRequest>({ url: `${this.apiPath}`, params: query }, options).byPage();
+  listByPage(query?: LeaveRequestsQueryParams): AsyncGenerator<AxiosResponse<LeaveRequest[]>>;
+  listByPage<F extends keyof LeaveRequest>(
+    query: LeaveRequestsQueryParams,
+    options: { fields: F[] } & OptionsExtended<LeaveRequest>,
+  ): AsyncGenerator<AxiosResponse<Pick<LeaveRequest, F>[]>>;
+  listByPage(
+    query: LeaveRequestsQueryParams,
+    options?: OptionsExtended<LeaveRequest>,
+  ): AsyncGenerator<AxiosResponse<LeaveRequest[]>>;
+  listByPage(query?: LeaveRequestsQueryParams, options?: OptionsExtended<LeaveRequest>) {
+    return super.iterator({ url: `${this.apiPath}`, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<LeaveRequest>): Promise<LeaveRequest>;
@@ -65,20 +91,23 @@ export class LeaveRequestService extends Service {
   update(id: number, data: Partial<LeaveRequest>, options: Options): Promise<LeaveRequest>;
   update(id: number, data: Partial<LeaveRequest>, options?: Options) {
     return super
-      .fetch<LeaveRequest>({
-        url: `${this.apiPath}/${id}`,
-        data,
-        method: 'POST',
-      })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .fetch<LeaveRequest>(
+        {
+          url: `${this.apiPath}/${id}`,
+          data,
+          method: 'POST',
+        },
+        options,
+      )
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<LeaveRequest, any>>;
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<LeaveRequest>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' }, options)
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }

package/src/services/leave.service.ts

@@ -1,12 +1,12 @@
 import { AxiosResponse } from 'axios';
-import { Leave, LeaveType } from '../interfaces/index.js';
-import { Service, Options, RequirementsOf } from './index.js';
+import { Leave } from '../interfaces/index.js';
+import { Service, Options, RequirementsOf, OptionsExtended } from './index.js';
 
 import { LeaveQueryParams } from '../interfaces/query-params/leave-query-params.interface.js';
 
 type RequiredProps = 'users' | 'type' | 'start_date' | 'end_date';
 
-export class LeaveService extends Service {
+export class LeaveService extends Service<Leave> {
   private apiPath = '/leave';
 
   create(data: RequirementsOf<Leave, RequiredProps>): Promise<Leave[]>;
@@ -17,27 +17,41 @@ export class LeaveService extends Service {
   create(data: RequirementsOf<Leave, RequiredProps>, options: Options): Promise<Leave[]>;
   create(data: RequirementsOf<Leave, RequiredProps>, options?: Options) {
     return super
-      .fetch<Leave[]>({ url: this.apiPath, data, method: 'POST' }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : [...res.data.map((leave) => leave)]));
+      .fetch({ url: this.apiPath, data, method: 'POST' }, options)
+      .then((res) => (options?.rawResponse ? res : [...res.data.map((leave) => leave)]));
   }
 
   get(id: number): Promise<Leave>;
-  get(id: number, options: { rawResponse: true }): Promise<AxiosResponse<Leave, any>>;
-  get(id: number, options: Options): Promise<Leave>;
-  get(id: number, options?: Options) {
+  get<F extends keyof Leave>(
+    id: number,
+    options: { fields: F[]; rawResponse: true } & OptionsExtended<Leave>,
+  ): Promise<AxiosResponse<Pick<Leave, F>>>;
+  get<F extends keyof Leave>(id: number, options: { fields: F[] } & OptionsExtended<Leave>): Promise<Pick<Leave, F>>;
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Leave>>;
+  get(id: number, options?: OptionsExtended<Leave>): Promise<Leave>;
+  get(id: number, options?: OptionsExtended<Leave>) {
     return super
       .fetch<Leave>({ url: `${this.apiPath}/${id}` }, options)
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
-  async *list(query: LeaveQueryParams, options?: Options) {
-    for await (const res of super.iterator<Leave>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
+  list(query?: LeaveQueryParams): AsyncGenerator<Leave>;
+  list<F extends keyof Leave>(
+    query: LeaveQueryParams,
+    options: { fields: F[] } & OptionsExtended<Leave>,
+  ): AsyncGenerator<Pick<Leave, F>>;
+  list(query?: LeaveQueryParams, options?: OptionsExtended<Leave>): AsyncGenerator<Leave>;
+  async *list(query?: LeaveQueryParams, options?: OptionsExtended<Leave>) {
+    yield* super.iterator({ url: this.apiPath, params: query }, options);
   }
 
-  listAll(query: LeaveQueryParams, options?: Options): Promise<Leave[]>;
-  async listAll(query: LeaveQueryParams, options?: Options) {
+  listAll(query?: LeaveQueryParams): Promise<Leave[]>;
+  listAll<F extends keyof Leave>(
+    query: LeaveQueryParams,
+    options: { fields: F[] } & OptionsExtended<Leave>,
+  ): Promise<Pick<Leave, F>[]>;
+  listAll(query?: LeaveQueryParams, options?: OptionsExtended<Leave>): Promise<Leave[]>;
+  async listAll(query?: LeaveQueryParams, options?: OptionsExtended<Leave>) {
     const leave = [] as Leave[];
     for await (const leaveRecord of this.list(query, options)) {
       leave.push(leaveRecord);
@@ -45,14 +59,14 @@ export class LeaveService extends Service {
     return leave;
   }
 
-  async *listLeaveTypes(query: LeaveQueryParams, options?: Options) {
-    for await (const res of super.iterator<LeaveType>({ url: this.apiPath, params: query }, options)) {
-      yield res;
-    }
-  }
-
-  listByPage(query: LeaveQueryParams, options?: Options) {
-    return super.iterator<Leave>({ url: this.apiPath, params: query }, options).byPage();
+  listByPage(query?: LeaveQueryParams): AsyncGenerator<AxiosResponse<Leave[]>>;
+  listByPage<F extends keyof Leave>(
+    query: LeaveQueryParams,
+    options: { fields: F[] } & OptionsExtended<Leave>,
+  ): AsyncGenerator<AxiosResponse<Pick<Leave, F>[]>>;
+  listByPage(query?: LeaveQueryParams, options?: OptionsExtended<Leave>): AsyncGenerator<AxiosResponse<Leave[]>>;
+  listByPage(query?: LeaveQueryParams, options?: OptionsExtended<Leave>) {
+    return super.iterator({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<Leave>): Promise<Leave>;
@@ -72,15 +86,15 @@ export class LeaveService extends Service {
         },
         options,
       )
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.data));
+      .then((res) => (options?.rawResponse ? res : res.data));
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<Leave, any>>;
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<void>>;
   delete(id: number, options: Options): Promise<number>;
   delete(id: number, options?: Options) {
     return super
-      .fetch<Leave>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
-      .then((res) => Promise.resolve(options?.rawResponse ? res : res.status));
+      .fetch<void>({ url: `${this.apiPath}/${id}`, method: 'DELETE' })
+      .then((res) => (options?.rawResponse ? res : res.status));
   }
 }