@nexushub/client 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,356 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+
+interface MinimalNexusConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    projectId?: string;
+}
+
+interface NexusConfig extends MinimalNexusConfig {
+    debug?: boolean;
+    cacheStrategy?: 'memory' | 'localStorage' | 'none';
+    revalidateTime?: number;
+    timeout?: number;
+    retries?: number;
+}
+interface NexusConfig {
+    projectId: string;
+    apiUrl: string;
+}
+interface ContentResponse<T = any> {
+    id: string;
+    type: string;
+    data: T;
+    meta: {
+        version: number;
+        updatedAt: string;
+        locale?: string;
+        cacheStatus: 'hit' | 'miss' | 'stale';
+    };
+}
+interface CollectionResponse<T = any> {
+    items: T[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+    meta?: {
+        fetchedAt: string;
+        cacheStatus: string;
+        filters?: Record<string, any>;
+    };
+}
+interface CacheMetadata {
+    timestamp: number;
+    etag?: string;
+    expiresAt: number;
+    tags: string[];
+}
+interface CacheEntry<T = any> {
+    data: T;
+    metadata: CacheMetadata;
+}
+interface CollectionQuery {
+    page?: number;
+    limit?: number;
+    sort?: string;
+    order?: 'asc' | 'desc';
+    filter?: Record<string, any>;
+    fields?: string[];
+    search?: string;
+    include?: string[];
+}
+interface ErrorResponse {
+    code: string;
+    message: string;
+    details?: any;
+    timestamp: string;
+}
+
+declare class ContentEngine {
+    private config;
+    private localCache;
+    private memoryCache;
+    private browserCache?;
+    private rateLimiter;
+    private backoff;
+    private requestBatcher;
+    private defaultRevalidate;
+    private cacheStrategy;
+    private abortController?;
+    private isServer;
+    constructor(config: NexusConfig);
+    /**
+     * Fetch a Singleton Page with enhanced caching
+     */
+    getPage<T = any>(slug: string, options?: {
+        revalidate?: number;
+        tags?: string[];
+        forceRefresh?: boolean;
+        includeMetadata?: boolean;
+    }): Promise<T>;
+    private _getPage;
+    /**
+     * Fetch a Collection with advanced query capabilities
+     */
+    getCollection<T = any>(collectionId: string, query?: CollectionQuery, options?: {
+        revalidate?: number;
+        tags?: string[];
+        forceRefresh?: boolean;
+        includeMetadata?: boolean;
+    }): Promise<CollectionResponse<T>>;
+    private _getCollection;
+    /**
+     * Fetch Global Settings with nested includes support
+     */
+    getGlobals<T = any>(options?: {
+        include?: string[];
+        revalidate?: number;
+        forceRefresh?: boolean;
+    }): Promise<T>;
+    /**
+     * Fetch a single item from a collection
+     */
+    getItem<T = any>(collectionId: string, itemId: string, options?: {
+        revalidate?: number;
+        tags?: string[];
+        include?: string[];
+    }): Promise<T>;
+    /**
+     * Search across collections
+     */
+    search<T = any>(query: string, options?: {
+        collections?: string[];
+        fields?: string[];
+        limit?: number;
+        revalidate?: number;
+    }): Promise<{
+        results: T[];
+        total: number;
+    }>;
+    /**
+     * Prefetch content for better performance
+     */
+    prefetch(urls: string[]): Promise<void>;
+    /**
+     * Invalidate cache by tags
+     */
+    invalidateCache(tags: string[]): void;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        memory: {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        browser: {
+            size: number;
+        } | null;
+        local: {
+            loaded: boolean;
+        };
+    };
+    /**
+     * Cancel ongoing requests
+     */
+    cancelRequests(): void;
+    /**
+     * Subscribe to content updates (SSE)
+     */
+    subscribeToUpdates(callback: (data: any) => void): () => void;
+    private fetchPage;
+    private fetchCollection;
+    private fetchWithTimeout;
+    private applyLocalQuery;
+    private isCacheValid;
+    private getHeaders;
+    private normalizeError;
+    /**
+     * Cleanup resources
+     */
+    private cleanup;
+}
+
+declare class NexusClient {
+    private config;
+    content: ContentEngine;
+    constructor(config?: Partial<NexusConfig>);
+    getPage<T = any>(slug: string, options?: any): Promise<T>;
+    getConfig(): Readonly<NexusConfig>;
+}
+declare const nexus: NexusClient;
+declare const createNexusClient: (config: Partial<NexusConfig>) => NexusClient;
+
+declare const NexusProvider: ({ children, projectId }: {
+    children: React.ReactNode;
+    projectId?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+interface SiteUser {
+    id: string;
+    email: string;
+    name?: string;
+    avatarUrl?: string;
+    role: string;
+    metadata: Record<string, any>;
+}
+interface AuthState {
+    user: SiteUser | null;
+    isLoading: boolean;
+    error: Error | null;
+    isAuthenticated: boolean;
+}
+interface LoginCredentials {
+    email: string;
+    password: string;
+}
+interface RegisterCredentials {
+    email: string;
+    password: string;
+    name?: string;
+    metadata?: Record<string, any>;
+}
+interface AuthContextType extends AuthState {
+    login: (creds: LoginCredentials) => Promise<void>;
+    register: (creds: RegisterCredentials) => Promise<void>;
+    logout: () => Promise<void>;
+    loginWithGoogle: () => void;
+    updateProfile: (data: Partial<SiteUser>) => Promise<void>;
+}
+
+declare const useNexusAuth: () => AuthContextType;
+
+/**
+ * NexusHub Advanced Caching System
+ *
+ * Features:
+ * 1. Multi-layer caching (Memory > Local > Remote)
+ * 2. Cache tagging for precise invalidation
+ * 3. LRU eviction policy
+ * 4. Cache statistics and monitoring
+ * 5. Development mode with filesystem cache
+ */
+interface CacheOptions {
+    maxSize?: number;
+    ttl?: number;
+    tags?: string[];
+    revalidate?: number;
+}
+interface CacheStats {
+    size: number;
+    hits: number;
+    misses: number;
+    hitRate: number;
+    evictions: number;
+}
+declare const CacheTags: {
+    project: (projectId: string) => string;
+    content: (slug: string) => string;
+    collection: (collectionId: string) => string;
+    global: string;
+    user: (userId: string) => string;
+    media: (mediaId: string) => string;
+};
+declare class MemoryCache {
+    private cache;
+    private tagIndex;
+    private stats;
+    private maxSize;
+    private defaultTTL;
+    constructor(options?: CacheOptions);
+    set<T = any>(key: string, data: T, options?: CacheOptions): void;
+    get<T = any>(key: string): {
+        data: T;
+        metadata: any;
+    } | null;
+    delete(key: string): boolean;
+    invalidateByTags(tags: string[]): void;
+    clear(): void;
+    getStats(): CacheStats;
+    private evictLRU;
+    private calculateSize;
+    private updateHitRate;
+}
+declare class LocalCache {
+    private data;
+    private hasLoaded;
+    private cachePath;
+    constructor(customPath?: string);
+    isLoaded(): boolean;
+    private load;
+    getPage(slug: string): any;
+    getCollection(collectionId: string): any[] | null;
+    getGlobals(): any;
+    getAllData(): any;
+    private shouldWarnAboutMissingCache;
+}
+declare class BrowserCache {
+    private projectId;
+    private prefix;
+    private maxSize;
+    private currentSize;
+    constructor(projectId: string);
+    set<T = any>(key: string, data: T, ttl?: number): void;
+    get<T = any>(key: string): T | null;
+    delete(key: string): void;
+    clear(): void;
+    private getStorageKey;
+    private calculateCurrentSize;
+    private calculateStorageSize;
+    private evictOldest;
+}
+
+/**
+ * Advanced strategies for resilience and performance
+ */
+interface RateLimiterConfig {
+    maxRequests: number;
+    timeWindow: number;
+}
+declare class RateLimiter {
+    private requests;
+    private config;
+    constructor(config: RateLimiterConfig);
+    checkLimit(): Promise<void>;
+    getStats(): {
+        currentRequests: number;
+        limit: number;
+    };
+}
+interface BackoffConfig {
+    maxRetries: number;
+    baseDelay: number;
+    maxDelay: number;
+    jitter?: boolean;
+}
+declare class ExponentialBackoff {
+    private config;
+    constructor(config: BackoffConfig);
+    execute<T>(fn: () => Promise<T>, onRetry?: (attempt: number, delay: number, error: Error) => void): Promise<T>;
+    private calculateDelay;
+    private isClientError;
+    private isRateLimitError;
+}
+declare class RequestBatcher {
+    private batchWindow;
+    private maxBatchSize;
+    private batch;
+    private batchTimeout?;
+    private processing;
+    constructor(batchWindow?: number, // milliseconds
+    maxBatchSize?: number);
+    schedule<T>(key: string, request: () => Promise<T>): Promise<T>;
+    private processBatch;
+}
+
+export { type BackoffConfig, BrowserCache, type CacheEntry, type CacheMetadata, type CacheOptions, type CacheStats, CacheTags, type CollectionQuery, type CollectionResponse, ContentEngine, type ContentResponse, type ErrorResponse, ExponentialBackoff, LocalCache, MemoryCache, NexusClient, type NexusConfig, NexusProvider, RateLimiter, type RateLimiterConfig, RequestBatcher, type SiteUser, createNexusClient, nexus, useNexusAuth };

package/dist/index.d.ts

@@ -0,0 +1,356 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+
+interface MinimalNexusConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    projectId?: string;
+}
+
+interface NexusConfig extends MinimalNexusConfig {
+    debug?: boolean;
+    cacheStrategy?: 'memory' | 'localStorage' | 'none';
+    revalidateTime?: number;
+    timeout?: number;
+    retries?: number;
+}
+interface NexusConfig {
+    projectId: string;
+    apiUrl: string;
+}
+interface ContentResponse<T = any> {
+    id: string;
+    type: string;
+    data: T;
+    meta: {
+        version: number;
+        updatedAt: string;
+        locale?: string;
+        cacheStatus: 'hit' | 'miss' | 'stale';
+    };
+}
+interface CollectionResponse<T = any> {
+    items: T[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+    hasNext: boolean;
+    hasPrev: boolean;
+    meta?: {
+        fetchedAt: string;
+        cacheStatus: string;
+        filters?: Record<string, any>;
+    };
+}
+interface CacheMetadata {
+    timestamp: number;
+    etag?: string;
+    expiresAt: number;
+    tags: string[];
+}
+interface CacheEntry<T = any> {
+    data: T;
+    metadata: CacheMetadata;
+}
+interface CollectionQuery {
+    page?: number;
+    limit?: number;
+    sort?: string;
+    order?: 'asc' | 'desc';
+    filter?: Record<string, any>;
+    fields?: string[];
+    search?: string;
+    include?: string[];
+}
+interface ErrorResponse {
+    code: string;
+    message: string;
+    details?: any;
+    timestamp: string;
+}
+
+declare class ContentEngine {
+    private config;
+    private localCache;
+    private memoryCache;
+    private browserCache?;
+    private rateLimiter;
+    private backoff;
+    private requestBatcher;
+    private defaultRevalidate;
+    private cacheStrategy;
+    private abortController?;
+    private isServer;
+    constructor(config: NexusConfig);
+    /**
+     * Fetch a Singleton Page with enhanced caching
+     */
+    getPage<T = any>(slug: string, options?: {
+        revalidate?: number;
+        tags?: string[];
+        forceRefresh?: boolean;
+        includeMetadata?: boolean;
+    }): Promise<T>;
+    private _getPage;
+    /**
+     * Fetch a Collection with advanced query capabilities
+     */
+    getCollection<T = any>(collectionId: string, query?: CollectionQuery, options?: {
+        revalidate?: number;
+        tags?: string[];
+        forceRefresh?: boolean;
+        includeMetadata?: boolean;
+    }): Promise<CollectionResponse<T>>;
+    private _getCollection;
+    /**
+     * Fetch Global Settings with nested includes support
+     */
+    getGlobals<T = any>(options?: {
+        include?: string[];
+        revalidate?: number;
+        forceRefresh?: boolean;
+    }): Promise<T>;
+    /**
+     * Fetch a single item from a collection
+     */
+    getItem<T = any>(collectionId: string, itemId: string, options?: {
+        revalidate?: number;
+        tags?: string[];
+        include?: string[];
+    }): Promise<T>;
+    /**
+     * Search across collections
+     */
+    search<T = any>(query: string, options?: {
+        collections?: string[];
+        fields?: string[];
+        limit?: number;
+        revalidate?: number;
+    }): Promise<{
+        results: T[];
+        total: number;
+    }>;
+    /**
+     * Prefetch content for better performance
+     */
+    prefetch(urls: string[]): Promise<void>;
+    /**
+     * Invalidate cache by tags
+     */
+    invalidateCache(tags: string[]): void;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        memory: {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        browser: {
+            size: number;
+        } | null;
+        local: {
+            loaded: boolean;
+        };
+    };
+    /**
+     * Cancel ongoing requests
+     */
+    cancelRequests(): void;
+    /**
+     * Subscribe to content updates (SSE)
+     */
+    subscribeToUpdates(callback: (data: any) => void): () => void;
+    private fetchPage;
+    private fetchCollection;
+    private fetchWithTimeout;
+    private applyLocalQuery;
+    private isCacheValid;
+    private getHeaders;
+    private normalizeError;
+    /**
+     * Cleanup resources
+     */
+    private cleanup;
+}
+
+declare class NexusClient {
+    private config;
+    content: ContentEngine;
+    constructor(config?: Partial<NexusConfig>);
+    getPage<T = any>(slug: string, options?: any): Promise<T>;
+    getConfig(): Readonly<NexusConfig>;
+}
+declare const nexus: NexusClient;
+declare const createNexusClient: (config: Partial<NexusConfig>) => NexusClient;
+
+declare const NexusProvider: ({ children, projectId }: {
+    children: React.ReactNode;
+    projectId?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+interface SiteUser {
+    id: string;
+    email: string;
+    name?: string;
+    avatarUrl?: string;
+    role: string;
+    metadata: Record<string, any>;
+}
+interface AuthState {
+    user: SiteUser | null;
+    isLoading: boolean;
+    error: Error | null;
+    isAuthenticated: boolean;
+}
+interface LoginCredentials {
+    email: string;
+    password: string;
+}
+interface RegisterCredentials {
+    email: string;
+    password: string;
+    name?: string;
+    metadata?: Record<string, any>;
+}
+interface AuthContextType extends AuthState {
+    login: (creds: LoginCredentials) => Promise<void>;
+    register: (creds: RegisterCredentials) => Promise<void>;
+    logout: () => Promise<void>;
+    loginWithGoogle: () => void;
+    updateProfile: (data: Partial<SiteUser>) => Promise<void>;
+}
+
+declare const useNexusAuth: () => AuthContextType;
+
+/**
+ * NexusHub Advanced Caching System
+ *
+ * Features:
+ * 1. Multi-layer caching (Memory > Local > Remote)
+ * 2. Cache tagging for precise invalidation
+ * 3. LRU eviction policy
+ * 4. Cache statistics and monitoring
+ * 5. Development mode with filesystem cache
+ */
+interface CacheOptions {
+    maxSize?: number;
+    ttl?: number;
+    tags?: string[];
+    revalidate?: number;
+}
+interface CacheStats {
+    size: number;
+    hits: number;
+    misses: number;
+    hitRate: number;
+    evictions: number;
+}
+declare const CacheTags: {
+    project: (projectId: string) => string;
+    content: (slug: string) => string;
+    collection: (collectionId: string) => string;
+    global: string;
+    user: (userId: string) => string;
+    media: (mediaId: string) => string;
+};
+declare class MemoryCache {
+    private cache;
+    private tagIndex;
+    private stats;
+    private maxSize;
+    private defaultTTL;
+    constructor(options?: CacheOptions);
+    set<T = any>(key: string, data: T, options?: CacheOptions): void;
+    get<T = any>(key: string): {
+        data: T;
+        metadata: any;
+    } | null;
+    delete(key: string): boolean;
+    invalidateByTags(tags: string[]): void;
+    clear(): void;
+    getStats(): CacheStats;
+    private evictLRU;
+    private calculateSize;
+    private updateHitRate;
+}
+declare class LocalCache {
+    private data;
+    private hasLoaded;
+    private cachePath;
+    constructor(customPath?: string);
+    isLoaded(): boolean;
+    private load;
+    getPage(slug: string): any;
+    getCollection(collectionId: string): any[] | null;
+    getGlobals(): any;
+    getAllData(): any;
+    private shouldWarnAboutMissingCache;
+}
+declare class BrowserCache {
+    private projectId;
+    private prefix;
+    private maxSize;
+    private currentSize;
+    constructor(projectId: string);
+    set<T = any>(key: string, data: T, ttl?: number): void;
+    get<T = any>(key: string): T | null;
+    delete(key: string): void;
+    clear(): void;
+    private getStorageKey;
+    private calculateCurrentSize;
+    private calculateStorageSize;
+    private evictOldest;
+}
+
+/**
+ * Advanced strategies for resilience and performance
+ */
+interface RateLimiterConfig {
+    maxRequests: number;
+    timeWindow: number;
+}
+declare class RateLimiter {
+    private requests;
+    private config;
+    constructor(config: RateLimiterConfig);
+    checkLimit(): Promise<void>;
+    getStats(): {
+        currentRequests: number;
+        limit: number;
+    };
+}
+interface BackoffConfig {
+    maxRetries: number;
+    baseDelay: number;
+    maxDelay: number;
+    jitter?: boolean;
+}
+declare class ExponentialBackoff {
+    private config;
+    constructor(config: BackoffConfig);
+    execute<T>(fn: () => Promise<T>, onRetry?: (attempt: number, delay: number, error: Error) => void): Promise<T>;
+    private calculateDelay;
+    private isClientError;
+    private isRateLimitError;
+}
+declare class RequestBatcher {
+    private batchWindow;
+    private maxBatchSize;
+    private batch;
+    private batchTimeout?;
+    private processing;
+    constructor(batchWindow?: number, // milliseconds
+    maxBatchSize?: number);
+    schedule<T>(key: string, request: () => Promise<T>): Promise<T>;
+    private processBatch;
+}
+
+export { type BackoffConfig, BrowserCache, type CacheEntry, type CacheMetadata, type CacheOptions, type CacheStats, CacheTags, type CollectionQuery, type CollectionResponse, ContentEngine, type ContentResponse, type ErrorResponse, ExponentialBackoff, LocalCache, MemoryCache, NexusClient, type NexusConfig, NexusProvider, RateLimiter, type RateLimiterConfig, RequestBatcher, type SiteUser, createNexusClient, nexus, useNexusAuth };