@levr-one/sdk 0.0.0-stage → 1.0.0

package/dist/runtime/client.js

@@ -0,0 +1,229 @@
+function createInterceptorManager() {
+    const _fns = [];
+    return {
+        _fns,
+        use(fn) {
+            _fns.push(fn);
+        },
+        eject(fn) {
+            const idx = _fns.indexOf(fn);
+            if (idx !== -1)
+                _fns[idx] = undefined;
+        },
+    };
+}
+function buildPath(urlTemplate, pathParams) {
+    if (!pathParams)
+        return urlTemplate;
+    return urlTemplate.replace(/\{(\w+)\}/g, (_, key) => {
+        const val = pathParams[key];
+        if (val === undefined)
+            return `{${key}}`;
+        const str = typeof val === 'object' && val !== null
+            ? JSON.stringify(val)
+            : String(val);
+        return encodeURIComponent(str);
+    });
+}
+function buildQuery(query) {
+    if (!query)
+        return '';
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(query)) {
+        if (value === null || value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item !== null && item !== undefined) {
+                    params.append(key, String(item));
+                }
+            }
+        }
+        else if (typeof value === 'object') {
+            params.append(key, JSON.stringify(value));
+        }
+        else {
+            params.append(key, String(value));
+        }
+    }
+    const str = params.toString();
+    return str ? `?${str}` : '';
+}
+async function setAuthHeader(headers, config, security) {
+    if (!security?.length || !config.auth)
+        return;
+    const scheme = security[0];
+    if (!scheme)
+        return;
+    let token;
+    if (typeof config.auth === 'function') {
+        token = await config.auth(scheme);
+    }
+    else {
+        token = config.auth;
+    }
+    if (token) {
+        const prefix = token.startsWith('Bearer ') ? '' : 'Bearer ';
+        headers.set('Authorization', `${prefix}${token}`);
+    }
+}
+export function createClient(initialConfig = {}) {
+    let _config = { ...initialConfig };
+    const interceptors = {
+        request: createInterceptorManager(),
+        response: createInterceptorManager(),
+        error: createInterceptorManager(),
+    };
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = { ...config };
+        return getConfig();
+    };
+    const request = async (options) => {
+        const fetchFn = _config.fetch ?? globalThis.fetch;
+        const resolvedBase = typeof _config.baseUrl === 'function'
+            ? _config.baseUrl()
+            : _config.baseUrl;
+        const base = resolvedBase ?? '';
+        const pathStr = buildPath(options.url, options.path);
+        const queryStr = buildQuery(options.query);
+        const url = `${base}${pathStr}${queryStr}`;
+        const headers = new Headers();
+        if (_config.headers) {
+            for (const [k, v] of Object.entries(_config.headers)) {
+                headers.set(k, v);
+            }
+        }
+        if (options.headers) {
+            for (const [k, v] of Object.entries(options.headers)) {
+                headers.set(k, v);
+            }
+        }
+        if (_config.workspaceId) {
+            if (!headers.has('Workspace-Id')) {
+                headers.set('Workspace-Id', _config.workspaceId);
+            }
+        }
+        await setAuthHeader(headers, _config, options.security);
+        let body;
+        if (options.body !== undefined) {
+            if (options.bodySerializer) {
+                const serialized = options.bodySerializer(options.body);
+                if (serialized instanceof FormData) {
+                    body = serialized;
+                    headers.delete('Content-Type');
+                }
+                else {
+                    body = serialized;
+                }
+            }
+            else if (options.body instanceof FormData) {
+                body = options.body;
+                headers.delete('Content-Type');
+            }
+            else {
+                body = JSON.stringify(options.body);
+                if (!headers.has('Content-Type')) {
+                    headers.set('Content-Type', 'application/json');
+                }
+            }
+        }
+        else {
+            headers.delete('Content-Type');
+        }
+        if (options.requestValidator) {
+            await options.requestValidator(options);
+        }
+        let req = new Request(url, {
+            method: options.method ?? 'GET',
+            headers,
+            body,
+            redirect: 'follow',
+            credentials: 'include',
+        });
+        for (const fn of interceptors.request._fns) {
+            if (fn)
+                req = await fn(req, options);
+        }
+        let response = await fetchFn(req);
+        for (const fn of interceptors.response._fns) {
+            if (fn)
+                response = await fn(response, req, options);
+        }
+        const result = { request: req, response };
+        if (response.ok) {
+            if (response.status === 204 ||
+                response.headers.get('Content-Length') === '0') {
+                return {
+                    ok: true,
+                    data: {},
+                    error: undefined,
+                    ...result,
+                };
+            }
+            const parseAs = options.parseAs ?? 'json';
+            let data;
+            if (parseAs === 'stream') {
+                return {
+                    ok: true,
+                    data: response.body,
+                    error: undefined,
+                    ...result,
+                };
+            }
+            if (parseAs === 'auto' || parseAs === 'json') {
+                const ct = response.headers.get('Content-Type') ?? '';
+                if (ct.includes('json')) {
+                    data = await response.json();
+                }
+                else {
+                    data = await response.text();
+                }
+            }
+            else {
+                data = await response[parseAs]();
+            }
+            if (parseAs === 'json' && options.responseTransformer) {
+                data = await options.responseTransformer(data);
+            }
+            return {
+                ok: true,
+                data: data,
+                error: undefined,
+                ...result,
+            };
+        }
+        const textError = await response.text();
+        let jsonError;
+        try {
+            jsonError = JSON.parse(textError);
+        }
+        catch { }
+        let error = jsonError ?? textError;
+        for (const fn of interceptors.error._fns) {
+            if (fn)
+                error = await fn(error, response, req, options);
+        }
+        error = error || {};
+        if (options.throwOnError) {
+            throw error;
+        }
+        return {
+            ok: false,
+            data: undefined,
+            error: error,
+            ...result,
+        };
+    };
+    return {
+        getConfig,
+        setConfig,
+        request,
+        get: (options) => request({ ...options, method: 'GET' }),
+        post: (options) => request({ ...options, method: 'POST' }),
+        put: (options) => request({ ...options, method: 'PUT' }),
+        patch: (options) => request({ ...options, method: 'PATCH' }),
+        delete: (options) => request({ ...options, method: 'DELETE' }),
+        interceptors,
+    };
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { createClient } from './client.js';
+export type { Client, ClientConfig, RequestOptions, RequestResult, Options, TDataShape, Config, CreateClientConfig, AuthScheme, InterceptorManager, } from './types.js';
+export declare const client: import("./types.js").Client;

