celitech-sdk 1.1.66 → 1.1.71

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

@@ -0,0 +1,106 @@
+import { Request } from '../transport/request';
+import { ZodUndefined } from 'zod';
+import { ContentType, HttpResponse, RequestHandler } from '../types';
+import { HttpError } from '../error';
+
+export class ResponseValidationHandler implements RequestHandler {
+  next?: RequestHandler;
+
+  async handle<T>(request: Request<T>): Promise<HttpResponse<T>> {
+    const response = await this.next!.handle(request);
+
+    if (!this.hasContent(request, response)) {
+      return response;
+    }
+
+    if (request.responseContentType === ContentType.Json) {
+      const decodedBody = new TextDecoder().decode(response.raw);
+      const json = JSON.parse(decodedBody);
+      return {
+        ...response,
+        data: this.validate<T>(request, json),
+      };
+    } else if (
+      request.responseContentType === ContentType.Binary ||
+      request.responseContentType === ContentType.Image
+    ) {
+      return {
+        ...response,
+        data: this.validate<T>(request, response.raw),
+      };
+    } else if (request.responseContentType === ContentType.Text || request.responseContentType === ContentType.Xml) {
+      const text = new TextDecoder().decode(response.raw);
+      return {
+        ...response,
+        data: this.validate<T>(request, text),
+      };
+    } else if (request.responseContentType === ContentType.FormUrlEncoded) {
+      const urlEncoded = this.fromUrlEncoded(new TextDecoder().decode(response.raw));
+      return {
+        ...response,
+        data: this.validate<T>(request, urlEncoded),
+      };
+    } else if (request.responseContentType === ContentType.MultipartFormData) {
+      const formData = this.fromFormData(response.raw);
+      return {
+        ...response,
+        data: this.validate<T>(request, formData),
+      };
+    } else {
+      const decodedBody = new TextDecoder().decode(response.raw);
+      const json = JSON.parse(decodedBody);
+      return {
+        ...response,
+        data: this.validate<T>(request, json),
+      };
+    }
+  }
+
+  private validate<T>(request: Request<T>, data: any): T {
+    if (request.config.validation?.responseValidation) {
+      return request.responseSchema.parse(data);
+    }
+    return data;
+  }
+
+  private hasContent<T>(request: Request<T>, response: HttpResponse<T>): boolean {
+    return (
+      !!request.responseSchema && !(request.responseSchema instanceof ZodUndefined) && response.metadata.status !== 204
+    );
+  }
+
+  private fromUrlEncoded(urlEncodedData: string): object {
+    const pairs = urlEncodedData.split('&');
+    const result: Record<string, string> = {};
+
+    pairs.forEach((pair) => {
+      const [key, value] = pair.split('=');
+      if (key && value !== undefined) {
+        result[decodeURIComponent(key)] = decodeURIComponent(value);
+      }
+    });
+
+    return result;
+  }
+
+  private fromFormData(arrayBuffer: ArrayBuffer): Record<string, string> {
+    const decoder = new TextDecoder();
+    const text = decoder.decode(arrayBuffer);
+
+    const boundary = text.split('\r\n')[0];
+    const parts = text.split(boundary).slice(1, -1);
+
+    const formDataObj: Record<string, string> = {};
+
+    parts.forEach((part) => {
+      const [header, value] = part.split('\r\n\r\n');
+      const nameMatch = header.match(/name="([^"]+)"/);
+      if (nameMatch) {
+        const name = nameMatch[1].trim();
+        formDataObj[name] = value?.trim() || '';
+      }
+    });
+
+    return formDataObj;
+  }
+}

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

@@ -0,0 +1,37 @@
+import { Request } from '../transport/request';
+import { HttpResponse, RequestHandler } from '../types';
+import { HttpError } from '../error';
+
+export class RetryHandler implements RequestHandler {
+  next?: RequestHandler;
+
+  async handle<T>(request: Request<T>): Promise<HttpResponse<T>> {
+    if (!this.next) {
+      throw new Error('No next handler set in retry handler.');
+    }
+
+    const retry = request.getRetry();
+    for (let attempt = 1; attempt <= retry.attempts; attempt++) {
+      try {
+        return await this.next.handle(request);
+      } catch (error: any) {
+        if (!this.shouldRetry(error) || attempt === retry.attempts) {
+          throw error;
+        }
+        await this.delay(retry.delayMs);
+      }
+    }
+
+    throw new Error('Error retrying request.');
+  }
+
+  private shouldRetry(error: Error): boolean {
+    return error instanceof HttpError && (error.metadata.status >= 500 || error.metadata.status === 408);
+  }
+
+  private delay(delayMs: number): Promise<void> {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => resolve(), delayMs);
+    });
+  }
+}

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

