celitech-sdk 1.1.84 → 1.1.86

package/src/http/serializer.ts

@@ -1,183 +0,0 @@
-export enum SerializationStyle {
-  SIMPLE = 'simple',
-  LABEL = 'label',
-  MATRIX = 'matrix',
-  FORM = 'form',
-  SPACE_DELIMITED = 'space_delimited',
-  PIPE_DELIMITED = 'pipe_delimited',
-  DEEP_OBJECT = 'deep_object',
-}
-
-export function serializePath(
-  pathPattern: string,
-  pathArguments: Record<string, unknown>,
-  style = SerializationStyle.SIMPLE,
-  explode = false,
-): string {
-  return Object.entries(pathArguments).reduce((acc, [key, value]) => {
-    const replaceValue = getPathReplaceValue(value, key, style, explode);
-    return acc.replace(`{${key}}`, `${replaceValue}`);
-  }, pathPattern);
-}
-
-export function serializeQuery(
-  queryParams?: Record<string, unknown>,
-  _style = SerializationStyle.FORM,
-  explode = true,
-): string {
-  if (!queryParams || !Object.entries(queryParams).length) {
-    return '';
-  }
-
-  // only style = form is supported for now
-  const query = Object.entries(queryParams)
-    .map(([key, value]) => {
-      if (Array.isArray(value)) {
-        if (explode) {
-          return value.map((v) => `${key}=${encode(v)}`).join('&');
-        } else {
-          return `${key}=${value.map(encode).join(',')}`;
-        }
-      } else if (isNonNullObject(value)) {
-        if (explode) {
-          return Object.entries(value)
-            .map(([k, v]) => `${k}=${encode(v)}`)
-            .join('&');
-        } else {
-          return `${key}=${Object.entries(value)
-            .map(([k, v]) => `${k},${encode(v)}`)
-            .join(',')}`;
-        }
-      } else if (isPrimitive(value)) {
-        return `${key}=${encode(value)}`;
-      }
-      return '';
-    })
-    .join('&');
-
-  return `?${query}`;
-}
-
-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]) => {
-    if (Array.isArray(value)) {
-      return { ...acc, [key]: value.join(',') };
-    }
-    if (isNonNullObject(value)) {
-      const serializedObject = Object.entries(value)
-        .map(([objectKey, objectValue]) => {
-          return explode ? `${objectKey}=${objectValue}` : `${objectKey},${objectValue}`;
-        })
-        .join(',');
-
-      return { ...acc, [key]: serializedObject };
-    }
-
-    if (isPrimitive(value)) {
-      return { ...acc, [key]: `${value}` };
-    }
-    return acc;
-  }, {});
-}
-
-function getPathReplaceValue<T>(value: T, key: string, style: SerializationStyle, explode: boolean): string {
-  if (Array.isArray(value)) {
-    return serializePathArray(value, key, style, explode);
-  }
-
-  if (isNonNullObject(value)) {
-    return serializePathObject(value, key, style, explode);
-  }
-
-  if (style === SerializationStyle.LABEL) {
-    return `.${encode(`${value}`)}`;
-  }
-
-  if (style === SerializationStyle.MATRIX) {
-    return `;${encode(`${value}`)}`;
-  }
-
-  return encode(`${value}`);
-}
-
-function getPathPrefix(style: SerializationStyle, explode: boolean, key: string): string {
-  if (style === SerializationStyle.LABEL) {
-    return '.';
-  }
-  if (style === SerializationStyle.MATRIX) {
-    return explode ? `;` : `;${key}=`;
-  }
-  return '';
-}
-
-function serializePathObject<T extends object>(
-  value: T,
-  key: string,
-  style: SerializationStyle,
-  explode: boolean,
-): string {
-  const delimiter = getPathDelimiter(style, explode);
-  const serialized = Object.entries(value)
-    .map(([k, v]) => {
-      const joinCharacter = explode ? '=' : delimiter;
-      const sanitized = encode(v);
-      return `${k}${joinCharacter}${sanitized}`;
-    })
-    .join(delimiter);
-
-  const prefix = getPathPrefix(style, explode, key);
-
-  return `${prefix}${serialized}`;
-}
-
-function serializePathArray(
-  array: (string | number | boolean)[],
-  key: string,
-  style: SerializationStyle,
-  explode: boolean,
-): string {
-  const sanitized = array.map(encode);
-  if (style === SerializationStyle.LABEL) {
-    return `.${sanitized.join(explode ? '.' : ',')}`;
-  }
-  if (style === SerializationStyle.MATRIX) {
-    if (explode) {
-      return `;${sanitized.map((sanitizedValue) => `${key}=${sanitizedValue}`).join(';')}`;
-    }
-    return `;${key}=${sanitized.join(',')}`;
-  }
-
-  return sanitized.join(',');
-}
-
-function encode(value: string | number | boolean): string {
-  return encodeURIComponent(value);
-}
-
-function getPathDelimiter(style: SerializationStyle, explode: boolean): string {
-  if (!explode || style === SerializationStyle.SIMPLE) {
-    return ',';
-  }
-  if (style === SerializationStyle.LABEL) {
-    return '.';
-  }
-  if (style === SerializationStyle.MATRIX) {
-    return ';';
-  }
-  return ',';
-}
-
-function isPrimitive(value: unknown): value is string | number | boolean {
-  return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
-}
-
-function isNonNullObject(value: unknown): value is object {
-  return typeof value === 'object' && value !== null;
-}

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

