celitech-sdk 1.1.71 → 1.1.72

package/.manifest.json

@@ -1,14 +1,14 @@
 {
-  "liblabVersion": "2.1.22",
-  "date": "2024-07-23T14:32:38.632Z",
+  "liblabVersion": "2.1.23",
+  "date": "2024-07-24T16:11:13.332Z",
   "config": {
-    "apiId": 819,
+    "apiId": 936,
     "sdkName": "Celitech",
-    "sdkVersion": "1.1.71",
+    "sdkVersion": "1.1.72",
     "liblabVersion": "2",
     "deliveryMethods": ["zip"],
     "languages": ["typescript"],
-    "apiVersion": "1.1.71",
+    "apiVersion": "1.1.72",
     "specFilePath": "swagger.yaml",
     "languageOptions": {
       "python": {
@@ -26,7 +26,7 @@
         "pypiPackageName": "celitech-sdk",
         "githubRepoName": "CelitechSDKPython",
         "liblabVersion": "2",
-        "sdkVersion": "1.1.71"
+        "sdkVersion": "1.1.72"
       },
       "php": {
         "packageName": "celitech-sdk/sdk",
@@ -41,7 +41,8 @@
           }
         ],
         "githubRepoName": "CelitechSDKPHP",
-        "sdkVersion": "1.1.71"
+        "liblabVersion": "2",
+        "sdkVersion": "1.1.72"
       },
       "typescript": {
         "bundle": false,
@@ -59,9 +60,8 @@
           }
         ],
         "githubRepoName": "CelitechSDKTypeScript",
-        "ignoreFiles": [],
         "liblabVersion": "2",
-        "sdkVersion": "1.1.71"
+        "sdkVersion": "1.1.72"
       }
     },
     "publishing": {
@@ -101,10 +101,10 @@
     },
     "multiTenant": true,
     "hooksLocation": {
-      "bucketKey": "6342/hooks.zip",
+      "bucketKey": "6361/hooks.zip",
       "bucketName": "prod-liblab-api-stack-hooks"
     },
-    "specUrl": "https://prod-liblab-api-stack-specs.s3.us-east-1.amazonaws.com/819/open-api-spec.yaml?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA5P3QKKDKGVNIJ2H7%2F20240723%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20240723T143233Z&X-Amz-Expires=43200&X-Amz-Signature=e60e010fbb2260e633a3b6b6919d9e94ea1120bd4e68b4ff4215e5c4f959f644&X-Amz-SignedHeaders=host&x-id=GetObject",
+    "specUrl": "https://prod-liblab-api-stack-specs.s3.us-east-1.amazonaws.com/936/open-api-spec.yaml?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=AKIA5P3QKKDKGVNIJ2H7%2F20240724%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20240724T161111Z&X-Amz-Expires=43200&X-Amz-Signature=0236628a6da6e1de7697560d1f6376f1176442f3899d75d7185d05b689f6b608&X-Amz-SignedHeaders=host&x-id=GetObject",
     "includeWatermark": false,
     "language": "typescript",
     "deliveryMethod": "zip",
@@ -127,7 +127,6 @@
       }
     ],
     "githubRepoName": "CelitechSDKTypeScript",
-    "ignoreFiles": [],
     "typescriptVersion": "5.3.3",
     "zodVersion": "3.22.0",
     "compilerOptions": {
@@ -227,6 +226,7 @@
     "src/http/handlers/request-validation-handler.ts",
     ".devcontainer/devcontainer.json",
     "src/http/transport/request.ts",
+    "src/http/transport/request-builder.ts",
     "documentation/models/ListDestinationsOkResponse.md",
     "documentation/models/ListPackagesOkResponse.md",
     "documentation/models/GetEsimOkResponse.md",

package/README.md

@@ -1,11 +1,11 @@
-# Celitech TypeScript SDK 1.1.71
+# Celitech TypeScript SDK 1.1.72
 
 Welcome to the Celitech SDK documentation. This guide will help you get started with integrating and using the Celitech SDK in your project.
 
 ## Versions
 
 - API version: `1.1.0`
-- SDK version: `1.1.71`
+- SDK version: `1.1.72`
 
 ## About the API
 

package/documentation/services/PurchasesService.md

@@ -87,8 +87,8 @@ import { Celitech, CreatePurchaseRequest } from 'celitech-sdk';
     email: 'example@domain.com',
     referenceId: 'abc111222333444',
     networkBrand: 'CELITECH',
-    startTime: 2.37,
-    endTime: 8.12,
+    startTime: 8.94,
+    endTime: 5.28,
   };
 
   const { data } = await celitech.purchases.createPurchase(input);
