rotacloud 1.0.25 → 1.0.27

package/src/services/roles.service.ts

@@ -5,20 +5,19 @@ import { Service, Options, RequirementsOf } from './index.js';
 import { Role } from '../models/role.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 import { RolesQueryParams } from '../interfaces/query-params/roles-query-params.interface.js';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 
 type RequiredProps = 'name';
 
-class RolesService extends Service {
+export class RolesService extends Service {
   private apiPath = '/roles';
 
   create(data: RequirementsOf<ApiRole, RequiredProps>): Promise<Role>;
   create(
     data: RequirementsOf<ApiRole, RequiredProps>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiRole, any>>;
-  create(data: RequirementsOf<ApiRole, RequiredProps>, options: Options<InternalQueryParams>): Promise<Role>;
-  create(data: RequirementsOf<ApiRole, RequiredProps>, options?: Options<InternalQueryParams>) {
+  create(data: RequirementsOf<ApiRole, RequiredProps>, options: Options): Promise<Role>;
+  create(data: RequirementsOf<ApiRole, RequiredProps>, options?: Options) {
     return super.fetch<ApiRole>({ url: this.apiPath, data, method: 'POST' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -26,26 +25,26 @@ class RolesService extends Service {
   }
 
   get(id: number): Promise<Role>;
-  get(id: number, options: { rawResponse: true; params?: InternalQueryParams }): Promise<AxiosResponse<ApiRole, any>>;
-  get(id: number, options: Options<InternalQueryParams>): Promise<Role>;
-  get(id: number, options?: Options<InternalQueryParams>) {
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiRole, any>>;
+  get(id: number, options: Options): Promise<Role>;
+  get(id: number, options?: Options) {
     return super.fetch<ApiRole>({ url: `${this.apiPath}/${id}` }, options).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new Role(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
     );
   }
 
-  async *list(options?: Options<RolesQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiRole>({ url: this.apiPath }, options)) {
+  async *list(query: RolesQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiRole>({ url: this.apiPath, params: query }, options)) {
       yield new Role(res);
     }
   }
 
-  listAll(): Promise<Role[]>;
-  async listAll() {
+  listAll(query: RolesQueryParams, options?: Options): Promise<Role[]>;
+  async listAll(query: RolesQueryParams, options?: Options) {
     try {
       const roles = [] as Role[];
-      for await (const role of this.list()) {
+      for await (const role of this.list(query, options)) {
         roles.push(role);
       }
       return roles;
@@ -54,18 +53,17 @@ class RolesService extends Service {
     }
   }
 
-  listByPage(options?: Options<RolesQueryParams & InternalQueryParams>) {
-    return super.iterator<ApiRole>({ url: this.apiPath }, options).byPage();
+  listByPage(query: RolesQueryParams, options?: Options) {
+    return super.iterator<ApiRole>({ url: this.apiPath, params: query }, options).byPage();
   }
-
   update(id: number, data: Partial<ApiRole>): Promise<Role>;
   update(
     id: number,
     data: Partial<ApiRole>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiRole, any>>;
-  update(id: number, data: Partial<ApiRole>, options: Options<InternalQueryParams>): Promise<Role>;
-  update(id: number, data: Partial<ApiRole>, options?: Options<InternalQueryParams>) {
+  update(id: number, data: Partial<ApiRole>, options: Options): Promise<Role>;
+  update(id: number, data: Partial<ApiRole>, options?: Options) {
     return super
       .fetch<ApiRole>({
         url: `${this.apiPath}/${id}`,
@@ -79,14 +77,12 @@ class RolesService extends Service {
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true; params?: InternalQueryParams }): Promise<AxiosResponse<any, any>>;
-  delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
-  delete(id: number, options?: Options<InternalQueryParams>) {
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(id: number, options: Options): Promise<number>;
+  delete(id: number, options?: Options) {
     return super.fetch<ApiRole>({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : res.status),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
     );
   }
 }
-
-export { RolesService };

package/src/services/service.ts

@@ -4,9 +4,11 @@ import { Version } from '../version.js';
 
 export type RequirementsOf<T, K extends keyof T> = Required<Pick<T, K>> & Partial<T>;
 
-export interface Options<T> {
+export interface Options {
   rawResponse?: boolean;
-  params?: T;
+  expand?: string[];
+  fields?: string[];
+  limit?: number;
 }
 
 interface PagingObject {
@@ -51,7 +53,7 @@ export abstract class Service<ApiResponse = any> {
     return keyVal;
   }
 
-  public async fetch<T = ApiResponse>(httpOptions: AxiosRequestConfig, options?): Promise<AxiosResponse<T>> {
+  public async fetch<T = ApiResponse>(httpOptions: AxiosRequestConfig, options?: Options): Promise<AxiosResponse<T>> {
     const headers: AxiosRequestHeaders = {
       Authorization: `Bearer ${RotaCloud.config.apiKey}`,
       'SDK-Version': Version.version,
@@ -67,7 +69,12 @@ export abstract class Service<ApiResponse = any> {
       ...httpOptions,
       baseURL: RotaCloud.config.baseUri,
       headers,
-      params: options?.params,
+      params: {
+        expand: options?.expand,
+        fields: options?.fields,
+        limit: options?.limit,
+        ...httpOptions?.params,
+      },
       paramsSerializer: (params) => {
         return params ? this.buildQueryStr(params) : '';
       },
@@ -77,7 +84,10 @@ export abstract class Service<ApiResponse = any> {
     return response;
   }
 
-  private async *listFetch<T = ApiResponse>(reqObject, options?): AsyncGenerator<AxiosResponse<T[], any>> {
+  private async *listFetch<T = ApiResponse>(
+    reqObject: AxiosRequestConfig<T[]>,
+    options?: Options
+  ): AsyncGenerator<AxiosResponse<T[], any>> {
     let running = true;
     do {
       const res = await this.fetch<T[]>(reqObject, options);
@@ -91,17 +101,17 @@ export abstract class Service<ApiResponse = any> {
       } else {
         running = false;
       }
-      yield await res;
+      yield res;
     } while (running);
   }
 
-  private async *listResponses<T = ApiResponse>(reqObject, options?) {
+  private async *listResponses<T = ApiResponse>(reqObject, options?: Options) {
     for await (const res of this.listFetch<T>(reqObject, options)) {
       yield* res.data;
     }
   }
 
-  public iterator<T = ApiResponse>(reqObject, options?) {
+  public iterator<T = ApiResponse>(reqObject, options?: Options) {
     const iterator = this.listResponses<T>(reqObject, options);
     return {
       [Symbol.asyncIterator]() {

package/src/services/shifts.service.ts

@@ -5,20 +5,19 @@ import { Service, Options, RequirementsOf } from './index.js';
 import { Shift } from '../models/shift.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 import { ShiftsQueryParams } from '../interfaces/query-params/shifts-query-params.interface.js';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 
 type RequiredProps = 'end_time' | 'start_time' | 'location';
 
-class ShiftsService extends Service {
+export class ShiftsService extends Service {
   private apiPath = '/shifts';
 
   create(data: RequirementsOf<ApiShift, RequiredProps>): Promise<Shift>;
   create(
     data: RequirementsOf<ApiShift, RequiredProps>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiShift, any>>;
-  create(data: RequirementsOf<ApiShift, RequiredProps>, options: Options<InternalQueryParams>): Promise<Shift>;
-  create(data: RequirementsOf<ApiShift, RequiredProps>, options?: Options<InternalQueryParams>) {
+  create(data: RequirementsOf<ApiShift, RequiredProps>, options: Options): Promise<Shift>;
+  create(data: RequirementsOf<ApiShift, RequiredProps>, options?: Options) {
     return super.fetch<ApiShift>({ url: this.apiPath, data, method: 'POST' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new Shift(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -26,26 +25,26 @@ class ShiftsService extends Service {
   }
 
   get(id: number): Promise<Shift>;
-  get(id: number, options: { rawResponse: true; params?: InternalQueryParams }): Promise<AxiosResponse<ApiShift, any>>;
-  get(id: number, options: Options<InternalQueryParams>): Promise<Shift>;
-  get(id: number, options?: Options<InternalQueryParams>) {
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiShift, any>>;
+  get(id: number, options: Options): Promise<Shift>;
+  get(id: number, options?: Options) {
     return super.fetch<ApiShift>({ url: `${this.apiPath}/${id}` }, options).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new Shift(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
     );
   }
 
-  async *list(options?: Options<ShiftsQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiShift>({ url: this.apiPath }, options)) {
+  async *list(query: ShiftsQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiShift>({ url: this.apiPath, params: query }, options)) {
       yield new Shift(res);
     }
   }
 
-  listAll(): Promise<Shift[]>;
-  async listAll() {
+  listAll(query: ShiftsQueryParams, options?: Options): Promise<Shift[]>;
+  async listAll(query: ShiftsQueryParams, options?: Options) {
     try {
       const shifts = [] as Shift[];
-      for await (const shift of this.list()) {
+      for await (const shift of this.list(query, options)) {
         shifts.push(shift);
       }
       return shifts;
@@ -54,18 +53,18 @@ class ShiftsService extends Service {
     }
   }
 
-  listByPage(options?: Options<ShiftsQueryParams & InternalQueryParams>) {
-    return super.iterator<ApiShift>({ url: this.apiPath }, options).byPage();
+  listByPage(query: ShiftsQueryParams, options?: Options) {
+    return super.iterator<ApiShift>({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<ApiShift>): Promise<Shift>;
   update(
     id: number,
     data: Partial<ApiShift>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiShift, any>>;
-  update(id: number, data: Partial<ApiShift>, options: Options<InternalQueryParams>): Promise<Shift>;
-  update(id: number, data: Partial<ApiShift>, options?: Options<InternalQueryParams>) {
+  update(id: number, data: Partial<ApiShift>, options: Options): Promise<Shift>;
+  update(id: number, data: Partial<ApiShift>, options?: Options) {
     return super
       .fetch<ApiShift>({
         url: `${this.apiPath}/${id}`,
@@ -79,9 +78,9 @@ class ShiftsService extends Service {
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true; params?: InternalQueryParams }): Promise<AxiosResponse<any, any>>;
-  delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
-  delete(id: number, options?: Options<InternalQueryParams>) {
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(id: number, options: Options): Promise<number>;
+  delete(id: number, options?: Options) {
     return super.fetch<ApiShift>({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : res.status),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -89,12 +88,9 @@ class ShiftsService extends Service {
   }
 
   acknowledge(data: number[]): Promise<number>;
-  acknowledge(
-    data: number[],
-    options: { rawResponse: true; params?: InternalQueryParams }
-  ): Promise<AxiosResponse<any, any>>;
-  acknowledge(data: number[], options: Options<InternalQueryParams>): Promise<number>;
-  acknowledge(data: number[], options?: Options<InternalQueryParams>) {
+  acknowledge(data: number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  acknowledge(data: number[], options: Options): Promise<number>;
+  acknowledge(data: number[], options?: Options) {
     return super.fetch<ApiShift>({ url: '/shifts_acknowledged', data, method: 'POST' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : res.status),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -102,12 +98,9 @@ class ShiftsService extends Service {
   }
 
   publish(data: number[]): Promise<number>;
-  publish(
-    data: number[],
-    options: { rawResponse: true; params?: InternalQueryParams }
-  ): Promise<AxiosResponse<any, any>>;
-  publish(data: number[], options: Options<InternalQueryParams>): Promise<number>;
-  publish(data: number[], options?: Options<InternalQueryParams>) {
+  publish(data: number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  publish(data: number[], options: Options): Promise<number>;
+  publish(data: number[], options?: Options) {
     return super.fetch<ApiShift>({ url: '/shifts_published', data, method: 'POST' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : res.status),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -115,17 +108,12 @@ class ShiftsService extends Service {
   }
 
   unpublish(data: number[]): Promise<number>;
-  unpublish(
-    data: number[],
-    options: { rawResponse: true; params?: InternalQueryParams }
-  ): Promise<AxiosResponse<any, any>>;
-  unpublish(data: number[], options: Options<InternalQueryParams>): Promise<number>;
-  unpublish(data: number[], options?: Options<InternalQueryParams>) {
+  unpublish(data: number[], options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  unpublish(data: number[], options: Options): Promise<number>;
+  unpublish(data: number[], options?: Options) {
     return super.fetch<ApiShift>({ url: '/shifts_published', data, method: 'DELETE' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : res.status),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
     );
   }
 }
-
-export { ShiftsService };

package/src/services/users.service.ts

@@ -5,7 +5,6 @@ import { Service, Options, RequirementsOf } from './index.js';
 import { User } from '../models/user.model.js';
 import { ErrorResponse } from '../models/error-response.model.js';
 import { UsersQueryParams } from '../interfaces/query-params/users-query-params.interface.js';
-import { InternalQueryParams } from '../interfaces/query-params/internal-query-params.interface.js';
 
 type RequiredProps = 'first_name' | 'last_name';
 
@@ -15,10 +14,10 @@ class UsersService extends Service {
   create(data: RequirementsOf<ApiUser, RequiredProps>): Promise<User>;
   create(
     data: RequirementsOf<ApiUser, RequiredProps>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiUser, any>>;
-  create(data: RequirementsOf<ApiUser, RequiredProps>, options: Options<InternalQueryParams>): Promise<User>;
-  create(data: RequirementsOf<ApiUser, RequiredProps>, options?: Options<InternalQueryParams>) {
+  create(data: RequirementsOf<ApiUser, RequiredProps>, options: Options): Promise<User>;
+  create(data: RequirementsOf<ApiUser, RequiredProps>, options?: Options) {
     return super.fetch<ApiUser>({ url: this.apiPath, data, method: 'POST' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
@@ -26,26 +25,26 @@ class UsersService extends Service {
   }
 
   get(id: number): Promise<User>;
-  get(id: number, options: { rawResponse: true; params?: InternalQueryParams }): Promise<AxiosResponse<ApiUser, any>>;
-  get(id: number, options: Options<InternalQueryParams>): Promise<User>;
-  get(id: number, options?: Options<InternalQueryParams>) {
+  get(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<ApiUser, any>>;
+  get(id: number, options: Options): Promise<User>;
+  get(id: number, options?: Options) {
     return super.fetch<ApiUser>({ url: `${this.apiPath}/${id}` }, options).then(
       (res) => Promise.resolve(options?.rawResponse ? res : new User(res.data)),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))
     );
   }
 
-  async *list(options?: Options<UsersQueryParams & InternalQueryParams>) {
-    for await (const res of super.iterator<ApiUser>({ url: this.apiPath }, options)) {
+  async *list(query: UsersQueryParams, options?: Options) {
+    for await (const res of super.iterator<ApiUser>({ url: this.apiPath, params: query }, options)) {
       yield new User(res);
     }
   }
 
-  listAll(): Promise<User[]>;
-  async listAll() {
+  listAll(query: UsersQueryParams, options?: Options): Promise<User[]>;
+  async listAll(query: UsersQueryParams, options?: Options) {
     try {
       const users = [] as User[];
-      for await (const user of this.list()) {
+      for await (const user of this.list(query, options)) {
         users.push(user);
       }
       return users;
@@ -54,18 +53,18 @@ class UsersService extends Service {
     }
   }
 
-  listByPage(options?: Options<UsersQueryParams & InternalQueryParams>) {
-    return super.iterator<ApiUser>({ url: this.apiPath }, options).byPage();
+  listByPage(query: UsersQueryParams, options?: Options) {
+    return super.iterator<ApiUser>({ url: this.apiPath, params: query }, options).byPage();
   }
 
   update(id: number, data: Partial<ApiUser>): Promise<User>;
   update(
     id: number,
     data: Partial<ApiUser>,
-    options: { rawResponse: true; params?: InternalQueryParams }
+    options: { rawResponse: true } & Options
   ): Promise<AxiosResponse<ApiUser, any>>;
-  update(id: number, data: Partial<ApiUser>, options: Options<InternalQueryParams>): Promise<User>;
-  update(id: number, data: Partial<ApiUser>, options?: Options<InternalQueryParams>) {
+  update(id: number, data: Partial<ApiUser>, options: Options): Promise<User>;
+  update(id: number, data: Partial<ApiUser>, options?: Options) {
     return super
       .fetch<ApiUser>({
         url: `${this.apiPath}/${id}`,
@@ -79,9 +78,9 @@ class UsersService extends Service {
   }
 
   delete(id: number): Promise<number>;
-  delete(id: number, options: { rawResponse: true; params?: InternalQueryParams }): Promise<AxiosResponse<any, any>>;
-  delete(id: number, options: Options<InternalQueryParams>): Promise<number>;
-  delete(id: number, options?: Options<InternalQueryParams>) {
+  delete(id: number, options: { rawResponse: true } & Options): Promise<AxiosResponse<any, any>>;
+  delete(id: number, options: Options): Promise<number>;
+  delete(id: number, options?: Options) {
     return super.fetch<ApiUser>({ url: `${this.apiPath}/${id}`, method: 'DELETE' }).then(
       (res) => Promise.resolve(options?.rawResponse ? res : res.status),
       (err) => Promise.reject(options?.rawResponse ? err : new ErrorResponse(err))

package/src/version.ts

@@ -1 +1 @@
-export const Version = { version: '1.0.25' };
+export const Version = { version: '1.0.27' };