astro-tokenkit 1.0.0

package/dist/client/client.js

@@ -0,0 +1,293 @@
+// packages/astro-tokenkit/src/client/client.ts
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { APIError, AuthError, NetworkError, TimeoutError } from '../types';
+import { TokenManager } from '../auth/manager';
+import { getContext } from './context';
+import { calculateDelay, shouldRetry, sleep } from '../utils/retry';
+/**
+ * API Client
+ */
+export class APIClient {
+    constructor(config) {
+        this.config = config;
+        this.contextOptions = {
+            context: config.context,
+            getContextStore: config.getContextStore,
+        };
+        // Initialize token manager if auth is configured
+        if (config.auth) {
+            this.tokenManager = new TokenManager(config.auth, config.baseURL);
+        }
+    }
+    /**
+     * GET request
+     */
+    get(url, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign({ method: 'GET', url }, options));
+        });
+    }
+    /**
+     * POST request
+     */
+    post(url, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign({ method: 'POST', url,
+                data }, options));
+        });
+    }
+    /**
+     * PUT request
+     */
+    put(url, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign({ method: 'PUT', url,
+                data }, options));
+        });
+    }
+    /**
+     * PATCH request
+     */
+    patch(url, data, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign({ method: 'PATCH', url,
+                data }, options));
+        });
+    }
+    /**
+     * DELETE request
+     */
+    delete(url, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request(Object.assign({ method: 'DELETE', url }, options));
+        });
+    }
+    /**
+     * Generic request method
+     */
+    request(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ctx = getContext(config.ctx, this.contextOptions);
+            let attempt = 0;
+            let lastError;
+            while (true) {
+                attempt++;
+                try {
+                    const response = yield this.executeRequest(config, ctx, attempt);
+                    return response.data;
+                }
+                catch (error) {
+                    lastError = error;
+                    // Check if we should retry
+                    if (shouldRetry(error.status, attempt, this.config.retry)) {
+                        const delay = calculateDelay(attempt, this.config.retry);
+                        yield sleep(delay);
+                        continue;
+                    }
+                    // No more retries
+                    throw error;
+                }
+            }
+        });
+    }
+    /**
+     * Execute single request
+     */
+    executeRequest(config, ctx, attempt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e;
+            // Ensure valid session (if auth is enabled)
+            if (this.tokenManager && !config.skipAuth) {
+                yield this.tokenManager.ensure(ctx);
+            }
+            // Build full URL
+            const fullURL = this.buildURL(config.url, config.params);
+            // Build headers
+            const headers = this.buildHeaders(config, ctx);
+            // Build request init
+            const init = {
+                method: config.method,
+                headers,
+                signal: config.signal,
+            };
+            // Add body for non-GET requests
+            if (config.data && config.method !== 'GET') {
+                init.body = JSON.stringify(config.data);
+            }
+            // Apply request interceptors
+            let requestConfig = Object.assign({}, config);
+            if ((_a = this.config.interceptors) === null || _a === void 0 ? void 0 : _a.request) {
+                for (const interceptor of this.config.interceptors.request) {
+                    requestConfig = yield interceptor(requestConfig, ctx);
+                }
+            }
+            // Execute fetch with timeout
+            const timeout = (_c = (_b = config.timeout) !== null && _b !== void 0 ? _b : this.config.timeout) !== null && _c !== void 0 ? _c : 30000;
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeout);
+            try {
+                const response = yield fetch(fullURL, Object.assign(Object.assign({}, init), { signal: controller.signal }));
+                clearTimeout(timeoutId);
+                // Handle 401 (try refresh and retry once)
+                if (response.status === 401 && this.tokenManager && !config.skipAuth && attempt === 1) {
+                    // Clear and try fresh session
+                    const session = yield this.tokenManager.ensure(ctx);
+                    if (session) {
+                        // Retry with new token
+                        return this.executeRequest(config, ctx, attempt + 1);
+                    }
+                }
+                // Parse response
+                const apiResponse = yield this.parseResponse(response, fullURL);
+                // Apply response interceptors
+                if ((_d = this.config.interceptors) === null || _d === void 0 ? void 0 : _d.response) {
+                    let interceptedResponse = apiResponse;
+                    for (const interceptor of this.config.interceptors.response) {
+                        interceptedResponse = yield interceptor(interceptedResponse, ctx);
+                    }
+                    return interceptedResponse;
+                }
+                return apiResponse;
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                // Apply error interceptors
+                if ((_e = this.config.interceptors) === null || _e === void 0 ? void 0 : _e.error) {
+                    for (const interceptor of this.config.interceptors.error) {
+                        yield interceptor(error, ctx);
+                    }
+                }
+                // Transform errors
+                if (error instanceof Error && error.name === 'AbortError') {
+                    throw new TimeoutError(`Request timeout after ${timeout}ms`, requestConfig);
+                }
+                if (error instanceof APIError) {
+                    throw error;
+                }
+                throw new NetworkError(error.message, requestConfig);
+            }
+        });
+    }
+    /**
+     * Parse response
+     */
+    parseResponse(response, url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let data;
+            // Try to parse JSON
+            const contentType = response.headers.get('content-type');
+            if (contentType === null || contentType === void 0 ? void 0 : contentType.includes('application/json')) {
+                try {
+                    data = yield response.json();
+                }
+                catch (_a) {
+                    data = (yield response.text());
+                }
+            }
+            else {
+                data = (yield response.text());
+            }
+            // Check if response is ok
+            if (!response.ok) {
+                if (response.status === 401 || response.status === 403) {
+                    throw new AuthError(`Authentication failed: ${response.status} ${response.statusText}`, response.status, data);
+                }
+                throw new APIError(`Request failed: ${response.status} ${response.statusText}`, response.status, data);
+            }
+            return {
+                data,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers,
+                url,
+            };
+        });
+    }
+    /**
+     * Build full URL with query params
+     */
+    buildURL(url, params) {
+        const fullURL = url.startsWith('http') ? url : this.config.baseURL + url;
+        if (!params)
+            return fullURL;
+        const urlObj = new URL(fullURL);
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                urlObj.searchParams.append(key, String(value));
+            }
+        });
+        return urlObj.toString();
+    }
+    /**
+     * Build request headers
+     */
+    buildHeaders(config, ctx) {
+        var _a, _b;
+        const headers = Object.assign(Object.assign({ 'Content-Type': 'application/json' }, this.config.headers), config.headers);
+        // Add auth token if available
+        if (this.tokenManager && !config.skipAuth) {
+            const session = this.tokenManager.getSession(ctx);
+            if (session === null || session === void 0 ? void 0 : session.accessToken) {
+                const injectFn = (_b = (_a = this.config.auth) === null || _a === void 0 ? void 0 : _a.injectToken) !== null && _b !== void 0 ? _b : ((token) => `Bearer ${token}`);
+                headers['Authorization'] = injectFn(session.accessToken);
+            }
+        }
+        return headers;
+    }
+    /**
+     * Login
+     */
+    login(credentials, ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tokenManager) {
+                throw new Error('Auth is not configured for this client');
+            }
+            const context = getContext(ctx, this.contextOptions);
+            yield this.tokenManager.login(context, credentials);
+        });
+    }
+    /**
+     * Logout
+     */
+    logout(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.tokenManager) {
+                throw new Error('Auth is not configured for this client');
+            }
+            const context = getContext(ctx, this.contextOptions);
+            yield this.tokenManager.logout(context);
+        });
+    }
+    /**
+     * Check if authenticated
+     */
+    isAuthenticated(ctx) {
+        if (!this.tokenManager)
+            return false;
+        const context = getContext(ctx, this.contextOptions);
+        return this.tokenManager.isAuthenticated(context);
+    }
+    /**
+     * Get current session
+     */
+    getSession(ctx) {
+        if (!this.tokenManager)
+            return null;
+        const context = getContext(ctx, this.contextOptions);
+        return this.tokenManager.getSession(context);
+    }
+}
+/**
+ * Create API client
+ */
+export function createClient(config) {
+    return new APIClient(config);
+}

