@bloque/sdk-core 0.0.1 → 0.0.3

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+import type { Mode } from './types';
+export declare const API_BASE_URLS: Record<Mode, string>;
+export declare const DEFAULT_HEADERS: {
+    'Content-Type': string;
+};

package/dist/errors.d.ts

@@ -0,0 +1,8 @@
+export declare class BloqueAPIError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    constructor(message: string, status?: number, code?: string);
+}
+export declare class BloqueConfigError extends Error {
+    constructor(message: string);
+}

package/dist/http-client.d.ts

@@ -0,0 +1,10 @@
+import type { BloqueConfig, RequestOptions } from './types';
+export declare class HttpClient {
+    private readonly config;
+    private readonly baseUrl;
+    private readonly publicRoutes;
+    constructor(config: BloqueConfig);
+    private isPublicRoute;
+    private validateConfig;
+    request<T, U = unknown>(options: RequestOptions<U>): Promise<T>;
+}

package/dist/index.cjs

@@ -1,5 +1,145 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
 var __webpack_exports__ = {};
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    API_BASE_URLS: ()=>API_BASE_URLS,
+    DEFAULT_HEADERS: ()=>DEFAULT_HEADERS,
+    HttpClient: ()=>HttpClient,
+    BloqueAPIError: ()=>BloqueAPIError,
+    BloqueConfigError: ()=>BloqueConfigError
+});
+const API_BASE_URLS = {
+    sandbox: 'https://dev.bloque.app',
+    production: 'https://api.bloque.app'
+};
+const DEFAULT_HEADERS = {
+    'Content-Type': 'application/json'
+};
+class BloqueAPIError extends Error {
+    status;
+    code;
+    constructor(message, status, code){
+        super(message);
+        this.name = 'BloqueAPIError';
+        this.status = status;
+        this.code = code;
+        Object.setPrototypeOf(this, BloqueAPIError.prototype);
+    }
+}
+class BloqueConfigError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'BloqueConfigError';
+        Object.setPrototypeOf(this, BloqueConfigError.prototype);
+    }
+}
+const createLocalStorageAdapter = ()=>({
+        get: ()=>{
+            if ('undefined' == typeof localStorage) return null;
+            return localStorage.getItem('access_token');
+        },
+        set: (token)=>{
+            if ('undefined' != typeof localStorage) localStorage.setItem('access_token', token);
+        },
+        clear: ()=>{
+            if ('undefined' != typeof localStorage) localStorage.removeItem('access_token');
+        }
+    });
+class HttpClient {
+    config;
+    baseUrl;
+    publicRoutes = [
+        '/api/aliases',
+        '/api/origins/*/assert'
+    ];
+    constructor(config){
+        this.validateConfig(config);
+        this.config = config;
+        this.baseUrl = API_BASE_URLS[config.mode ?? 'production'];
+    }
+    isPublicRoute(path) {
+        const pathWithoutQuery = path.split('?')[0];
+        return this.publicRoutes.some((route)=>{
+            const pattern = route.replace(/\*/g, '[^/]+');
+            const regex = new RegExp(`^${pattern}$`);
+            return regex.test(pathWithoutQuery);
+        });
+    }
+    validateConfig(config) {
+        if (!config.apiKey || '' === config.apiKey.trim()) throw new BloqueConfigError('API key is required');
+        if (!config.mode) config.mode = 'production';
+        if (![
+            'sandbox',
+            'production'
+        ].includes(config.mode)) throw new BloqueConfigError('Mode must be either "sandbox" or "production"');
+        if ('client' === config.runtime && !config.tokenStorage) config.tokenStorage = createLocalStorageAdapter();
+    }
+    async request(options) {
+        const { method, path, body, headers = {} } = options;
+        const url = `${this.baseUrl}${path}`;
+        const requestHeaders = {
+            ...DEFAULT_HEADERS,
+            Authorization: this.config.apiKey,
+            ...headers
+        };
+        if ('client' === this.config.runtime && !this.isPublicRoute(path)) {
+            const token = this.config.tokenStorage?.get();
+            if (!token) throw new BloqueConfigError('Authentication token is missing');
+            requestHeaders.Authorization = `Bearer ${token}`;
+        }
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: requestHeaders,
+                body: body ? JSON.stringify(body) : void 0
+            });
+            const responseData = await response.json().catch(()=>({}));
+            if (!response.ok) {
+                const errorData = responseData;
+                throw new BloqueAPIError(errorData.message || `HTTP ${response.status}: ${response.statusText}`, response.status, errorData.code);
+            }
+            return responseData;
+        } catch (error) {
+            if (error instanceof BloqueAPIError) throw error;
+            if (error instanceof Error) throw new BloqueAPIError(`Request failed: ${error.message}`, void 0, 'NETWORK_ERROR');
+            throw new BloqueAPIError('Unknown error occurred', void 0, 'UNKNOWN_ERROR');
+        }
+    }
+}
+exports.API_BASE_URLS = __webpack_exports__.API_BASE_URLS;
+exports.BloqueAPIError = __webpack_exports__.BloqueAPIError;
+exports.BloqueConfigError = __webpack_exports__.BloqueConfigError;
+exports.DEFAULT_HEADERS = __webpack_exports__.DEFAULT_HEADERS;
+exports.HttpClient = __webpack_exports__.HttpClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "API_BASE_URLS",
+    "BloqueAPIError",
+    "BloqueConfigError",
+    "DEFAULT_HEADERS",
+    "HttpClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './errors';
+export * from './http-client';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,99 @@
+const API_BASE_URLS = {
+    sandbox: 'https://dev.bloque.app',
+    production: 'https://api.bloque.app'
+};
+const DEFAULT_HEADERS = {
+    'Content-Type': 'application/json'
+};
+class BloqueAPIError extends Error {
+    status;
+    code;
+    constructor(message, status, code){
+        super(message);
+        this.name = 'BloqueAPIError';
+        this.status = status;
+        this.code = code;
+        Object.setPrototypeOf(this, BloqueAPIError.prototype);
+    }
+}
+class BloqueConfigError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'BloqueConfigError';
+        Object.setPrototypeOf(this, BloqueConfigError.prototype);
+    }
+}
+const createLocalStorageAdapter = ()=>({
+        get: ()=>{
+            if ('undefined' == typeof localStorage) return null;
+            return localStorage.getItem('access_token');
+        },
+        set: (token)=>{
+            if ('undefined' != typeof localStorage) localStorage.setItem('access_token', token);
+        },
+        clear: ()=>{
+            if ('undefined' != typeof localStorage) localStorage.removeItem('access_token');
+        }
+    });
+class HttpClient {
+    config;
+    baseUrl;
+    publicRoutes = [
+        '/api/aliases',
+        '/api/origins/*/assert'
+    ];
+    constructor(config){
+        this.validateConfig(config);
+        this.config = config;
+        this.baseUrl = API_BASE_URLS[config.mode ?? 'production'];
+    }
+    isPublicRoute(path) {
+        const pathWithoutQuery = path.split('?')[0];
+        return this.publicRoutes.some((route)=>{
+            const pattern = route.replace(/\*/g, '[^/]+');
+            const regex = new RegExp(`^${pattern}$`);
+            return regex.test(pathWithoutQuery);
+        });
+    }
+    validateConfig(config) {
+        if (!config.apiKey || '' === config.apiKey.trim()) throw new BloqueConfigError('API key is required');
+        if (!config.mode) config.mode = 'production';
+        if (![
+            'sandbox',
+            'production'
+        ].includes(config.mode)) throw new BloqueConfigError('Mode must be either "sandbox" or "production"');
+        if ('client' === config.runtime && !config.tokenStorage) config.tokenStorage = createLocalStorageAdapter();
+    }
+    async request(options) {
+        const { method, path, body, headers = {} } = options;
+        const url = `${this.baseUrl}${path}`;
+        const requestHeaders = {
+            ...DEFAULT_HEADERS,
+            Authorization: this.config.apiKey,
+            ...headers
+        };
+        if ('client' === this.config.runtime && !this.isPublicRoute(path)) {
+            const token = this.config.tokenStorage?.get();
+            if (!token) throw new BloqueConfigError('Authentication token is missing');
+            requestHeaders.Authorization = `Bearer ${token}`;
+        }
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: requestHeaders,
+                body: body ? JSON.stringify(body) : void 0
+            });
+            const responseData = await response.json().catch(()=>({}));
+            if (!response.ok) {
+                const errorData = responseData;
+                throw new BloqueAPIError(errorData.message || `HTTP ${response.status}: ${response.statusText}`, response.status, errorData.code);
+            }
+            return responseData;
+        } catch (error) {
+            if (error instanceof BloqueAPIError) throw error;
+            if (error instanceof Error) throw new BloqueAPIError(`Request failed: ${error.message}`, void 0, 'NETWORK_ERROR');
+            throw new BloqueAPIError('Unknown error occurred', void 0, 'UNKNOWN_ERROR');
+        }
+    }
+}
+export { API_BASE_URLS, BloqueAPIError, BloqueConfigError, DEFAULT_HEADERS, HttpClient };

