@meistrari/tela-sdk-js 0.0.2 → 0.0.4

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "@meistrari/tela-sdk-js",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/meistrari/tela-sdk-js.git"
   },
+  "types": "dist/index.d.ts",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
   },
-  "main": "dist/index.js",
   "files": [
     "dist"
   ],
@@ -17,9 +23,10 @@
     "node": "^20.15.1"
   },
   "scripts": {
-    "build": "tsc",
+    "prepublishOnly": "bun run build",
+    "release": "bunx bumpp & npm publish",
+    "build": "bunx unbuild",
     "test": "bun test",
-    "prepare": "husky",
     "lint": "eslint . --fix",
     "lint:fix": "eslint . --fix",
     "check": "eslint . --quiet && tsc --noEmit",
@@ -35,7 +42,8 @@
     "@types/micromatch": "4.0.9",
     "@types/node": "22.5.5",
     "husky": "9.1.6",
-    "lint-staged": "15.2.10"
+    "lint-staged": "15.2.10",
+    "unbuild": "^2.0.0"
   },
   "peerDependencies": {
     "typescript": "5.6.0"

package/dist/base-client.d.ts

@@ -1,49 +0,0 @@
-type HTTPMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-export type RequestOptions<Req = unknown | Record<string, unknown>> = {
-    method?: HTTPMethods;
-    path?: string;
-    query?: Req | undefined;
-    body?: Req | null | undefined;
-    headers?: Headers | undefined;
-    maxRetries?: number;
-    stream?: boolean | undefined;
-    timeout?: number;
-    signal?: AbortSignal | undefined | null;
-};
-export interface BaseClientOptions {
-    baseURL: string;
-    maxRetries?: number;
-    timeout?: number;
-}
-export declare abstract class BaseClient {
-    baseURL: string;
-    maxRetries: number;
-    timeout: number;
-    fetch: typeof fetch;
-    constructor({ baseURL, maxRetries, timeout }: BaseClientOptions);
-    protected createHeaders(opts?: Record<string, string>): Headers;
-    protected getUserAgent(): string;
-    protected getAuthHeaders(): Record<string, string>;
-    get<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
-    post<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
-    put<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
-    patch<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
-    delete<Req, Res>(path: string, opts?: RequestOptions<Req>): Promise<Res>;
-    private methodRequest;
-    private request;
-    private makeRequest;
-    private shouldRetry;
-    private retryRequest;
-    private calculateDefaultRetryTimeoutMillis;
-    fetchWithTimeout(url: string, _options: RequestInit, timeout: number, controller: AbortController): Promise<Response>;
-    protected buildRequest<Req>(options: RequestOptions<Req>): {
-        req: RequestInit;
-        url: string;
-        timeout: number;
-    };
-    protected buildURL<Req>(path: string, query: Req | null | undefined): string;
-    protected stringifyQuery(query: Record<string, unknown>): string;
-}
-export declare function createResponseHeaders(headers: Awaited<ReturnType<Fetch>>['headers']): Headers;
-export declare function debug(action: string, ...args: any[]): void;
-export {};

package/dist/base-client.js

@@ -1,299 +0,0 @@
-import { version } from '../package.json';
-import { APIError, ConnectionError, ConnectionTimeout, TelaError, UserAbortError, 
-// eslint-disable-next-line perfectionist/sort-named-imports
-toError, } from './errors';
-import { Stream } from './streaming';
-import { DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS } from './utils/constants';
-import { transformObjectFromCamelCaseToSnakeCase, transformObjectFromSnakeCaseToCamelCase } from './utils/data-transformation';
-async function defaultParseResponse(props) {
-    const { response } = props;
-    if (props.options.stream) {
-        debug('response', response.status, response.url, response.headers, response.body);
-        return Stream.fromSSEResponse(response, props.controller);
-    }
-    if (response.status === 204) {
-        return null;
-    }
-    const contentType = response.headers.get('content-type');
-    const isJSON = contentType?.includes('application/json') || contentType?.includes('application/vnd.api+json');
-    if (isJSON) {
-        const json = await response.json();
-        debug('response', response.status, response.url, response.headers, json);
-        return transformObjectFromSnakeCaseToCamelCase(json, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS);
-    }
-    const text = await response.text();
-    debug('response', response.status, response.url, response.headers, text);
-    return text;
-}
-export class BaseClient {
-    baseURL;
-    maxRetries;
-    timeout;
-    fetch;
-    constructor({ baseURL, maxRetries = 5, timeout = 0 }) {
-        this.baseURL = baseURL;
-        this.maxRetries = validateMaxRetries(maxRetries);
-        this.timeout = validateTimeout(timeout);
-        this.fetch = fetch;
-    }
-    createHeaders(opts) {
-        const headers = new Headers();
-        headers.set('Accept', 'application/json');
-        headers.set('Content-Type', 'application/json');
-        headers.set('User-Agent', this.getUserAgent());
-        for (const [key, value] of Object.entries(this.getAuthHeaders())) {
-            headers.set(key, value);
-        }
-        for (const [key, value] of Object.entries(opts ?? {})) {
-            headers.set(key, value);
-        }
-        return headers;
-    }
-    getUserAgent() {
-        return `tela-sdk-node/${version}`;
-    }
-    getAuthHeaders() {
-        return {};
-    }
-    get(path, opts) {
-        return this.methodRequest('GET', path, opts);
-    }
-    post(path, opts) {
-        return this.methodRequest('POST', path, opts);
-    }
-    put(path, opts) {
-        return this.methodRequest('PUT', path, opts);
-    }
-    patch(path, opts) {
-        return this.methodRequest('PATCH', path, opts);
-    }
-    delete(path, opts) {
-        return this.methodRequest('DELETE', path, opts);
-    }
-    async methodRequest(method, path, opts) {
-        const headers = this.createHeaders();
-        debug('methodRequest', method, path, opts);
-        const transformedQuery = opts?.query ? transformObjectFromCamelCaseToSnakeCase(opts.query, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS) : undefined;
-        const transformedBody = opts?.body ? transformObjectFromCamelCaseToSnakeCase(opts.body, DEFAULT_FIELDS_TRANSFORMATION_EXCLUSIONS) : undefined;
-        const { response, options, controller } = await this.request({
-            method,
-            path,
-            headers,
-            ...opts,
-            query: transformedQuery,
-            body: transformedBody,
-        });
-        return defaultParseResponse({ response, options, controller });
-    }
-    async request(options, remainingRetries = null) {
-        return this.makeRequest(options, remainingRetries);
-    }
-    async makeRequest(options, remainingRetries = null) {
-        if (remainingRetries === null) {
-            remainingRetries = options.maxRetries ?? this.maxRetries;
-        }
-        const { req, url, timeout } = this.buildRequest(options);
-        if (options.signal?.aborted) {
-            throw new UserAbortError();
-        }
-        const controller = new AbortController();
-        const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(toError);
-        if (response instanceof Error) {
-            debug('fetchWithTimeout error', response);
-            if (options.signal?.aborted) {
-                throw new UserAbortError();
-            }
-            if (remainingRetries) {
-                return this.retryRequest(options, remainingRetries);
-            }
-            if (response.name === 'AbortError') {
-                throw new ConnectionTimeout();
-            }
-            throw new ConnectionError({ cause: response });
-        }
-        const responseHeaders = createResponseHeaders(response.headers);
-        if (!response.ok) {
-            if (remainingRetries && this.shouldRetry(response)) {
-                debug('shouldRetry', `Retrying ${remainingRetries} more times`);
-                return this.retryRequest(options, remainingRetries, responseHeaders);
-            }
-            const errorText = await response.text().catch(e => toError(e).message);
-            const errorJSON = safeJSONParse(errorText);
-            const errorMessage = errorJSON ? undefined : errorText;
-            // const retryMessage = remainingRetries ? `(no more retries left)` : '(not retryable)'
-            const error = APIError.from(response.status, errorJSON, errorMessage);
-            debug('APIError', error);
-            throw error;
-        }
-        return { response, options, controller };
-    }
-    shouldRetry(response) {
-        // Note this is not a standard header.
-        const shouldRetryHeader = response.headers.get('x-should-retry');
-        // If the server explicitly says whether or not to retry, obey.
-        if (shouldRetryHeader === 'true')
-            return true;
-        if (shouldRetryHeader === 'false')
-            return false;
-        if (response.status === 408)
-            return true;
-        if (response.status === 409)
-            return true;
-        if (response.status === 429)
-            return true;
-        if (response.status >= 500)
-            return true;
-        return false;
-    }
-    async retryRequest(options, retriesRemaining, responseHeaders) {
-        let timeoutMillis;
-        const retryAfterMillisHeader = responseHeaders?.get('retry-after-ms');
-        if (retryAfterMillisHeader) {
-            const timeoutMs = Number.parseFloat(retryAfterMillisHeader);
-            if (!Number.isNaN(timeoutMs)) {
-                timeoutMillis = timeoutMs;
-            }
-        }
-        const retryAfterHeader = responseHeaders?.get('retry-after');
-        if (retryAfterHeader && !timeoutMillis) {
-            const timeoutSeconds = Number.parseFloat(retryAfterHeader);
-            if (!Number.isNaN(timeoutSeconds)) {
-                timeoutMillis = timeoutSeconds * 1000;
-            }
-            else {
-                timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
-            }
-        }
-        // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
-        // just do what it says, but otherwise calculate a default
-        if (!(timeoutMillis && timeoutMillis >= 0 && timeoutMillis < 60 * 1000)) {
-            const maxRetries = options.maxRetries ?? this.maxRetries;
-            timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
-        }
-        await sleep(timeoutMillis);
-        return this.makeRequest(options, retriesRemaining - 1);
-    }
-    calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
-        const initialRetryDelay = 0.5;
-        const maxRetryDelay = 25.0;
-        const numRetries = maxRetries - retriesRemaining;
-        // Apply exponential backoff, but not more than the max.
-        const sleepSeconds = Math.min(initialRetryDelay * 2 ** numRetries, maxRetryDelay);
-        // Apply some jitter, take up to at most 25 percent of the retry time.
-        const jitter = 1 - Math.random() * 0.25;
-        return sleepSeconds * jitter * 1000;
-    }
-    async fetchWithTimeout(url, _options, timeout, controller) {
-        const { signal, ...options } = _options || {};
-        if (signal) {
-            signal.addEventListener('abort', () => {
-                controller.abort();
-            });
-        }
-        let timeoutId;
-        if (timeout > 0) {
-            timeoutId = setTimeout(() => {
-                debug('fetchWithTimeout timeout');
-                controller.abort();
-            }, timeout);
-        }
-        debug('fetchWithTimeout', { url, options });
-        return this.fetch
-            .call(undefined, url, {
-            signal: controller.signal,
-            ...options,
-            ...(options.body ? { body: JSON.stringify(options.body) } : {}),
-        })
-            .finally(() => {
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-            }
-        });
-    }
-    buildRequest(options) {
-        const { method, path, query, headers = {}, body } = options;
-        if ('timeout' in options && options.timeout !== undefined) {
-            validateTimeout(options.timeout);
-        }
-        const url = this.buildURL(path, query);
-        const req = {
-            method,
-            ...(body && { body: body }),
-            headers,
-            signal: options.signal ?? null,
-        };
-        return {
-            req,
-            url,
-            timeout: options.timeout ?? this.timeout,
-        };
-    }
-    buildURL(path, query) {
-        const startsWithSchemeRegexp = /^(?:[a-z]+:)?\/\//i;
-        const isAbsoluteURL = (url) => {
-            return startsWithSchemeRegexp.test(url);
-        };
-        const url = isAbsoluteURL(path)
-            ? new URL(path)
-            : new URL(this.baseURL
-                + (this.baseURL.endsWith('/') && path.startsWith('/')
-                    ? path.slice(1)
-                    : path));
-        if (typeof query === 'object' && query && !Array.isArray(query)) {
-            url.search = this.stringifyQuery(query);
-        }
-        return url.toString();
-    }
-    stringifyQuery(query) {
-        return Object.entries(query)
-            .filter(([_, value]) => typeof value !== 'undefined')
-            .map(([key, value]) => {
-            if (typeof value === 'string'
-                || typeof value === 'number'
-                || typeof value === 'boolean') {
-                return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
-            }
-            if (value === null) {
-                return `${encodeURIComponent(key)}=`;
-            }
-            throw new TelaError(`Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
-        })
-            .join('&');
-    }
-}
-export function createResponseHeaders(headers) {
-    const headersFromResponse = new Headers();
-    for (const [key, value] of Object.entries(headers)) {
-        headersFromResponse.set(key, value);
-    }
-    return headersFromResponse;
-}
-function validateMaxRetries(maxRetries) {
-    if (maxRetries < 0) {
-        throw new TelaError('Max retries must be a non-negative integer');
-    }
-    return maxRetries;
-}
-function validateTimeout(timeout) {
-    if (timeout < 0) {
-        throw new TelaError('Timeout must be a non-negative integer');
-    }
-    return timeout;
-}
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-function safeJSONParse(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
-export function debug(action, ...args) {
-    if (typeof process !== 'undefined' && process?.env?.DEBUG === 'true') {
-        // eslint-disable-next-line no-console
-        console.log(`TelaSDK:DEBUG:${action}`, ...args);
-    }
-}

package/dist/errors.d.ts

@@ -1,67 +0,0 @@
-export declare class TelaError extends Error {
-}
-export declare class ConflictApiKeyAndJWTError extends TelaError {
-    constructor();
-}
-export declare class MissingApiKeyOrJWTError extends TelaError {
-    constructor();
-}
-export declare class EmptyFileError extends TelaError {
-    constructor();
-}
-export declare class InvalidFileURL extends TelaError {
-    constructor(url: string);
-}
-export declare class FileUploadError extends TelaError {
-    constructor(message: string);
-}
-export declare class APIError extends TelaError {
-    readonly statusCode: number | undefined;
-    readonly error: any;
-    constructor(statusCode: number | undefined, error: any, _message: string | undefined);
-    static from(statusCode: number, responseError: object | undefined, message: string | undefined): APIError;
-}
-export declare class UserAbortError extends APIError {
-    readonly statusCode: undefined;
-    constructor({ message }?: {
-        message?: string;
-    });
-}
-export declare class ConnectionError extends APIError {
-    readonly statusCode: undefined;
-    constructor({ message, cause, }: {
-        message?: string | undefined;
-        cause?: Error | undefined;
-    });
-}
-export declare class ConnectionTimeout extends APIError {
-    readonly statusCode: undefined;
-    constructor({ message, }?: {
-        message?: string | undefined;
-    });
-}
-export declare class BadRequestError extends APIError {
-    readonly statusCode = 400;
-}
-export declare class AuthenticationError extends APIError {
-    readonly statusCode = 401;
-}
-export declare class AuthorizationError extends APIError {
-    readonly statusCode = 403;
-}
-export declare class NotFoundError extends APIError {
-    readonly statusCode = 404;
-}
-export declare class ConflictError extends APIError {
-    readonly statusCode = 409;
-}
-export declare class UnprocessableEntityError extends APIError {
-    readonly statusCode = 422;
-}
-export declare class RateLimitError extends APIError {
-    readonly statusCode = 429;
-}
-export declare class InternalServerError extends APIError {
-    readonly statusCode = 500;
-}
-export declare function toError(err: any): Error;

package/dist/errors.js

@@ -1,133 +0,0 @@
-export class TelaError extends Error {
-}
-export class ConflictApiKeyAndJWTError extends TelaError {
-    constructor() {
-        super('You must provide either an API key or a JWT, but not both');
-    }
-}
-export class MissingApiKeyOrJWTError extends TelaError {
-    constructor() {
-        super('You must provide an API key or a JWT');
-    }
-}
-export class EmptyFileError extends TelaError {
-    constructor() {
-        super('File cannot be empty');
-    }
-}
-export class InvalidFileURL extends TelaError {
-    constructor(url) {
-        super(`Invalid file URL: ${url}`);
-    }
-}
-export class FileUploadError extends TelaError {
-    constructor(message) {
-        super(`Failed to upload file: ${message}`);
-    }
-}
-export class APIError extends TelaError {
-    statusCode;
-    error;
-    constructor(statusCode, error, _message) {
-        const message = error?.message
-            ? typeof error.message === 'string'
-                ? error.message
-                : JSON.stringify(error.message)
-            : error
-                ? JSON.stringify(error)
-                : _message;
-        super(message);
-        this.statusCode = statusCode;
-        this.error = error;
-    }
-    static from(statusCode, responseError, message) {
-        if (!statusCode) {
-            return new ConnectionError({
-                message,
-                cause: toError(responseError),
-            });
-        }
-        const error = responseError;
-        if (error.status === 400) {
-            return new BadRequestError(statusCode, error, message);
-        }
-        if (error.status === 401) {
-            return new AuthenticationError(statusCode, error, message);
-        }
-        if (error.status === 403) {
-            return new AuthorizationError(statusCode, error, message);
-        }
-        if (error.status === 404) {
-            return new NotFoundError(statusCode, error, message);
-        }
-        if (error.status === 409) {
-            return new ConflictError(statusCode, error, message);
-        }
-        if (error.status === 422) {
-            return new UnprocessableEntityError(statusCode, error, message);
-        }
-        if (error.status === 429) {
-            return new RateLimitError(statusCode, error, message);
-        }
-        if (error.status >= 500) {
-            return new InternalServerError(statusCode, error, message);
-        }
-        return new APIError(statusCode, error, message);
-    }
-}
-export class UserAbortError extends APIError {
-    statusCode = undefined;
-    constructor({ message } = {}) {
-        super(undefined, undefined, message || 'User aborted.');
-    }
-}
-export class ConnectionError extends APIError {
-    statusCode = undefined;
-    constructor({ message, cause, }) {
-        super(undefined, undefined, message || 'Connection error.');
-        if (cause)
-            this.cause = cause;
-    }
-}
-export class ConnectionTimeout extends APIError {
-    statusCode = undefined;
-    constructor({ message, } = {}) {
-        super(undefined, undefined, message || 'Request timed out.');
-    }
-}
-export class BadRequestError extends APIError {
-    statusCode = 400;
-}
-export class AuthenticationError extends APIError {
-    statusCode = 401;
-}
-export class AuthorizationError extends APIError {
-    statusCode = 403;
-}
-export class NotFoundError extends APIError {
-    statusCode = 404;
-}
-export class ConflictError extends APIError {
-    statusCode = 409;
-}
-export class UnprocessableEntityError extends APIError {
-    // todo: check if tela returns 400 or 422 for zod errors
-    statusCode = 422;
-}
-export class RateLimitError extends APIError {
-    statusCode = 429;
-}
-export class InternalServerError extends APIError {
-    statusCode = 500;
-}
-export function toError(err) {
-    if (err instanceof Error)
-        return err;
-    if (typeof err === 'object' && err !== null) {
-        try {
-            return new Error(JSON.stringify(err));
-        }
-        catch { }
-    }
-    return new Error(err);
-}