package/dist/client/context-shared.d.ts

@@ -0,0 +1,17 @@
+import type { TokenKitContext } from '../types';
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * Configure shared AsyncLocalStorage
+ *
+ * @param storage - Shared AsyncLocalStorage instance
+ * @param key - Key to access Astro context in the storage
+ */
+export declare function setSharedContextStorage(storage: AsyncLocalStorage<any>, key?: string): void;
+/**
+ * Get context from shared storage
+ */
+export declare function getContext(explicitCtx?: TokenKitContext): TokenKitContext;
+/**
+ * Bind context (only needed if not using shared storage)
+ */
+export declare function bindContext<T>(ctx: TokenKitContext, fn: () => T): T;

package/dist/client/context-shared.js

@@ -0,0 +1,60 @@
+// packages/astro-tokenkit/src/client/context-shared.ts
+/**
+ * OPTION: Share AsyncLocalStorage with other libraries
+ *
+ * If you have another library (like SessionKit) that uses AsyncLocalStorage,
+ * you can share the same instance to avoid performance overhead.
+ *
+ * Usage:
+ *
+ * // In your shared context file:
+ * import { AsyncLocalStorage } from 'node:async_hooks';
+ * export const appContext = new AsyncLocalStorage<{ astro: TokenKitContext }>();
+ *
+ * // Then configure TokenKit to use it:
+ * import { setSharedContextStorage } from 'astro-tokenkit';
+ * import { appContext } from './shared-context';
+ *
+ * setSharedContextStorage(appContext, 'astro');
+ */
+let sharedStorage = null;
+let contextKey = null;
+/**
+ * Configure shared AsyncLocalStorage
+ *
+ * @param storage - Shared AsyncLocalStorage instance
+ * @param key - Key to access Astro context in the storage
+ */
+export function setSharedContextStorage(storage, key = 'astro') {
+    sharedStorage = storage;
+    contextKey = key;
+}
+/**
+ * Get context from shared storage
+ */
+export function getContext(explicitCtx) {
+    if (explicitCtx) {
+        return explicitCtx;
+    }
+    if (sharedStorage && contextKey) {
+        const store = sharedStorage.getStore();
+        const ctx = store === null || store === void 0 ? void 0 : store[contextKey];
+        if (ctx) {
+            return ctx;
+        }
+    }
+    throw new Error('Astro context not found. Either:\n' +
+        '1. Pass context explicitly: api.get("/path", { ctx: Astro })\n' +
+        '2. Configure shared storage: setSharedContextStorage(storage, "key")');
+}
+/**
+ * Bind context (only needed if not using shared storage)
+ */
+export function bindContext(ctx, fn) {
+    if (sharedStorage && contextKey) {
+        const currentStore = sharedStorage.getStore() || {};
+        return sharedStorage.run(Object.assign(Object.assign({}, currentStore), { [contextKey]: ctx }), fn);
+    }
+    // Fallback: context must be passed explicitly
+    return fn();
+}

