local-lite 0.0.21 → 0.0.22

package/dist/storage/manager.js

@@ -12,12 +12,14 @@ class BlobStorageManager {
     uploader;
     network;
     tableName;
+    deleteRemoteOnDelete;
     constructor(db, options = {}) {
         this.db = db;
         this.driver = options.driver ?? new driver_js_1.MemoryFileDriver();
         this.uploader = options.uploader;
         this.network = options.network;
         this.tableName = options.tableName ?? store_js_1.DEFAULT_BLOBS_TABLE;
+        this.deleteRemoteOnDelete = options.deleteRemoteOnDelete ?? false;
     }
     async initialize() {
         await store_js_1.BlobStore.ensureSchema(this.db, this.tableName);
@@ -109,6 +111,148 @@ class BlobStorageManager {
     async delete(key) {
         await this.driver.delete(key);
         await store_js_1.BlobStore.deleteByKey(this.db, this.tableName, key);
+        if (this.deleteRemoteOnDelete && this.uploader && typeof this.uploader.delete === 'function') {
+            try {
+                await this.uploader.delete(key);
+            }
+            catch { }
+        }
+    }
+    /**
+     * Retrieves the remote download/serving URL for a stored blob key.
+     */
+    async getDownloadUrl(key) {
+        const record = await store_js_1.BlobStore.getByKey(this.db, this.tableName, key);
+        if (record?.remoteUrl)
+            return record.remoteUrl;
+        if (this.uploader && typeof this.uploader.getDownloadUrl === 'function') {
+            try {
+                return await this.uploader.getDownloadUrl(key);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Retrieves the local file path or URI (e.g. file:///... on mobile) for a stored blob key.
+     * Ideal for React Native <Image source={{ uri }} /> without loading bytes into JS memory.
+     */
+    async getLocalUri(key) {
+        const record = await store_js_1.BlobStore.getByKey(this.db, this.tableName, key);
+        if (!record)
+            return null;
+        if (typeof this.driver.getUri === 'function') {
+            return await this.driver.getUri(key);
+        }
+        return record.localPath;
+    }
+    /**
+     * Directly imports a file from a local filesystem URI (e.g. expo-image-picker or expo-document-picker)
+     * into local-lite managed storage without having to manually read and encode byte arrays in memory.
+     */
+    async saveFromUri(key, sourceUri, options = {}) {
+        let localPath;
+        let size = 0;
+        let bytes = null;
+        if (typeof this.driver.copyFrom === 'function') {
+            localPath = await this.driver.copyFrom(sourceUri, key);
+            if (typeof this.driver.getSize === 'function') {
+                size = await this.driver.getSize(key);
+            }
+        }
+        else {
+            const res = await fetch(sourceUri);
+            const ab = await res.arrayBuffer();
+            bytes = new Uint8Array(ab);
+            size = bytes.byteLength;
+            localPath = await this.driver.write(key, bytes);
+        }
+        const now = Date.now();
+        const existing = await store_js_1.BlobStore.getByKey(this.db, this.tableName, key);
+        const id = existing ? existing.id : (0, uuid_js_1.generateUUID)();
+        const record = {
+            id,
+            key,
+            name: options.name || key.split('/').pop() || key,
+            mimeType: options.mimeType || 'application/octet-stream',
+            size,
+            localPath,
+            remoteUrl: existing?.remoteUrl || null,
+            status: 'PENDING',
+            metadata: options.metadata || existing?.metadata,
+            createdAt: existing ? existing.createdAt : now,
+            updatedAt: now,
+        };
+        await store_js_1.BlobStore.insertOrUpdate(this.db, this.tableName, record);
+        if (options.autoUpload !== false && this.uploader) {
+            const isOnline = this.network ? await this.network.isOnline() : true;
+            if (isOnline) {
+                try {
+                    if (!bytes) {
+                        bytes = await this.driver.read(key);
+                    }
+                    if (bytes) {
+                        await store_js_1.BlobStore.updateStatus(this.db, this.tableName, id, 'UPLOADING');
+                        const res = await this.uploader.upload(record, bytes);
+                        record.status = 'UPLOADED';
+                        record.remoteUrl = res.remoteUrl;
+                        await store_js_1.BlobStore.updateStatus(this.db, this.tableName, id, 'UPLOADED', res.remoteUrl);
+                    }
+                }
+                catch {
+                    record.status = 'FAILED';
+                    await store_js_1.BlobStore.updateStatus(this.db, this.tableName, id, 'FAILED');
+                }
+            }
+        }
+        return record;
+    }
+    /**
+     * Downloads a remote asset (e.g. from Supabase Storage) and saves it to local disk.
+     * Caches metadata with status 'UPLOADED'.
+     */
+    async download(key, remoteUrl, options = {}) {
+        let localPath;
+        let size = 0;
+        let hash = null;
+        if (typeof this.driver.downloadFrom === 'function') {
+            localPath = await this.driver.downloadFrom(remoteUrl, key);
+            if (typeof this.driver.getSize === 'function') {
+                size = await this.driver.getSize(key);
+            }
+        }
+        else {
+            const res = await fetch(remoteUrl);
+            if (!res.ok) {
+                throw new Error(`Failed to download blob from "${remoteUrl}": ${res.statusText}`);
+            }
+            const ab = await res.arrayBuffer();
+            const bytes = new Uint8Array(ab);
+            size = bytes.byteLength;
+            hash = (0, utils_js_1.bytesToHex)((0, sha2_js_1.sha256)(bytes));
+            localPath = await this.driver.write(key, bytes);
+        }
+        const now = Date.now();
+        const existing = await store_js_1.BlobStore.getByKey(this.db, this.tableName, key);
+        const id = existing ? existing.id : (0, uuid_js_1.generateUUID)();
+        const record = {
+            id,
+            key,
+            name: options.name || key.split('/').pop() || key,
+            mimeType: options.mimeType || 'application/octet-stream',
+            size,
+            localPath,
+            remoteUrl,
+            status: 'UPLOADED',
+            sha256: hash,
+            metadata: options.metadata || existing?.metadata,
+            createdAt: existing ? existing.createdAt : now,
+            updatedAt: now,
+        };
+        await store_js_1.BlobStore.insertOrUpdate(this.db, this.tableName, record);
+        return record;
     }
     /**
      * Flushes and syncs pending or failed uploads to the remote storage uploader.

package/dist/storage/supabase.d.ts

@@ -0,0 +1,44 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import { BlobRecord, RemoteStorageUploader } from './types.js';
+export interface SupabaseStorageUploaderOptions {
+    /**
+     * Supabase Storage bucket name (e.g. 'avatars', 'property-photos', 'documents').
+     */
+    bucket: string;
+    /**
+     * Whether to overwrite existing files on Supabase with the same path/key.
+     * Default: true
+     */
+    upsert?: boolean;
+    /**
+     * Custom path transformation function from local blob key to Supabase Storage path.
+     * By default, returns `key.replace(/^\/+/, '')`.
+     */
+    pathTransform?: (key: string, blob?: BlobRecord) => string;
+    /**
+     * URL format to store in metadata:
+     * - 'public': Uses `supabase.storage.from(bucket).getPublicUrl(path)`
+     * - 'signed': Uses `supabase.storage.from(bucket).createSignedUrl(path, expiresIn)`
+     * Default: 'public'
+     */
+    urlType?: 'public' | 'signed';
+    /**
+     * Expiration duration in seconds when generating signed URLs.
+     * Default: 86400 (24 hours)
+     */
+    signedUrlExpiresIn?: number;
+    /**
+     * Cache control HTTP header for uploaded assets (e.g. '3600').
+     */
+    cacheControl?: string;
+}
+export interface SupabaseStorageUploaderInstance extends RemoteStorageUploader {
+    getPublicUrl(keyOrPath: string): string;
+    createSignedUrl(keyOrPath: string, expiresIn?: number): Promise<string>;
+    getDownloadUrl(keyOrPath: string): Promise<string> | string;
+    delete(keyOrPath: string): Promise<void>;
+}
+/**
+ * Creates a RemoteStorageUploader that syncs binary files to Supabase Storage buckets.
+ */
+export declare function createSupabaseStorageUploader(supabase: SupabaseClient | any, options: SupabaseStorageUploaderOptions): SupabaseStorageUploaderInstance;

package/dist/storage/supabase.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSupabaseStorageUploader = createSupabaseStorageUploader;
+/**
+ * Creates a RemoteStorageUploader that syncs binary files to Supabase Storage buckets.
+ */
+function createSupabaseStorageUploader(supabase, options) {
+    const bucketName = options.bucket;
+    const getBucket = () => {
+        if (typeof supabase.storage?.from === 'function') {
+            return supabase.storage.from(bucketName);
+        }
+        if (typeof supabase.from === 'function') {
+            return supabase.from(bucketName);
+        }
+        throw new Error('Supabase client does not have storage.from() available.');
+    };
+    const resolveRemotePath = (key, blob) => {
+        if (options.pathTransform) {
+            return options.pathTransform(key, blob);
+        }
+        return key.replace(/^\/+/, '');
+    };
+    return {
+        async upload(blob, data) {
+            const bucket = getBucket();
+            const remotePath = resolveRemotePath(blob.key, blob);
+            const uploadOptions = {
+                contentType: blob.mimeType || 'application/octet-stream',
+                upsert: options.upsert !== false,
+            };
+            if (options.cacheControl) {
+                uploadOptions.cacheControl = options.cacheControl;
+            }
+            // Supabase Storage accepts Uint8Array, Buffer, or ArrayBuffer
+            const { error } = await bucket.upload(remotePath, data, uploadOptions);
+            if (error) {
+                throw new Error(`Supabase Storage upload failed for "${remotePath}": ${error.message || JSON.stringify(error)}`);
+            }
+            if (options.urlType === 'signed') {
+                const expiresIn = options.signedUrlExpiresIn ?? 86400;
+                const { data: signedData, error: signedErr } = await bucket.createSignedUrl(remotePath, expiresIn);
+                if (signedErr || !signedData?.signedUrl) {
+                    throw new Error(`Failed to create signed URL for "${remotePath}": ${signedErr?.message || 'unknown error'}`);
+                }
+                return { remoteUrl: signedData.signedUrl };
+            }
+            const { data: publicData } = bucket.getPublicUrl(remotePath);
+            return { remoteUrl: publicData.publicUrl };
+        },
+        getPublicUrl(keyOrPath) {
+            const bucket = getBucket();
+            const remotePath = resolveRemotePath(keyOrPath);
+            const { data } = bucket.getPublicUrl(remotePath);
+            return data.publicUrl;
+        },
+        async createSignedUrl(keyOrPath, expiresIn = 86400) {
+            const bucket = getBucket();
+            const remotePath = resolveRemotePath(keyOrPath);
+            const { data, error } = await bucket.createSignedUrl(remotePath, expiresIn);
+            if (error || !data?.signedUrl) {
+                throw new Error(`Failed to create signed URL for "${remotePath}": ${error?.message || 'unknown error'}`);
+            }
+            return data.signedUrl;
+        },
+        getDownloadUrl(keyOrPath) {
+            if (options.urlType === 'signed') {
+                return this.createSignedUrl(keyOrPath, options.signedUrlExpiresIn);
+            }
+            return this.getPublicUrl(keyOrPath);
+        },
+        async delete(keyOrPath) {
+            const bucket = getBucket();
+            const remotePath = resolveRemotePath(keyOrPath);
+            if (typeof bucket.remove === 'function') {
+                const { error } = await bucket.remove([remotePath]);
+                if (error) {
+                    throw new Error(`Failed to delete "${remotePath}" from Supabase Storage: ${error.message}`);
+                }
+            }
+        },
+    };
+}

package/dist/storage/types.d.ts

@@ -28,12 +28,22 @@ export interface FileDriver {
     read(key: string): Promise<Uint8Array | null>;
     delete(key: string): Promise<void>;
     exists(key: string): Promise<boolean>;
+    getUri?(key: string): Promise<string> | string;
+    copyFrom?(sourceUri: string, key: string): Promise<string>;
+    downloadFrom?(remoteUrl: string, key: string): Promise<string>;
+    getSize?(key: string): Promise<number>;
+}
+export interface RemoteStorageUploadResult {
+    remoteUrl: string;
+    storageId?: string;
+    metadata?: Record<string, any>;
 }
 export interface RemoteStorageUploader {
-    upload(blob: BlobRecord, data: Uint8Array): Promise<{
-        remoteUrl: string;
-    }>;
+    upload(blob: BlobRecord, data: Uint8Array): Promise<RemoteStorageUploadResult>;
+    getDownloadUrl?(keyOrPath: string): Promise<string> | string;
+    delete?(keyOrPath: string): Promise<void>;
 }
+export type StorageProviderType = 'supabase' | 'convex' | 'firebase';
 export interface BlobStorageManagerOptions {
     driver?: FileDriver;
     uploader?: RemoteStorageUploader;
@@ -41,4 +51,20 @@ export interface BlobStorageManagerOptions {
         isOnline(): boolean | Promise<boolean>;
     };
     tableName?: string;
+    /**
+     * If true, calling delete(key) on BlobStorageManager will also attempt to delete
+     * the asset from the remote storage uploader if supported. Default: false
+     */
+    deleteRemoteOnDelete?: boolean;
+    /**
+     * If true, automatically attempts to infer the storage uploader from the client's
+     * remote database adapter (Supabase, Convex, or Firebase) if bucket/mutation options are provided.
+     */
+    autoRemote?: boolean;
+    /** Optional bucket name for Supabase or Firebase Storage */
+    bucket?: string;
+    /** Optional mutation reference for Convex Storage */
+    uploadMutation?: any;
+    /** Additional provider-specific configuration */
+    [key: string]: any;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "local-lite",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "description": "Never let a lost connection break a promise. Local-first sync that faithfully keeps data safe until you're back online.",
   "license": "MIT",
   "main": "dist/index.js",
@@ -144,7 +144,8 @@
     "@supabase/supabase-js": "^2.0.0",
     "better-sqlite3": "^8.0.0",
     "convex": ">=1.0.0",
-    "expo-sqlite": ">=57.0.0",
+    "expo-file-system": ">=58.0.0",
+    "expo-sqlite": ">=58.0.0",
     "firebase": ">=9.0.0",
     "react": ">=18.0.0",
     "sql.js": "^1.8.0"
@@ -162,6 +163,9 @@
     "firebase": {
       "optional": true
     },
+    "expo-file-system": {
+      "optional": true
+    },
     "expo-sqlite": {
       "optional": true
     },