@undefineds.co/xpod 0.1.7 → 0.2.0

package/dist/storage/accessors/TieredMinioDataAccessor.d.ts

@@ -1,150 +0,0 @@
-import type { Readable } from 'node:stream';
-import { RepresentationMetadata } from '@solid/community-server';
-import type { Guarded } from '@solid/community-server';
-import type { FileIdentifierMapper, ResourceLink } from '@solid/community-server';
-import type { ResourceIdentifier, Representation, MetadataRecord } from '@solid/community-server';
-import type { MigratableDataAccessor, MigrationProgress } from '../MigratableDataAccessor';
-interface TieredMinioDataAccessorConfig {
-    resourceMapper: FileIdentifierMapper;
-    accessKey: string;
-    secretKey: string;
-    endpoint: string;
-    bucketName: string;
-    cachePath: string;
-    cacheMaxSize: number;
-    /** Current region identifier (e.g., "bj", "gz", "sh") */
-    region?: string;
-    /** Map of region identifier to bucket name for cross-region migration */
-    regionBuckets?: Record<string, string>;
-}
-/**
- * TieredMinioDataAccessor extends MinioDataAccessor with a local cache layer.
- *
- * Read: Check local cache first, if miss then fetch from COS and cache locally.
- * Write: Write to COS first (ensure durability), then cache locally.
- *
- * Uses LRU eviction when cache exceeds maxSize.
- *
- * Supports cross-region migration via MigratableDataAccessor interface.
- */
-export declare class TieredMinioDataAccessor implements MigratableDataAccessor {
-    protected readonly logger: import("global-logger-factory").Logger<unknown>;
-    protected readonly resourceMapper: FileIdentifierMapper;
-    private readonly client;
-    private readonly bucketName;
-    private readonly cachePath;
-    private readonly cacheMaxSize;
-    private readonly region?;
-    private readonly regionBuckets;
-    private readonly cacheEntries;
-    private currentCacheSize;
-    private readonly activeSyncs;
-    constructor(config: TieredMinioDataAccessorConfig);
-    /**
-     * Scan existing cache directory and populate cache entries map.
-     */
-    private initializeCacheTracking;
-    private scanCacheDir;
-    /**
-     * Convert URL path to local cache file path.
-     */
-    private getCacheFilePath;
-    /**
-     * Check if file exists in local cache.
-     */
-    private isCached;
-    /**
-     * Update LRU access time for a cache entry.
-     */
-    private touchCache;
-    /**
-     * Add file to cache tracking.
-     */
-    private addToCacheTracking;
-    /**
-     * Remove file from cache tracking.
-     */
-    private removeFromCacheTracking;
-    /**
-     * Evict least recently used files until cache is under maxSize.
-     */
-    private evictIfNeeded;
-    private formatBytes;
-    canHandle(representation: Representation): Promise<void>;
-    /**
-     * Get data with cache-first strategy and cross-region fallback.
-     *
-     * Read order:
-     * 1. Local cache (fastest)
-     * 2. Local bucket (current region)
-     * 3. Fallback buckets (other regions) - enables instant migration
-     *
-     * When reading from fallback bucket, optionally copy to local bucket (lazy migration).
-     */
-    getData(identifier: ResourceIdentifier): Promise<Guarded<Readable>>;
-    /**
-     * Fetch data from a specific bucket.
-     */
-    private fetchFromBucket;
-    /**
-     * Try to fetch data from fallback buckets (other regions).
-     * Returns the data and source bucket name, or null if not found.
-     */
-    private fetchFromFallbackBuckets;
-    /**
-     * Write data to local cache.
-     */
-    private writeToCache;
-    /**
-     * Lazily copy data to local bucket for future reads.
-     * This runs in the background and doesn't block the read.
-     */
-    private lazyCopyToLocalBucket;
-    getMetadata(identifier: ResourceIdentifier): Promise<RepresentationMetadata>;
-    getChildren(identifier: ResourceIdentifier): AsyncIterableIterator<RepresentationMetadata>;
-    /**
-     * Write document: COS first (durability), then cache.
-     */
-    writeDocument(identifier: ResourceIdentifier, data: Guarded<Readable>, metadata: RepresentationMetadata): Promise<void>;
-    writeContainer(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
-    writeMetadata(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
-    deleteResource(identifier: ResourceIdentifier): Promise<void>;
-    private getFileMetadata;
-    private getDirectoryMetadata;
-    private getBaseMetadata;
-    private addPosixMetadata;
-    protected encodeMetadata(link: ResourceLink, metadata: RepresentationMetadata): object | null;
-    protected decodeMetadata(link: ResourceLink, metadata: MetadataRecord): RepresentationMetadata;
-    getCacheStats(): {
-        entries: number;
-        size: number;
-        maxSize: number;
-    };
-    /**
-     * Check if migration is supported.
-     * Migration requires region configuration and region-to-bucket mapping.
-     */
-    supportsMigration(): boolean;
-    /**
-     * Migrate all objects under the given prefix to a target region's bucket.
-     * Uses Minio server-side copy for efficiency (data doesn't pass through this node).
-     */
-    migrateToRegion(prefix: string, targetRegion: string, onProgress?: (progress: MigrationProgress) => void): Promise<void>;
-    /**
-     * Set up real-time sync during migration.
-     *
-     * Note: Full implementation would use Minio Bucket Notifications to replicate
-     * new writes to the target bucket. For now, we track active syncs and replicate
-     * writes in writeDocument().
-     */
-    setupRealtimeSync(prefix: string, targetRegion: string): Promise<void>;
-    /**
-     * Stop real-time sync after migration completes.
-     */
-    stopRealtimeSync(prefix: string, targetRegion: string): Promise<void>;
-    /**
-     * Check if a write should be replicated to sync targets.
-     */
-    private getActiveSyncTargets;
-}
-export {};