celitech-sdk 1.1.85 → 1.1.86

package/examples/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es6",
-    "module": "commonjs",
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "noImplicitAny": true,
-    "baseUrl": "./",
-    "declaration": true,
-    "moduleResolution": "node",
-    "isolatedModules": true,
-    "allowSyntheticDefaultImports": true,
-    "declarationMap": true,
-    "lib": ["es2017", "dom"],
-    "sourceMap": true
-  },
-  "include": ["src/"]
-}

package/src/http/client.ts

@@ -1,46 +0,0 @@
-import { SerializationStyle, serializePath, serializeQuery } from './serializer';
-import { HttpMethod, HttpResponse, Options, RetryOptions, SdkConfig } from './types';
-import { RequestHandlerChain } from './handlers/handler-chain';
-import { HookHandler } from './handlers/hook-handler';
-import { ResponseValidationHandler } from './handlers/response-validation-handler';
-import { RequestValidationHandler } from './handlers/request-validation-handler';
-import { CustomHook } from './hooks/custom-hook';
-import { TerminatingHandler } from './handlers/terminating-handler';
-import { RetryHandler } from './handlers/retry-handler';
-import { Request } from './transport/request';
-
-export class HttpClient {
-  private readonly requestHandlerChain = new RequestHandlerChain();
-
-  constructor(
-    private config: SdkConfig,
-    hook = new CustomHook(),
-  ) {
-    this.requestHandlerChain.addHandler(new ResponseValidationHandler());
-    this.requestHandlerChain.addHandler(new RequestValidationHandler());
-    this.requestHandlerChain.addHandler(new RetryHandler());
-    this.requestHandlerChain.addHandler(new HookHandler(hook));
-    this.requestHandlerChain.addHandler(new TerminatingHandler());
-  }
-
-  call<T>(request: Request<T>): Promise<HttpResponse<T>> {
-    return this.requestHandlerChain.callChain(request);
-  }
-
-  buildPath(
-    pathPattern: string,
-    pathArguments: Record<string, unknown>,
-    style = SerializationStyle.SIMPLE,
-    explode = false,
-  ): string {
-    return serializePath(pathPattern, pathArguments, style, explode);
-  }
-
-  setBaseUrl(url: string): void {
-    this.config.baseUrl = url;
-  }
-
-  setConfig(config: SdkConfig): void {
-    this.config = config;
-  }
-}

package/src/http/environment.ts

@@ -1,3 +0,0 @@
-export enum Environment {
-  DEFAULT = 'https://api.celitech.net/v1',
-}

package/src/http/error.ts

@@ -1,12 +0,0 @@
-import { HttpMetadata } from './types';
-
-export class HttpError extends Error {
-  public readonly error: string;
-  public readonly metadata: HttpMetadata;
-
-  constructor(metadata: HttpMetadata, error?: string) {
-    super(error);
-    this.error = metadata.statusText;
-    this.metadata = metadata;
-  }
-}

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

@@ -1,22 +0,0 @@
-import { Request } from '../transport/request';
-import { HttpResponse, RequestHandler } from '../types';
-
-export class RequestHandlerChain {
-  private readonly handlers: RequestHandler[] = [];
-
-  addHandler(handler: RequestHandler): void {
-    if (this.handlers.length > 0) {
-      const previousHandler = this.handlers[this.handlers.length - 1];
-      previousHandler.next = handler;
-    }
-    this.handlers.push(handler);
-  }
-
-  async callChain<T>(request: Request<T>): Promise<HttpResponse<T>> {
-    if (!this.handlers.length) {
-      throw new Error('No handlers added to the chain');
-    }
-
-    return this.handlers[0].handle(request);
-  }
-}

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