@@ -0,0 +1,38 @@
+import { HttpError } from '../error';
+import { Request } from '../transport/request';
+import { HttpResponse, RequestHandler } from '../types';
+
+export class TerminatingHandler implements RequestHandler {
+  async handle<T>(request: Request<T>): Promise<HttpResponse<T>> {
+    const { url, requestInit } = request.getFetchArgs();
+    const response = await fetch(url, requestInit);
+
+    const metadata = {
+      status: response.status,
+      statusText: response.statusText,
+      headers: this.getHeaders(response),
+    };
+
+    if (metadata.status >= 400) {
+      throw new HttpError(metadata);
+    }
+
+    return {
+      metadata,
+      raw: await response.clone().arrayBuffer(),
+    };
+  }
+
+  private getHeaders(response: Response): Record<string, string> {
+    const headers: Record<string, string> = {};
+    response.headers.forEach((value: string, key: string) => {
+      headers[key] = value;
+    });
+
+    return headers;
+  }
+
+  private isErrorResponse(response: HttpResponse<unknown>): boolean {
+    return response.metadata.status >= 400;
+  }
+}

package/src/http/hooks/custom-hook.ts

@@ -0,0 +1,87 @@
+import { HttpMetadata } from '../types';
+import { Hook } from './hook';
+import { HttpRequest, HttpResponse, HttpError } from './hook';
+
+let CURRENT_TOKEN = '';
+let CURRENT_EXPIRY = -1;
+
+export class CustomHook implements Hook {
+  public async beforeRequest(request: HttpRequest, params: Map<string, string>): Promise<HttpRequest> {
+    if (request.path.endsWith('/oauth/token')) return request;
+
+    const clientId = params.get('clientId') || '';
+    const clientSecret = params.get('clientSecret') || '';
+    if (!clientId || !clientSecret) {
+      throw new Error('Missing clientId and/or clientSecret constructor parameters');
+    }
+
+    if (!CURRENT_TOKEN || CURRENT_EXPIRY < Date.now()) {
+      // Prepare the request payload for fecthing a fresh Oauth token
+      const input = {
+        client_id: clientId || '',
+        client_secret: clientSecret || '',
+        grant_type: 'client_credentials',
+      };
+
+      // Fetch a fresh Oauth token
+      // Retrieve the new access token and expiry, and set them to the global variables
+      const tokenResponse = await this.getToken(input);
+      const { expires_in, access_token } = tokenResponse.data;
+
+      if (!expires_in || !access_token) {
+        throw new Error('There is an issue with getting the oauth token');
+      }
+      CURRENT_EXPIRY = Date.now() + expires_in * 1000;
+      CURRENT_TOKEN = access_token;
+    }
+
+    // Set the Bearer token in the request header
+    const authorization = `Bearer ${CURRENT_TOKEN}`;
+
+    if (!request.headers) {
+      request.headers = new Map();
+    }
+    request.headers.set('Authorization', authorization);
+
+    return request;
+  }
+
+  async getToken(input: any): Promise<any> {
+    const tokenUrl = 'https://auth.celitech.net/oauth2/token';
+
+    const response = await fetch(tokenUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: new URLSearchParams(input),
+    }).catch((error) => {
+      throw new Error('Error in posting the request:' + error);
+    });
+
+    return response.json();
+  }
+
+  public async afterResponse(
+    request: HttpRequest,
+    response: HttpResponse<any>,
+    params: Map<string, string>,
+  ): Promise<HttpResponse<any>> {
+    return response;
+  }
+
+  public async onError(
+    request: HttpRequest,
+    response: HttpResponse<any>,
+    params: Map<string, string>,
+  ): Promise<HttpError> {
+    return new CustomHttpError('a custom error message', response.metadata);
+  }
+}
+
+class CustomHttpError implements HttpError {
+  constructor(
+    public error: string,
+    public metadata: HttpMetadata,
+  ) {}
+}