@@ -1,145 +0,0 @@
-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,178 +0,0 @@
-import { ZodType } from 'zod';
-import { ContentType, HttpMethod, SdkConfig, RetryOptions, RequestConfig, ValidationOptions } from '../types';
-import { serializeHeader, serializePath, serializeQuery } from '../serializer';
-import { HttpRequest } from '../hooks/hook';
-
-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;
-  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();
-
-  public pathParams: Map<string, unknown> = new Map();
-
-  public body?: any;
-
-  public method: HttpMethod;
-
-  public path: string;
-
-  public config: SdkConfig;
-
-  public responseSchema: ZodType<T, any, any>;
-
-  public requestSchema: ZodType;
-
-  public requestContentType: ContentType;
-
-  public responseContentType: ContentType;
-
-  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.retry = params.retry;
-    this.validation = params.validation;
-  }
-
-  addHeaderParam(key: string, value: unknown): void {
-    if (value === undefined) {
-      return;
-    }
-
-    this.headers.set(key, value);
-  }
-
-  addQueryParam(key: string, value: unknown): void {
-    if (value === undefined) {
-      return;
-    }
-
-    this.queryParams.set(key, value);
-  }
-
-  addPathParam(key: string, value: unknown): void {
-    if (value === undefined) {
-      return;
-    }
-
-    this.pathParams.set(key, value);
-  }
-
-  addBody(body: any): void {
-    if (body === undefined) {
-      return;
-    }
-
-    this.body = body;
-  }
-
-  getFetchArgs(): { url: string; requestInit: RequestInit } {
-    const fetchArgs: { url: string; requestInit: RequestInit } = {
-      url: this.constructFullUrl(),
-      requestInit: {
-        method: this.method,
-        body: this.body,
-      },
-    };
-
-    const headersInit = this.constructHeadersInit();
-    if (!!headersInit) {
-      fetchArgs.requestInit['headers'] = headersInit;
-    }
-
-    if (this.config.timeout !== undefined) {
-      fetchArgs.requestInit = {
-        ...fetchArgs.requestInit,
-        signal: AbortSignal.timeout(this.config.timeout),
-      };
-    }
-
-    return fetchArgs;
-  }
-
-  public updateFromHookRequest(hookRequest: HttpRequest) {
-    this.baseUrl = hookRequest.baseUrl;
-    this.method = hookRequest.method;
-    this.path = hookRequest.path;
-    this.body = hookRequest.body;
-    this.headers = hookRequest.headers;
-    this.queryParams = hookRequest.queryParams;
-  }
-
-  public toHookRequest(): HttpRequest {
-    return {
-      baseUrl: this.baseUrl,
-      method: this.method,
-      path: this.path,
-      headers: this.headers,
-      body: this.body,
-      queryParams: this.queryParams,
-    };
-  }
-
-  private constructFullUrl(): string {
-    const queryString = this.constructQueryString();
-    return `${this.baseUrl}${this.constructPath()}${queryString}`;
-  }
-
-  private constructPath(): string {
-    const pathParamsRecord: Record<string, unknown> = this.constructParamsRecord(this.pathParams);
-    return serializePath(this.pathPattern, pathParamsRecord);
-  }
-
-  private constructHeadersInit(): HeadersInit | undefined {
-    const headerParamsRecord: Record<string, unknown> = this.constructParamsRecord(this.headers);
-    if (Object.entries(headerParamsRecord).length === 0) {
-      return undefined;
-    }
-    return serializeHeader(headerParamsRecord);
-  }
-
-  private constructQueryString(): string {
-    const queryParamsRecord: Record<string, unknown> = this.constructParamsRecord(this.queryParams);
-    return serializeQuery(queryParamsRecord);
-  }
-
-  private constructParamsRecord(params: Map<string, unknown>): Record<string, unknown> {
-    const record: Record<string, unknown> = {};
-    params.forEach((val, key) => {
-      record[key] = val;
-    });
-    return record;
-  }
-}

package/src/http/types.ts