package/dist/runtime/index.js

@@ -0,0 +1,8 @@
+// Runtime client barrel
+export { createClient } from './client.js';
+// Default client instance. Point it elsewhere with `client.setConfig()`.
+import { createClient } from './client.js';
+const defaultConfig = {
+    baseUrl: 'https://api.levr.one',
+};
+export const client = createClient(defaultConfig);

package/dist/runtime/types.d.ts

@@ -0,0 +1,83 @@
+export type AuthScheme = {
+    scheme: string;
+    type: string;
+};
+export interface ClientConfig {
+    baseUrl?: string | (() => string);
+    auth?: ((scheme: AuthScheme) => Promise<string> | string) | string;
+    headers?: Record<string, string>;
+    workspaceId?: string;
+    fetch?: typeof globalThis.fetch;
+}
+export interface RequestOptions {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    security?: ReadonlyArray<AuthScheme>;
+    requestValidator?: (data: unknown) => Promise<unknown>;
+    responseTransformer?: (data: unknown) => Promise<unknown>;
+    throwOnError?: boolean;
+    client?: Client;
+    bodySerializer?: (body: unknown) => string | FormData | undefined;
+    parseAs?: 'json' | 'text' | 'blob' | 'arrayBuffer' | 'stream' | 'auto';
+    responseStyle?: 'data' | 'fields';
+}
+type UnwrapResponse<T> = T extends Record<string, unknown> ? keyof T extends never ? T : T[keyof T] : T;
+export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean> = ThrowOnError extends true ? Promise<{
+    ok: true;
+    data: UnwrapResponse<TData>;
+    request: Request;
+    response: Response;
+}> : Promise<{
+    ok: true;
+    data: UnwrapResponse<TData>;
+    error: undefined;
+    request: Request;
+    response: Response;
+} | {
+    ok: false;
+    data: undefined;
+    error: TError;
+    request: Request;
+    response: Response;
+}>;
+type InterceptorFn<T extends unknown[]> = (...args: T) => Promise<T[0]> | T[0];
+export interface InterceptorManager<T extends unknown[]> {
+    use(fn: InterceptorFn<T>): void;
+    eject(fn: InterceptorFn<T>): void;
+    _fns: Array<InterceptorFn<T> | undefined>;
+}
+type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: Omit<RequestOptions, 'method'>) => RequestResult<TData, TError, ThrowOnError>;
+export interface Client {
+    getConfig(): ClientConfig;
+    setConfig(config: ClientConfig): ClientConfig;
+    request: <TData = unknown, TError = unknown, ThrowOnError extends boolean = false>(options: RequestOptions) => RequestResult<TData, TError, ThrowOnError>;
+    get: MethodFn;
+    post: MethodFn;
+    put: MethodFn;
+    patch: MethodFn;
+    delete: MethodFn;
+    interceptors: {
+        request: InterceptorManager<[Request, RequestOptions]>;
+        response: InterceptorManager<[Response, Request, RequestOptions]>;
+        error: InterceptorManager<[unknown, Response, Request, RequestOptions]>;
+    };
+}
+export interface TDataShape {
+    body?: unknown;
+    headers?: unknown;
+    path?: unknown;
+    query?: unknown;
+    url: string;
+}
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = OmitKeys<RequestOptions, 'body' | 'path' | 'query' | 'url' | 'method'> & Omit<TData, 'url'> & {
+    throwOnError?: ThrowOnError;
+    client?: Client;
+};
+export type Config = ClientConfig;
+export type CreateClientConfig<T = ClientConfig> = (override?: Partial<T>) => T;
+export {};

package/dist/runtime/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@levr-one/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "TypeScript SDK for the Levr API",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/runtime/index.d.ts",
+      "default": "./dist/runtime/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "author": "BitModern",
+  "license": "MIT",
+  "dependencies": {
+    "zod": "^3.25.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BitModern/levr.git",
+    "directory": "packages/sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/BitModern/levr/issues"
+  },
+  "homepage": "https://github.com/BitModern/levr/tree/main/packages/sdk#readme"
+}