package/src/http/hooks/hook.ts

@@ -0,0 +1,39 @@
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+export interface HttpRequest {
+  method: HttpMethod;
+  path: string;
+  headers?: Map<string, unknown>;
+  body?: BodyInit;
+  abortSignal?: AbortSignal;
+  queryParams?: Map<string, unknown>;
+}
+
+interface HttpMetadata {
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+}
+
+export interface HttpResponse<T> {
+  data?: T;
+  metadata: HttpMetadata;
+  raw: ArrayBuffer;
+}
+
+export interface HttpError {
+  error: string;
+  metadata: HttpMetadata;
+}
+
+export interface Hook {
+  beforeRequest(request: HttpRequest, params: Map<string, string>): Promise<HttpRequest>;
+
+  afterResponse(
+    request: HttpRequest,
+    response: HttpResponse<any>,
+    params: Map<string, string>,
+  ): Promise<HttpResponse<any>>;
+
+  onError(request: HttpRequest, response: HttpResponse<any>, params: Map<string, string>): Promise<HttpError>;
+}

package/src/http/index.ts

@@ -0,0 +1,4 @@
+export * from './client';
+export * from './serializer';
+export * from './types';
+export * from './error';

package/src/http/serializer.ts

@@ -0,0 +1,180 @@
+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)) {
+    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> {
+  if (!headers) {
+    return {};
+  }
+
+  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.ts

@@ -0,0 +1,169 @@
+import { ZodType } from 'zod';
+import { ContentType, HttpMethod, SdkConfig, RetryOptions, RequestConfig } from '../types';
+import { serializeHeader, serializePath, serializeQuery } from '../serializer';
+import { HttpRequest } from '../hooks/hook';
+
+interface CreateRequestParameters<T> {
+  method: HttpMethod;
+  body?: any;
+  path: string;
+  config: SdkConfig;
+  responseSchema: ZodType<T, any, any>;
+  requestSchema: ZodType;
+  requestContentType: ContentType;
+  responseContentType: ContentType;
+  requestConfig?: RequestConfig;
+}
+
+export class Request<T> {
+  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;
+
+  constructor(params: CreateRequestParameters<T>) {
+    this.method = params.method;
+    this.pathPattern = params.path;
+    this.body = params.body;
+    this.path = this.constructPath();
+    this.config = params.config;
+    this.responseSchema = params.responseSchema;
+    this.requestSchema = params.requestSchema;
+    this.requestContentType = params.requestContentType;
+    this.responseContentType = params.responseContentType;
+    this.applyRequestConfig(params.requestConfig);
+  }
+
+  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;
+  }
+
+  getRetry(): Required<RetryOptions> {
+    return {
+      attempts: this.config.retry?.attempts ?? 3,
+      delayMs: this.config.retry?.delayMs ?? 150,
+    };
+  }
+
+  getFetchArgs(): { url: string; requestInit: RequestInit } {
+    const fetchArgs: { url: string; requestInit: RequestInit } = {
+      url: this.constructFullUrl(),
+      requestInit: {
+        method: this.method,
+        body: this.body,
+        headers: this.constructHeadersInit(),
+      },
+    };
+
+    if (this.config.timeout !== undefined) {
+      fetchArgs.requestInit = {
+        ...fetchArgs.requestInit,
+        signal: AbortSignal.timeout(this.config.timeout),
+      };
+    }
+
+    return fetchArgs;
+  }
+
+  public updateFromHookRequest(hookRequest: HttpRequest) {
+    this.method = hookRequest.method;
+    this.path = hookRequest.path;
+    this.body = hookRequest.body;
+    this.headers = hookRequest.headers || new Map();
+    this.queryParams = hookRequest.queryParams || new Map();
+  }
+
+  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),
+      },
+    };
+  }
+
+  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}`;
+  }
+
+  private constructPath(): string {
+    const pathParamsRecord: Record<string, unknown> = this.constructParamsRecord(this.pathParams);
+    return serializePath(this.pathPattern, pathParamsRecord);
+  }
+
+  private constructHeadersInit(): HeadersInit {
+    const headerParamsRecord: Record<string, unknown> = this.constructParamsRecord(this.headers);
+    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;
+  }
+}