celitech-sdk 1.1.68 → 1.1.72

package/src/http/transport/request.ts

@@ -0,0 +1,178 @@
+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

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,68 @@
+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 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

@@ -0,0 +1,29 @@
+import { Environment } from '../http/environment';
+import { HttpClient } from '../http';
+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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { BaseService } from '../base-service';
+import { ContentType, HttpResponse } from '../../http';
+import { 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

@@ -0,0 +1 @@
+export * from './destinations';

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const destinations = z.lazy(() => {
+  return z.object({
+    name: z.string().optional(),
+    destination: z.string().optional(),
+    supportedCountries: z.array(z.string()).optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Destinations} destinations
+ * @property {string} - Name of the destination
+ * @property {string} - ISO representation of the destination
+ * @property {string[]} - This array indicates the geographical area covered by a specific destination. If the destination represents a single country, the array will include that country. However, if the destination represents a broader regional scope, the array will be populated with the names of the countries belonging to that region.
+ */
+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 = z.lazy(() => {
+  return z
+    .object({
+      name: z.string().optional(),
+      destination: z.string().optional(),
+      supportedCountries: z.array(z.string()).optional(),
+    })
+    .transform((data) => ({
+      name: data['name'],
+      destination: data['destination'],
+      supportedCountries: data['supportedCountries'],
+    }));
+});
+
+/**
+ * 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 = z.lazy(() => {
+  return z
+    .object({
+      name: z.string().nullish(),
+      destination: z.string().nullish(),
+      supportedCountries: z.array(z.string()).nullish(),
+    })
+    .transform((data) => ({
+      name: data['name'],
+      destination: data['destination'],
+      supportedCountries: data['supportedCountries'],
+    }));
+});

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

@@ -0,0 +1,2 @@
+export * from './list-destinations-ok-response';
+export * from './destinations';

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

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { destinations, destinationsRequest, destinationsResponse } from './destinations';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const listDestinationsOkResponse = z.lazy(() => {
+  return z.object({
+    destinations: z.array(destinations).optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {ListDestinationsOkResponse} listDestinationsOkResponse
+ * @property {Destinations[]}
+ */
+export type ListDestinationsOkResponse = z.infer<typeof listDestinationsOkResponse>;
+
+/**
+ * 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 = z.lazy(() => {
+  return z
+    .object({
+      destinations: z.array(destinationsResponse).optional(),
+    })
+    .transform((data) => ({
+      destinations: data['destinations'],
+    }));
+});
+
+/**
+ * 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 = z.lazy(() => {
+  return z.object({ destinations: z.array(destinationsRequest).nullish() }).transform((data) => ({
+    destinations: data['destinations'],
+  }));
+});

package/src/services/e-sim/e-sim.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { BaseService } from '../base-service';
+import { ContentType, HttpResponse } from '../../http';
+import { RequestConfig } from '../../http/types';
+import { RequestBuilder } from '../../http/transport/request-builder';
+import { GetEsimOkResponse, getEsimOkResponseResponse } from './models/get-esim-ok-response';
+import { GetEsimParams } from './request-params';
+import { GetEsimDeviceOkResponse, getEsimDeviceOkResponseResponse } from './models/get-esim-device-ok-response';
+import { GetEsimHistoryOkResponse, getEsimHistoryOkResponseResponse } from './models/get-esim-history-ok-response';
+import { GetEsimMacOkResponse, getEsimMacOkResponseResponse } from './models/get-esim-mac-ok-response';
+
+export class ESimService extends BaseService {
+  /**
+   * Get eSIM Status
+   * @param {string} iccid - ID of the eSIM
+   * @returns {Promise<HttpResponse<GetEsimOkResponse>>} Successful Response
+   */
+  async getEsim(params: GetEsimParams, requestConfig?: RequestConfig): Promise<HttpResponse<GetEsimOkResponse>> {
+    const request = new RequestBuilder<GetEsimOkResponse>()
+      .setConfig(this.config)
+      .setBaseUrl(this.config)
+      .setMethod('GET')
+      .setPath('/esim')
+      .setRequestSchema(z.any())
+      .setResponseSchema(getEsimOkResponseResponse)
+      .setRequestContentType(ContentType.Json)
+      .setResponseContentType(ContentType.Json)
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addQueryParam('iccid', params?.iccid)
+      .build();
+    return this.client.call<GetEsimOkResponse>(request);
+  }
+
+  /**
+   * Get eSIM Device
+   * @param {string} iccid - ID of the eSIM
+   * @returns {Promise<HttpResponse<GetEsimDeviceOkResponse>>} Successful Response
+   */
+  async getEsimDevice(iccid: string, requestConfig?: RequestConfig): Promise<HttpResponse<GetEsimDeviceOkResponse>> {
+    const request = new RequestBuilder<GetEsimDeviceOkResponse>()
+      .setConfig(this.config)
+      .setBaseUrl(this.config)
+      .setMethod('GET')
+      .setPath('/esim/{iccid}/device')
+      .setRequestSchema(z.any())
+      .setResponseSchema(getEsimDeviceOkResponseResponse)
+      .setRequestContentType(ContentType.Json)
+      .setResponseContentType(ContentType.Json)
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addPathParam('iccid', iccid)
+      .build();
+    return this.client.call<GetEsimDeviceOkResponse>(request);
+  }
+
+  /**
+   * Get eSIM History
+   * @param {string} iccid - ID of the eSIM
+   * @returns {Promise<HttpResponse<GetEsimHistoryOkResponse>>} Successful Response
+   */
+  async getEsimHistory(iccid: string, requestConfig?: RequestConfig): Promise<HttpResponse<GetEsimHistoryOkResponse>> {
+    const request = new RequestBuilder<GetEsimHistoryOkResponse>()
+      .setConfig(this.config)
+      .setBaseUrl(this.config)
+      .setMethod('GET')
+      .setPath('/esim/{iccid}/history')
+      .setRequestSchema(z.any())
+      .setResponseSchema(getEsimHistoryOkResponseResponse)
+      .setRequestContentType(ContentType.Json)
+      .setResponseContentType(ContentType.Json)
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addPathParam('iccid', iccid)
+      .build();
+    return this.client.call<GetEsimHistoryOkResponse>(request);
+  }
+
+  /**
+   * Get eSIM MAC
+   * @param {string} iccid - ID of the eSIM
+   * @returns {Promise<HttpResponse<GetEsimMacOkResponse>>} Successful Response
+   */
+  async getEsimMac(iccid: string, requestConfig?: RequestConfig): Promise<HttpResponse<GetEsimMacOkResponse>> {
+    const request = new RequestBuilder<GetEsimMacOkResponse>()
+      .setConfig(this.config)
+      .setBaseUrl(this.config)
+      .setMethod('GET')
+      .setPath('/esim/{iccid}/mac')
+      .setRequestSchema(z.any())
+      .setResponseSchema(getEsimMacOkResponseResponse)
+      .setRequestContentType(ContentType.Json)
+      .setResponseContentType(ContentType.Json)
+      .setRetryAttempts(this.config, requestConfig)
+      .setRetryDelayMs(this.config, requestConfig)
+      .setResponseValidation(this.config, requestConfig)
+      .addPathParam('iccid', iccid)
+      .build();
+    return this.client.call<GetEsimMacOkResponse>(request);
+  }
+}

package/src/services/e-sim/index.ts

@@ -0,0 +1 @@
+export * from './e-sim';

package/src/services/e-sim/models/device.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const device = z.lazy(() => {
+  return z.object({
+    oem: z.string().optional(),
+    hardwareName: z.string().optional(),
+    hardwareModel: z.string().optional(),
+    eid: z.string().optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {Device} device
+ * @property {string} - Name of the OEM
+ * @property {string} - Name of the Device
+ * @property {string} - Model of the Device
+ * @property {string} - Serial Number of the eSIM
+ */
+export type Device = z.infer<typeof device>;
+
+/**
+ * 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 deviceResponse = z.lazy(() => {
+  return z
+    .object({
+      oem: z.string().optional(),
+      hardwareName: z.string().optional(),
+      hardwareModel: z.string().optional(),
+      eid: z.string().optional(),
+    })
+    .transform((data) => ({
+      oem: data['oem'],
+      hardwareName: data['hardwareName'],
+      hardwareModel: data['hardwareModel'],
+      eid: data['eid'],
+    }));
+});
+
+/**
+ * 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 deviceRequest = z.lazy(() => {
+  return z
+    .object({
+      oem: z.string().nullish(),
+      hardwareName: z.string().nullish(),
+      hardwareModel: z.string().nullish(),
+      eid: z.string().nullish(),
+    })
+    .transform((data) => ({
+      oem: data['oem'],
+      hardwareName: data['hardwareName'],
+      hardwareModel: data['hardwareModel'],
+      eid: data['eid'],
+    }));
+});

package/src/services/e-sim/models/get-esim-device-ok-response.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { device, deviceRequest, deviceResponse } from './device';
+
+/**
+ * The shape of the model inside the application code - what the users use
+ */
+export const getEsimDeviceOkResponse = z.lazy(() => {
+  return z.object({
+    device: device.optional(),
+  });
+});
+
+/**
+ *
+ * @typedef  {GetEsimDeviceOkResponse} getEsimDeviceOkResponse
+ * @property {Device}
+ */
+export type GetEsimDeviceOkResponse = z.infer<typeof getEsimDeviceOkResponse>;
+
+/**
+ * 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 getEsimDeviceOkResponseResponse = z.lazy(() => {
+  return z
+    .object({
+      device: deviceResponse.optional(),
+    })
+    .transform((data) => ({
+      device: data['device'],
+    }));
+});
+
+/**
+ * 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 getEsimDeviceOkResponseRequest = z.lazy(() => {
+  return z.object({ device: deviceRequest.nullish() }).transform((data) => ({
+    device: data['device'],
+  }));
+});