@@ -1,70 +0,0 @@
-import { ZodType } from 'zod';
-import { Environment } from './environment';
-import { Request } from './transport/request';
-
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-
-export interface SdkConfig {
-  baseUrl?: string;
-  environment?: Environment;
-  timeout?: number;
-  clientId?: string;
-  clientSecret?: string;
-  retry?: RetryOptions;
-  validation?: ValidationOptions;
-}
-
-export interface HttpMetadata {
-  status: number;
-  statusText: string;
-  headers: Record<string, string>;
-}
-
-export interface HttpResponse<T> {
-  data?: T;
-  metadata: HttpMetadata;
-  raw: ArrayBuffer;
-}
-
-export interface RequestHandler {
-  next?: RequestHandler;
-
-  handle<T>(request: Request<T>): Promise<HttpResponse<T>>;
-}
-
-export enum ContentType {
-  Json = 'json',
-  Xml = 'xml',
-  Pdf = 'pdf',
-  Image = 'image',
-  File = 'file',
-  Binary = 'binary',
-  FormUrlEncoded = 'form',
-  Text = 'text',
-  MultipartFormData = 'multipartFormData',
-}
-
-export interface Options<T> {
-  responseSchema: ZodType<T, any, any>;
-  requestSchema?: ZodType;
-  body?: any;
-  requestContentType?: ContentType;
-  responseContentType?: ContentType;
-  abortSignal?: AbortSignal;
-  queryParams?: Record<string, unknown>;
-  retry?: RetryOptions;
-}
-
-export interface RequestConfig {
-  retry?: RetryOptions;
-  validation?: ValidationOptions;
-}
-
-export interface RetryOptions {
-  attempts: number;
-  delayMs?: number;
-}
-
-export interface ValidationOptions {
-  responseValidation?: boolean;
-}

package/src/index.ts

@@ -1,73 +0,0 @@
-import { Environment } from './http/environment';
-import { SdkConfig } from './http/types';
-import { DestinationsService } from './services/destinations';
-import { PackagesService } from './services/packages';
-import { PurchasesService } from './services/purchases';
-import { ESimService } from './services/e-sim';
-
-export * as Destinations from './services/destinations';
-export * as Packages from './services/packages';
-export * as Purchases from './services/purchases';
-export * as ESim from './services/e-sim';
-
-export class Celitech {
-  public readonly destinations: DestinationsService;
-
-  public readonly packages: PackagesService;
-
-  public readonly purchases: PurchasesService;
-
-  public readonly eSim: ESimService;
-
-  constructor(public config: SdkConfig) {
-    const baseUrl = config.environment || config.baseUrl || Environment.DEFAULT;
-    this.config = {
-      ...config,
-      baseUrl,
-    };
-    this.destinations = new DestinationsService(this.config);
-
-    this.packages = new PackagesService(this.config);
-
-    this.purchases = new PurchasesService(this.config);
-
-    this.eSim = new ESimService(this.config);
-  }
-
-  set baseUrl(baseUrl: string) {
-    this.destinations.baseUrl = baseUrl;
-    this.packages.baseUrl = baseUrl;
-    this.purchases.baseUrl = baseUrl;
-    this.eSim.baseUrl = baseUrl;
-  }
-
-  set environment(environment: Environment) {
-    this.destinations.baseUrl = environment;
-    this.packages.baseUrl = environment;
-    this.purchases.baseUrl = environment;
-    this.eSim.baseUrl = environment;
-  }
-
-  set timeout(timeout: number) {
-    this.destinations.timeout = timeout;
-    this.packages.timeout = timeout;
-    this.purchases.timeout = timeout;
-    this.eSim.timeout = timeout;
-  }
-
-  set clientId(clientId: string) {
-    this.destinations.clientId = clientId;
-    this.packages.clientId = clientId;
-    this.purchases.clientId = clientId;
-    this.eSim.clientId = clientId;
-  }
-
-  set clientSecret(clientSecret: string) {
-    this.destinations.clientSecret = clientSecret;
-    this.packages.clientSecret = clientSecret;
-    this.purchases.clientSecret = clientSecret;
-    this.eSim.clientSecret = clientSecret;
-  }
-}
-
-// c029837e0e474b76bc487506e8799df5e3335891efe4fb02bda7a1441840310c

package/src/services/base-service.ts

@@ -1,29 +0,0 @@
-import { Environment } from '../http/environment';
-import { HttpClient } from '../http/client';
-import { SdkConfig } from '../http/types';
-
-export class BaseService {
-  public client: HttpClient = new HttpClient(this.config);
-
-  constructor(public config: SdkConfig) {}
-
-  set baseUrl(baseUrl: string) {
-    this.config.baseUrl = baseUrl;
-  }
-
-  set environment(environment: Environment) {
-    this.config.environment = environment;
-  }
-
-  set timeout(timeout: number) {
-    this.config.timeout = timeout;
-  }
-
-  set clientId(clientId: string) {
-    this.config.clientId = clientId;
-  }
-
-  set clientSecret(clientSecret: string) {
-    this.config.clientSecret = clientSecret;
-  }
-}

package/src/services/destinations/destinations.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { BaseService } from '../base-service';
-import { ContentType, HttpResponse, RequestConfig } from '../../http/types';
-import { RequestBuilder } from '../../http/transport/request-builder';
-import { ListDestinationsOkResponse, listDestinationsOkResponseResponse } from './models/list-destinations-ok-response';
-
-export class DestinationsService extends BaseService {
-  /**
-   * List Destinations
-   * @returns {Promise<HttpResponse<ListDestinationsOkResponse>>} Successful Response
-   */
-  async listDestinations(requestConfig?: RequestConfig): Promise<HttpResponse<ListDestinationsOkResponse>> {
-    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/index.ts

@@ -1 +0,0 @@
-export { DestinationsService } from './destinations';