package/dist/types.d.ts

@@ -0,0 +1,124 @@
+export type Mode = 
+/**
+ * Production environment.
+ *
+ * Uses live endpoints and real data.
+ * This is the default mode.
+ */
+'production'
+/**
+ * Sandbox environment.
+ *
+ * Uses isolated endpoints and mock data for development and testing.
+ */
+ | 'sandbox';
+export type Runtime = 
+/**
+ * Server runtime (default).
+ *
+ * Intended for backend environments such as Node.js, Bun,
+ * Deno, Edge runtimes, or any server-side execution context.
+ *
+ * Allows the use of private API keys.
+ */
+'server'
+/**
+ * Client runtime.
+ *
+ * Intended for browsers or frontend runtimes.
+ *
+ * In the current version of the SDK:
+ * - The client authenticates using the `auth` module.
+ * - The SDK automatically obtains and manages a JWT.
+ * - The JWT is used to authenticate all subsequent requests.
+ * - An authenticated client can execute any operation
+ *   exposed by the API.
+ *
+ * Authorization and security enforcement are handled
+ * exclusively by the backend.
+ */
+ | 'client';
+/**
+ * Interface that defines how the SDK stores and retrieves
+ * the JWT token when running in `client` runtime.
+ *
+ * This allows consumers to customize the storage mechanism
+ * (localStorage, sessionStorage, cookies, in-memory, etc.).
+ */
+export interface TokenStorage {
+    /**
+     * Retrieves the currently stored JWT.
+     *
+     * @returns The JWT token, or `null` if no token is stored.
+     */
+    get(): string | null;
+    /**
+     * Persists a JWT token.
+     *
+     * @param token The JWT token to store.
+     */
+    set(token: string): void;
+    /**
+     * Clears the stored JWT token.
+     */
+    clear(): void;
+}
+/**
+ * Main configuration object for the Bloque SDK.
+ *
+ * This configuration is resolved once when initializing
+ * the SDK (via `new SDK()` or `init()` in the modular API).
+ */
+export interface BloqueConfig {
+    /**
+     * Bloque API key.
+     *
+     * - In `server` runtime, a private API key is expected.
+     * - In `client` runtime, the API key is not used directly;
+     *   authentication is performed via JWT instead.
+     */
+    apiKey: string;
+    /**
+     * SDK operation mode.
+     *
+     * - `production` (default): production environment.
+     * - `sandbox`: sandbox environment.
+     *
+     * If not specified, the SDK defaults to `production`.
+     */
+    mode?: Mode;
+    /**
+     * Runtime environment where the SDK is executed.
+     *
+     * - `server` (default): backend runtime using API keys.
+     * - `client`: frontend runtime using JWT authentication.
+     *
+     * If not specified, the SDK defaults to `server`.
+     */
+    runtime?: 'server' | 'client';
+    /**
+     * JWT token storage strategy.
+     *
+     * Only applies when `runtime` is set to `client`.
+     *
+     * By default, the SDK uses `localStorage` to persist
+     * the JWT token. This behavior can be overridden to
+     * use alternative storage mechanisms.
+     */
+    tokenStorage?: TokenStorage;
+}
+export interface RequestOptions<U = unknown> {
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    body?: U;
+    headers?: Record<string, string>;
+}
+export interface BloqueResponse<T> {
+    data?: T;
+    error?: BloqueError;
+}
+export interface BloqueError {
+    message: string;
+    code?: string;
+    status?: number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bloque/sdk-core",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Core utilities and types for Bloque SDK.",
   "type": "module",
   "keywords": [