@@ -132,8 +132,8 @@ import { Celitech, TopUpEsimRequest } from 'celitech-sdk';
     endDate: '2023-11-20',
     email: 'example@domain.com',
     referenceId: 'abc111222333444',
-    startTime: 8.12,
-    endTime: 4.35,
+    startTime: 5.74,
+    endTime: 9.23,
   };
 
   const { data } = await celitech.purchases.topUpEsim(input);
@@ -174,8 +174,8 @@ import { Celitech, EditPurchaseRequest } from 'celitech-sdk';
     purchaseId: 'ae471106-c8b4-42cf-b83a-b061291f2922',
     startDate: '2023-11-01',
     endDate: '2023-11-20',
-    startTime: 8.76,
-    endTime: 4.68,
+    startTime: 1.27,
+    endTime: 5.18,
   };
 
   const { data } = await celitech.purchases.editPurchase(input);

package/examples/package.json

@@ -1,6 +1,6 @@
 {
   "name": "Celitech",
-  "version": "1.1.71",
+  "version": "1.1.72",
   "private": true,
   "dependencies": {
     "celitech-sdk": "file:../",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "celitech-sdk",
-  "version": "1.1.71",
+  "version": "1.1.72",
   "description": "Welcome to the CELITECH API documentation!  Useful links: [Homepage](https://www.celitech.com) | [Support email](mailto:support@celitech.com) | [Blog](https://www.celitech.com/blog/) ",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/http/handlers/hook-handler.ts

@@ -20,18 +20,20 @@ export class HookHandler implements RequestHandler {
     const response = await this.next.handle(nextRequest);
 
     if (response.metadata.status < 400) {
-      return await this.hook.afterResponse(request, response, hookParams);
+      return await this.hook.afterResponse(request.toHookRequest(), response, hookParams);
     }
 
-    const error = await this.hook.onError(request, response, hookParams);
+    const error = await this.hook.onError(request.toHookRequest(), response, hookParams);
 
     throw new HttpError(error.metadata, error.error);
   }
 
   private async beforeRequest<T>(request: Request<T>, hookParams: Map<string, string>): Promise<Request<T>> {
-    const hookRequest = await this.hook.beforeRequest(request, hookParams);
+    const hookRequest = request.toHookRequest();
 
-    request.updateFromHookRequest(hookRequest);
+    const newRequest = await this.hook.beforeRequest(hookRequest, hookParams);
+
+    request.updateFromHookRequest(newRequest);
 
     return request;
   }

package/src/http/handlers/response-validation-handler.ts

@@ -57,7 +57,7 @@ export class ResponseValidationHandler implements RequestHandler {
   }
 
   private validate<T>(request: Request<T>, data: any): T {
-    if (request.config.validation?.responseValidation) {
+    if (request.validation?.responseValidation) {
       return request.responseSchema.parse(data);
     }
     return data;

package/src/http/handlers/retry-handler.ts

@@ -10,15 +10,14 @@ export class RetryHandler implements RequestHandler {
       throw new Error('No next handler set in retry handler.');
     }
 
-    const retry = request.getRetry();
-    for (let attempt = 1; attempt <= retry.attempts; attempt++) {
+    for (let attempt = 1; attempt <= request.retry.attempts; attempt++) {
       try {
         return await this.next.handle(request);
       } catch (error: any) {
-        if (!this.shouldRetry(error) || attempt === retry.attempts) {
+        if (!this.shouldRetry(error) || attempt === request.retry.attempts) {
           throw error;
         }
-        await this.delay(retry.delayMs);
+        await this.delay(request.retry.delayMs);
       }
     }
 
@@ -29,7 +28,11 @@ export class RetryHandler implements RequestHandler {
     return error instanceof HttpError && (error.metadata.status >= 500 || error.metadata.status === 408);
   }
 
-  private delay(delayMs: number): Promise<void> {
+  private delay(delayMs: number | undefined): Promise<void> {
+    if (!delayMs) {
+      return Promise.resolve();
+    }
+
     return new Promise((resolve, reject) => {
       setTimeout(() => resolve(), delayMs);
     });

package/src/http/hooks/hook.ts

@@ -1,12 +1,13 @@
 type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 
 export interface HttpRequest {
+  baseUrl: string;
   method: HttpMethod;
   path: string;
-  headers?: Map<string, unknown>;
+  headers: Map<string, unknown>;
   body?: BodyInit;
   abortSignal?: AbortSignal;
-  queryParams?: Map<string, unknown>;
+  queryParams: Map<string, unknown>;
 }
 
 interface HttpMetadata {

package/src/http/serializer.ts

@@ -25,7 +25,7 @@ export function serializeQuery(
   _style = SerializationStyle.FORM,
   explode = true,
 ): string {
-  if (!queryParams || !Object.entries(queryParams)) {
+  if (!queryParams || !Object.entries(queryParams).length) {
     return '';
   }
 
@@ -58,9 +58,12 @@ export function serializeQuery(
   return `?${query}`;
 }
 
-export function serializeHeader(headers?: Record<string, unknown>, explode = false): Record<string, string> {
-  if (!headers) {
-    return {};
+export function serializeHeader(
+  headers?: Record<string, unknown>,
+  explode = false,
+): Record<string, string> | undefined {
+  if (!headers || !Object.entries(headers).length) {
+    return undefined;
   }
 
   return Object.entries(headers).reduce((acc, [key, value]) => {

package/src/http/transport/request-builder.ts

@@ -0,0 +1,145 @@
+import z, { ZodType } from 'zod';
+import { Request, CreateRequestParameters } from './request';
+import { ContentType, HttpMethod, SdkConfig, RequestConfig, RetryOptions, ValidationOptions } from '../types';
+import { Environment } from '../environment';
+
+export class RequestBuilder<T> {
+  private params: CreateRequestParameters<T>;
+
+  constructor() {
+    this.params = {
+      baseUrl: Environment.DEFAULT,
+      method: 'GET',
+      path: '',
+      config: {},
+      responseSchema: z.any(),
+      requestSchema: z.any(),
+      requestContentType: ContentType.Json,
+      responseContentType: ContentType.Json,
+      retry: {
+        attempts: 3,
+        delayMs: 150,
+      },
+      validation: {
+        responseValidation: true,
+      },
+      pathParams: new Map(),
+      queryParams: new Map(),
+      headers: new Map(),
+    };
+  }
+
+  setRetryAttempts(sdkConfig?: SdkConfig, requestConfig?: RequestConfig): RequestBuilder<T> {
+    if (requestConfig?.retry?.attempts !== undefined) {
+      this.params.retry.attempts = requestConfig.retry.attempts;
+    } else if (sdkConfig?.retry?.attempts !== undefined) {
+      this.params.retry.attempts = sdkConfig.retry.attempts;
+    }
+
+    return this;
+  }
+
+  setRetryDelayMs(sdkConfig?: SdkConfig, requestConfig?: RequestConfig): RequestBuilder<T> {
+    if (requestConfig?.retry?.delayMs !== undefined) {
+      this.params.retry.delayMs = requestConfig.retry.delayMs;
+    } else if (sdkConfig?.retry?.delayMs !== undefined) {
+      this.params.retry.delayMs = sdkConfig.retry.delayMs;
+    }
+
+    return this;
+  }
+
+  setResponseValidation(sdkConfig: SdkConfig, requestConfig?: RequestConfig): RequestBuilder<T> {
+    if (requestConfig?.validation?.responseValidation !== undefined) {
+      this.params.validation.responseValidation = requestConfig.validation.responseValidation;
+    } else if (sdkConfig?.validation?.responseValidation !== undefined) {
+      this.params.validation.responseValidation = sdkConfig.validation.responseValidation;
+    }
+
+    return this;
+  }
+
+  setBaseUrl(sdkConfig: SdkConfig): RequestBuilder<T> {
+    if (sdkConfig?.baseUrl !== undefined) {
+      this.params.baseUrl = sdkConfig.baseUrl;
+    }
+
+    return this;
+  }
+
+  setMethod(method: HttpMethod): RequestBuilder<T> {
+    this.params.method = method;
+    return this;
+  }
+
+  setPath(path: string): RequestBuilder<T> {
+    this.params.path = path;
+    return this;
+  }
+
+  setConfig(config: SdkConfig): RequestBuilder<T> {
+    this.params.config = config;
+    return this;
+  }
+
+  setRequestContentType(contentType: ContentType): RequestBuilder<T> {
+    this.params.requestContentType = contentType;
+    return this;
+  }
+
+  setResponseContentType(contentType: ContentType): RequestBuilder<T> {
+    this.params.responseContentType = contentType;
+    return this;
+  }
+
+  setRequestSchema(requestSchema: ZodType): RequestBuilder<T> {
+    this.params.requestSchema = requestSchema;
+    return this;
+  }
+
+  setResponseSchema(responseSchema: ZodType): RequestBuilder<T> {
+    this.params.responseSchema = responseSchema;
+    return this;
+  }
+
+  addBody(body?: any): RequestBuilder<T> {
+    if (body !== undefined) {
+      this.params.body = body;
+    }
+    return this;
+  }
+
+  addPathParam(key: string, value: unknown): RequestBuilder<T> {
+    if (value === undefined) {
+      return this;
+    }
+
+    this.params.pathParams.set(key, value);
+
+    return this;
+  }
+
+  addQueryParam(key: string, value: unknown): RequestBuilder<T> {
+    if (value === undefined) {
+      return this;
+    }
+
+    this.params.queryParams.set(key, value);
+
+    return this;
+  }
+
+  addHeaderParam(key: string, value: unknown): RequestBuilder<T> {
+    if (value === undefined) {
+      return this;
+    }
+
+    this.params.headers.set(key, value);
+
+    return this;
+  }
+
+  public build(): Request<T> {
+    return new Request<T>(this.params);
+  }
+}

package/src/http/transport/request.ts

@@ -1,21 +1,28 @@
 import { ZodType } from 'zod';
-import { ContentType, HttpMethod, SdkConfig, RetryOptions, RequestConfig } from '../types';
+import { ContentType, HttpMethod, SdkConfig, RetryOptions, RequestConfig, ValidationOptions } from '../types';
 import { serializeHeader, serializePath, serializeQuery } from '../serializer';
 import { HttpRequest } from '../hooks/hook';
 
-interface CreateRequestParameters<T> {
+export interface CreateRequestParameters<T> {
+  baseUrl: string;
   method: HttpMethod;
   body?: any;
+  headers: Map<string, unknown>;
+  queryParams: Map<string, unknown>;
+  pathParams: Map<string, unknown>;
   path: string;
   config: SdkConfig;
   responseSchema: ZodType<T, any, any>;
   requestSchema: ZodType;
   requestContentType: ContentType;
   responseContentType: ContentType;
-  requestConfig?: RequestConfig;
+  validation: ValidationOptions;
+  retry: RetryOptions;
 }
 
 export class Request<T> {
+  public baseUrl: string = '';
+
   public headers: Map<string, unknown> = new Map();
 
   public queryParams: Map<string, unknown> = new Map();
@@ -40,23 +47,33 @@ export class Request<T> {
 
   private readonly pathPattern: string;
 
+  public validation: ValidationOptions = {} as any;
+
+  public retry: RetryOptions = {} as any;
+
   constructor(params: CreateRequestParameters<T>) {
+    this.baseUrl = params.baseUrl;
     this.method = params.method;
     this.pathPattern = params.path;
     this.body = params.body;
     this.path = this.constructPath();
     this.config = params.config;
+    this.pathParams = params.pathParams;
+    this.headers = params.headers;
+    this.queryParams = params.queryParams;
     this.responseSchema = params.responseSchema;
     this.requestSchema = params.requestSchema;
     this.requestContentType = params.requestContentType;
     this.responseContentType = params.responseContentType;
-    this.applyRequestConfig(params.requestConfig);
+    this.retry = params.retry;
+    this.validation = params.validation;
   }
 
   addHeaderParam(key: string, value: unknown): void {
     if (value === undefined) {
       return;
     }
+
     this.headers.set(key, value);
   }
 
@@ -64,6 +81,7 @@ export class Request<T> {
     if (value === undefined) {
       return;
     }
+
     this.queryParams.set(key, value);
   }
 
@@ -71,6 +89,7 @@ export class Request<T> {
     if (value === undefined) {
       return;
     }
+
     this.pathParams.set(key, value);
   }
 
@@ -78,14 +97,8 @@ export class Request<T> {
     if (body === undefined) {
       return;
     }
-    this.body = body;
-  }
 
-  getRetry(): Required<RetryOptions> {
-    return {
-      attempts: this.config.retry?.attempts ?? 3,
-      delayMs: this.config.retry?.delayMs ?? 150,
-    };
+    this.body = body;
   }
 
   getFetchArgs(): { url: string; requestInit: RequestInit } {
@@ -94,10 +107,14 @@ export class Request<T> {
       requestInit: {
         method: this.method,
         body: this.body,
-        headers: this.constructHeadersInit(),
       },
     };
 
+    const headersInit = this.constructHeadersInit();
+    if (!!headersInit) {
+      fetchArgs.requestInit['headers'] = headersInit;
+    }
+
     if (this.config.timeout !== undefined) {
       fetchArgs.requestInit = {
         ...fetchArgs.requestInit,
@@ -109,39 +126,28 @@ export class Request<T> {
   }
 
   public updateFromHookRequest(hookRequest: HttpRequest) {
+    this.baseUrl = hookRequest.baseUrl;
     this.method = hookRequest.method;
     this.path = hookRequest.path;
     this.body = hookRequest.body;
-    this.headers = hookRequest.headers || new Map();
-    this.queryParams = hookRequest.queryParams || new Map();
+    this.headers = hookRequest.headers;
+    this.queryParams = hookRequest.queryParams;
   }
 
-  private applyRequestConfig(requestConfig: RequestConfig | undefined) {
-    this.config = {
-      ...this.config,
-      retry: {
-        attempts: requestConfig?.retry?.attempts || this.config.retry?.attempts || 3,
-        delayMs: requestConfig?.retry?.delayMs || this.config.retry?.delayMs || 150,
-      },
-      validation: {
-        responseValidation: this.applyResponseValidation(requestConfig),
-      },
+  public toHookRequest(): HttpRequest {
+    return {
+      baseUrl: this.baseUrl,
+      method: this.method,
+      path: this.path,
+      headers: this.headers,
+      body: this.body,
+      queryParams: this.queryParams,
     };
   }
 
-  private applyResponseValidation(requestConfig: RequestConfig | undefined): boolean {
-    if (requestConfig?.validation?.responseValidation !== undefined) {
-      return requestConfig?.validation.responseValidation;
-    }
-    if (this.config?.validation?.responseValidation !== undefined) {
-      return this.config?.validation?.responseValidation;
-    }
-    return true;
-  }
-
   private constructFullUrl(): string {
     const queryString = this.constructQueryString();
-    return `${this.config.baseUrl}${this.constructPath()}${queryString}`;
+    return `${this.baseUrl}${this.constructPath()}${queryString}`;
   }
 
   private constructPath(): string {
@@ -149,8 +155,11 @@ export class Request<T> {
     return serializePath(this.pathPattern, pathParamsRecord);
   }
 
-  private constructHeadersInit(): HeadersInit {
+  private constructHeadersInit(): HeadersInit | undefined {
     const headerParamsRecord: Record<string, unknown> = this.constructParamsRecord(this.headers);
+    if (Object.entries(headerParamsRecord).length === 0) {
+      return undefined;
+    }
     return serializeHeader(headerParamsRecord);
   }
 

package/src/services/destinations/destinations.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { BaseService } from '../base-service';
 import { ContentType, HttpResponse } from '../../http';
 import { RequestConfig } from '../../http/types';
-import { Request } from '../../http/transport/request';
+import { RequestBuilder } from '../../http/transport/request-builder';
 import { ListDestinationsOkResponse, listDestinationsOkResponseResponse } from './models/list-destinations-ok-response';
 
 export class DestinationsService extends BaseService {
@@ -11,16 +11,19 @@ export class DestinationsService extends BaseService {
    * @returns {Promise<HttpResponse<ListDestinationsOkResponse>>} Successful Response
    */
   async listDestinations(requestConfig?: RequestConfig): Promise<HttpResponse<ListDestinationsOkResponse>> {
-    const request = new Request({
-      method: 'GET',
-      path: '/destinations',
-      config: this.config,
-      responseSchema: listDestinationsOkResponseResponse,
-      requestSchema: z.any(),
-      requestContentType: ContentType.Json,
-      responseContentType: ContentType.Json,
-      requestConfig,
-    });
+    const request = new RequestBuilder<ListDestinationsOkResponse>()
+      .setConfig(this.config)
+      .setBaseUrl(this.config)
+      .setMethod('GET')
+      .setPath('/destinations')
+      .setRequestSchema(z.any())
+      .setResponseSchema(listDestinationsOkResponseResponse)
+      .setRequestContentType(ContentType.Json)
+      .setResponseContentType(ContentType.Json)
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .build();
     return this.client.call<ListDestinationsOkResponse>(request);
   }
 }

package/src/services/destinations/models/destinations.ts

@@ -3,7 +3,7 @@ import { z } from 'zod';
 /**
  * The shape of the model inside the application code - what the users use
  */
-export const destinations: any = z.lazy(() => {
+export const destinations = z.lazy(() => {
   return z.object({
     name: z.string().optional(),
     destination: z.string().optional(),
@@ -24,7 +24,7 @@ export type Destinations = z.infer<typeof destinations>;
  * The shape of the model mapping from the api schema into the application shape.
  * Is equal to application shape if all property names match the api schema
  */
-export const destinationsResponse: any = z.lazy(() => {
+export const destinationsResponse = z.lazy(() => {
   return z
     .object({
       name: z.string().optional(),
@@ -42,7 +42,7 @@ export const destinationsResponse: any = z.lazy(() => {
  * The shape of the model mapping from the application shape into the api schema.
  * Is equal to application shape if all property names match the api schema
  */
-export const destinationsRequest: any = z.lazy(() => {
+export const destinationsRequest = z.lazy(() => {
   return z
     .object({
       name: z.string().nullish(),

package/src/services/destinations/models/list-destinations-ok-response.ts

@@ -4,7 +4,7 @@ import { destinations, destinationsRequest, destinationsResponse } from './desti
 /**
  * The shape of the model inside the application code - what the users use
  */
-export const listDestinationsOkResponse: any = z.lazy(() => {
+export const listDestinationsOkResponse = z.lazy(() => {
   return z.object({
     destinations: z.array(destinations).optional(),
   });
@@ -21,7 +21,7 @@ export type ListDestinationsOkResponse = z.infer<typeof listDestinationsOkRespon
  * The shape of the model mapping from the api schema into the application shape.
  * Is equal to application shape if all property names match the api schema
  */
-export const listDestinationsOkResponseResponse: any = z.lazy(() => {
+export const listDestinationsOkResponseResponse = z.lazy(() => {
   return z
     .object({
       destinations: z.array(destinationsResponse).optional(),
@@ -35,7 +35,7 @@ export const listDestinationsOkResponseResponse: any = z.lazy(() => {
  * The shape of the model mapping from the application shape into the api schema.
  * Is equal to application shape if all property names match the api schema
  */
-export const listDestinationsOkResponseRequest: any = z.lazy(() => {
+export const listDestinationsOkResponseRequest = z.lazy(() => {
   return z.object({ destinations: z.array(destinationsRequest).nullish() }).transform((data) => ({
     destinations: data['destinations'],
   }));