@@ -1,47 +0,0 @@
-import { Request } from '../transport/request';
-import { HttpResponse, RequestHandler } from '../types';
-import { HttpError } from '../error';
-import { Hook } from '../hooks/hook';
-
-export class HookHandler implements RequestHandler {
-  next?: RequestHandler;
-
-  constructor(private readonly hook: Hook) {}
-
-  async handle<T>(request: Request<T>): Promise<HttpResponse<T>> {
-    if (!this.next) {
-      throw new Error('No next handler set in hook handler.');
-    }
-
-    const hookParams = this.getHookParams<T>(request);
-
-    const nextRequest = await this.beforeRequest(request, hookParams);
-
-    const response = await this.next.handle(nextRequest);
-
-    if (response.metadata.status < 400) {
-      return await this.hook.afterResponse(request.toHookRequest(), 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 = request.toHookRequest();
-
-    const newRequest = await this.hook.beforeRequest(hookRequest, hookParams);
-
-    request.updateFromHookRequest(newRequest);
-
-    return request;
-  }
-
-  getHookParams<T>(request: Request<T>): Map<string, string> {
-    const hookParams: Map<string, string> = new Map();
-    hookParams.set('clientId', request.config.clientId || '');
-    hookParams.set('clientSecret', request.config.clientSecret || '');
-    return hookParams;
-  }
-}

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

@@ -1,72 +0,0 @@
-import { Request } from '../transport/request';
-import { ContentType, HttpResponse, RequestHandler } from '../types';
-import { HttpError } from '../error';
-
-export class RequestValidationHandler implements RequestHandler {
-  next?: RequestHandler;
-
-  async handle<T>(request: Request<T>): Promise<HttpResponse<T>> {
-    if (!this.next) {
-      throw new Error('No next handler set in ContentTypeHandler.');
-    }
-
-    if (request.requestContentType === ContentType.Json) {
-      request.body = JSON.stringify(request.requestSchema?.parse(request.body));
-    } else if (
-      request.requestContentType === ContentType.Xml ||
-      request.requestContentType === ContentType.Binary ||
-      request.requestContentType === ContentType.Text
-    ) {
-      request.body = request.body;
-    } else if (request.requestContentType === ContentType.FormUrlEncoded) {
-      request.body = this.toFormUrlEncoded(request.body);
-    } else if (request.requestContentType === ContentType.MultipartFormData) {
-      request.body = this.toFormData(request.body);
-    } else {
-      request.body = JSON.stringify(request.requestSchema?.parse(request.body));
-    }
-
-    return await this.next.handle(request);
-  }
-
-  toFormUrlEncoded(body: BodyInit | undefined): string {
-    if (body === undefined) {
-      return '';
-    }
-
-    if (typeof body === 'string') {
-      return body;
-    }
-
-    if (body instanceof URLSearchParams) {
-      return body.toString();
-    }
-
-    if (body instanceof FormData) {
-      const params = new URLSearchParams();
-      body.forEach((value, key) => {
-        params.append(key, value.toString());
-      });
-      return params.toString();
-    }
-
-    return '';
-  }
-
-  toFormData(body: Record<string, any>): FormData | undefined {
-    const formData = new FormData();
-
-    Object.keys(body).forEach((key: any) => {
-      const value: any = body[key];
-      if (Array.isArray(value)) {
-        value.forEach((v, i) => formData.append(`${key}[${i}]`, v));
-      } else if (value instanceof ArrayBuffer) {
-        formData.append(key, new Blob([value]));
-      } else {
-        formData.append(key, value);
-      }
-    });
-
-    return formData;
-  }
-}

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

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

@@ -1,40 +0,0 @@
-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.');
-    }
-
-    for (let attempt = 1; attempt <= request.retry.attempts; attempt++) {
-      try {
-        return await this.next.handle(request);
-      } catch (error: any) {
-        if (!this.shouldRetry(error) || attempt === request.retry.attempts) {
-          throw error;
-        }
-        await this.delay(request.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 | undefined): Promise<void> {
-    if (!delayMs) {
-      return Promise.resolve();
-    }
-
-    return new Promise((resolve, reject) => {
-      setTimeout(() => resolve(), delayMs);
-    });
-  }
-}

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

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

@@ -1,32 +0,0 @@
-import { HttpMetadata } from '../types';
-import { Hook } from './hook';
-import { HttpRequest, HttpResponse, HttpError } from './hook';
-
-export class CustomHook implements Hook {
-  public async beforeRequest(request: HttpRequest, params: Map<string, string>): Promise<HttpRequest> {
-    return request;
-  }
-
-  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

@@ -1,40 +0,0 @@
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-
-export interface HttpRequest {
-  baseUrl: string;
-  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/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;
-}