package/dist/client/context.d.ts

@@ -0,0 +1,21 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { TokenKitContext } from '../types';
+/**
+ * Configuration for context handling
+ */
+export interface ContextOptions {
+    context?: AsyncLocalStorage<any>;
+    getContextStore?: () => TokenKitContext | undefined | null;
+}
+/**
+ * Bind Astro context for the current async scope
+ */
+export declare function bindContext<T>(ctx: TokenKitContext, fn: () => T, options?: ContextOptions): T;
+/**
+ * Get current Astro context (from middleware binding or explicit)
+ */
+export declare function getContext(explicitCtx?: TokenKitContext, options?: ContextOptions): TokenKitContext;
+/**
+ * Check if context is available
+ */
+export declare function hasContext(explicitCtx?: TokenKitContext, options?: ContextOptions): boolean;

package/dist/client/context.js

@@ -0,0 +1,37 @@
+// packages/astro-tokenkit/src/client/context.ts
+import { AsyncLocalStorage } from 'node:async_hooks';
+/**
+ * Async local storage for Astro context
+ */
+const defaultContextStorage = new AsyncLocalStorage();
+/**
+ * Bind Astro context for the current async scope
+ */
+export function bindContext(ctx, fn, options) {
+    const storage = (options === null || options === void 0 ? void 0 : options.context) || defaultContextStorage;
+    return storage.run(ctx, fn);
+}
+/**
+ * Get current Astro context (from middleware binding or explicit)
+ */
+export function getContext(explicitCtx, options) {
+    const store = (options === null || options === void 0 ? void 0 : options.getContextStore)
+        ? options.getContextStore()
+        : ((options === null || options === void 0 ? void 0 : options.context) || defaultContextStorage).getStore();
+    const ctx = explicitCtx || store;
+    if (!ctx) {
+        throw new Error('Astro context not found. Either:\n' +
+            '1. Use api.middleware() to bind context automatically, or\n' +
+            '2. Pass context explicitly: api.get("/path", { ctx: Astro })');
+    }
+    return ctx;
+}
+/**
+ * Check if context is available
+ */
+export function hasContext(explicitCtx, options) {
+    const store = (options === null || options === void 0 ? void 0 : options.getContextStore)
+        ? options.getContextStore()
+        : ((options === null || options === void 0 ? void 0 : options.context) || defaultContextStorage).getStore();
+    return !!(explicitCtx || store);
+}