nexabase-console 2.0.5 → 2.0.6

package/dist/storage/Storage.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from 'axios';
-import { UploadMetadata, StorageMetadata } from './types';
+import { UploadMetadata, StorageMetadata, SettableMetadata, ListOptions, ListResult } from './types';
 import { UploadOptions } from '../types/index';
 import { UploadTask } from './UploadTask';
 import { IStorageReference } from './StorageReference';
@@ -8,9 +8,9 @@ export declare class Storage {
     private client;
     emulatorUrl?: string;
     constructor(projectId: string, client: AxiosInstance);
-    ref(path: string): IStorageReference;
+    ref(path?: string): IStorageReference;
     refFromURL(url: string): IStorageReference;
-    createUploadTask(path: string, file: File | Blob, metadata?: UploadMetadata): UploadTask;
+    createUploadTask(path: string, file: Blob, metadata?: UploadMetadata): UploadTask;
     uploadFile(path: string, file: File | Blob, options?: UploadOptions): Promise<{
         url: string;
         path: string;
@@ -21,8 +21,8 @@ export declare class Storage {
         message?: string;
     }>;
     getMetadata(path: string): Promise<StorageMetadata>;
-    updateMetadata(path: string, metadata: Partial<StorageMetadata>): Promise<StorageMetadata>;
-    list(path: string, options?: any): Promise<any>;
+    updateMetadata(path: string, metadata: SettableMetadata): Promise<StorageMetadata>;
+    list(path: string, options?: ListOptions): Promise<ListResult>;
 }
-export declare const getStorage: (app: any) => Storage;
+export declare const getStorage: (app?: any) => Storage;
 export declare const connectStorageEmulator: (storage: Storage, host: string, port: number) => void;

package/dist/storage/Storage.js

@@ -9,15 +9,16 @@ class Storage {
         this.projectId = projectId;
         this.client = client;
     }
-    ref(path) {
+    ref(path = '') {
         return new StorageReference_1.StorageReferenceImpl(path, this);
     }
     refFromURL(url) {
-        const match = url.match(/storage\/([^?]*)/);
+        // Handle both NexaBase and standard URL paths
+        const match = url.match(/[?&]path=([^&]+)/) || url.match(/storage\/file\/([^?]+)/) || url.match(/storage\/([^?]+)/);
         if (match && match[1]) {
             return this.ref(decodeURIComponent(match[1]));
         }
-        throw new NexaStorageError_1.NexaStorageError('storage/invalid-path', 'Invalid storage URL');
+        throw new NexaStorageError_1.NexaStorageError('storage/invalid-path', 'Invalid storage URL format');
     }
     createUploadTask(path, file, metadata) {
         const task = new UploadTask_1.UploadTask(this.projectId, this.client, path, file, metadata);
@@ -35,11 +36,24 @@ class Storage {
     async getDownloadURL(path) {
         try {
             const res = await this.client.get(`/api/project/${this.projectId}/storage/url?path=${encodeURIComponent(path)}`);
-            return res.data.url;
+            let url = res.data.downloadUrl || res.data.url;
+            // If the backend returns a relative URL, build full absolute URL using client baseURL or window.location.origin
+            if (url && !url.startsWith('http://') && !url.startsWith('https://')) {
+                let baseUrl = this.client.defaults.baseURL || '';
+                if (!baseUrl && typeof window !== 'undefined' && window.location) {
+                    baseUrl = window.location.origin;
+                }
+                if (baseUrl) {
+                    const cleanBase = baseUrl.replace(/\/+$/, '');
+                    const cleanPath = url.startsWith('/') ? url : `/${url}`;
+                    url = `${cleanBase}${cleanPath}`;
+                }
+            }
+            return url;
         }
         catch (err) {
             if (err.response) {
-                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message, err.response.status);
             }
             throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
@@ -51,7 +65,7 @@ class Storage {
         }
         catch (err) {
             if (err.response) {
-                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message, err.response.status);
             }
             throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
@@ -62,8 +76,9 @@ class Storage {
             return res.data;
         }
         catch (err) {
-            if (err.response)
-                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+            if (err.response) {
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message, err.response.status);
+            }
             throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
     }
@@ -73,19 +88,26 @@ class Storage {
             return res.data;
         }
         catch (err) {
-            if (err.response)
-                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+            if (err.response) {
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message, err.response.status);
+            }
             throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
     }
     async list(path, options) {
         try {
-            const res = await this.client.get(`/api/project/${this.projectId}/storage/list?path=${encodeURIComponent(path)}`);
+            const params = new URLSearchParams();
+            if (path)
+                params.append('path', path);
+            if (options?.maxResults)
+                params.append('maxResults', options.maxResults.toString());
+            const res = await this.client.get(`/api/project/${this.projectId}/storage/list?${params.toString()}`);
             return res.data;
         }
         catch (err) {
-            if (err.response)
-                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message);
+            if (err.response) {
+                throw new NexaStorageError_1.NexaStorageError(err.response.data?.error?.code || 'storage/server-error', err.response.data?.error?.message || err.message, err.response.status);
+            }
             throw new NexaStorageError_1.NexaStorageError('storage/network-error', err.message);
         }
     }
@@ -95,7 +117,13 @@ const getStorage = (app) => {
     if (app && typeof app.storage === 'function') {
         return app.storage();
     }
-    throw new Error('Invalid NexaApp instance provided to getStorage()');
+    if (app && app.storageService) {
+        return app.storageService;
+    }
+    if (app instanceof Storage) {
+        return app;
+    }
+    throw new Error('NexaApp instance is required for getStorage(app)');
 };
 exports.getStorage = getStorage;
 const connectStorageEmulator = (storage, host, port) => {
@@ -103,7 +131,6 @@ const connectStorageEmulator = (storage, host, port) => {
         throw new Error('Emulator already connected.');
     }
     storage.emulatorUrl = `http://${host}:${port}`;
-    // Modify the axios client inside storage to point to emulator
     const client = storage.client;
     if (client) {
         client.defaults.baseURL = storage.emulatorUrl;

package/dist/storage/StorageReference.d.ts

@@ -1,20 +1,26 @@
 import { Storage } from './Storage';
 import { UploadTask } from './UploadTask';
-import { UploadMetadata, StorageMetadata } from './types';
+import { UploadMetadata, StorageMetadata, SettableMetadata, StringFormat, UploadResult, ListOptions, ListResult } from './types';
 import { UploadOptions } from '../types/index';
 export interface IStorageReference {
+    name: string;
+    bucket: string;
+    fullPath: string;
     path: string;
-    put(file: File | Blob, metadata?: UploadMetadata): UploadTask;
-    putString(data: string, format?: string, metadata?: UploadMetadata): UploadTask;
+    root: IStorageReference;
+    parent: IStorageReference | null;
+    storage: Storage;
+    put(file: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata): UploadTask;
+    putString(data: string, format?: StringFormat, metadata?: UploadMetadata): UploadTask;
     getDownloadURL(): Promise<string>;
     getMetadata(): Promise<StorageMetadata>;
-    updateMetadata(metadata: Partial<StorageMetadata>): Promise<StorageMetadata>;
+    updateMetadata(metadata: SettableMetadata): Promise<StorageMetadata>;
     delete(): Promise<{
         success: boolean;
         message?: string;
     }>;
-    listAll(): Promise<any>;
-    list(options?: any): Promise<any>;
+    listAll(): Promise<ListResult>;
+    list(options?: ListOptions): Promise<ListResult>;
     upload?: (file: File | Blob, options?: UploadOptions) => Promise<{
         url: string;
         path: string;
@@ -22,28 +28,39 @@ export interface IStorageReference {
 }
 export declare class StorageReferenceImpl implements IStorageReference {
     path: string;
-    private storage;
+    fullPath: string;
+    name: string;
+    bucket: string;
+    storage: Storage;
     constructor(path: string, storage: Storage);
-    put(file: File | Blob, metadata?: UploadMetadata): UploadTask;
-    putString(data: string, format?: string, metadata?: UploadMetadata): UploadTask;
+    get root(): IStorageReference;
+    get parent(): IStorageReference | null;
+    put(data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata): UploadTask;
+    putString(data: string, format?: StringFormat, metadata?: UploadMetadata): UploadTask;
     getDownloadURL(): Promise<string>;
     getMetadata(): Promise<StorageMetadata>;
-    updateMetadata(metadata: Partial<StorageMetadata>): Promise<StorageMetadata>;
+    updateMetadata(metadata: SettableMetadata): Promise<StorageMetadata>;
     delete(): Promise<{
         success: boolean;
         message?: string;
     }>;
-    listAll(): Promise<any>;
-    list(options?: any): Promise<any>;
+    listAll(): Promise<ListResult>;
+    list(options?: ListOptions): Promise<ListResult>;
     upload(file: File | Blob, options?: UploadOptions): Promise<{
         url: string;
         path: string;
     }>;
 }
-export declare const ref: (storage: Storage, path: string) => IStorageReference;
-export declare const uploadBytes: (storageRef: IStorageReference, file: File | Blob, metadata?: UploadMetadata) => Promise<any>;
+/**
+ * 1:1 Modular Firebase Storage API functions
+ */
+export declare const ref: (storageOrRef: Storage | IStorageReference, path?: string) => IStorageReference;
+export declare const uploadBytes: (storageRef: IStorageReference, data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata) => Promise<UploadResult>;
+export declare const uploadBytesResumable: (storageRef: IStorageReference, data: Blob | Uint8Array | ArrayBuffer, metadata?: UploadMetadata) => UploadTask;
+export declare const uploadString: (storageRef: IStorageReference, value: string, format?: StringFormat, metadata?: UploadMetadata) => Promise<UploadResult>;
 export declare const getDownloadURL: (storageRef: IStorageReference) => Promise<string>;
-export declare const deleteObject: (storageRef: IStorageReference) => Promise<{
-    success: boolean;
-    message?: string;
-}>;
+export declare const getMetadata: (storageRef: IStorageReference) => Promise<StorageMetadata>;
+export declare const updateMetadata: (storageRef: IStorageReference, metadata: SettableMetadata) => Promise<StorageMetadata>;
+export declare const deleteObject: (storageRef: IStorageReference) => Promise<void>;
+export declare const listAll: (storageRef: IStorageReference) => Promise<ListResult>;
+export declare const list: (storageRef: IStorageReference, options?: ListOptions) => Promise<ListResult>;

package/dist/storage/StorageReference.js

@@ -1,28 +1,81 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteObject = exports.getDownloadURL = exports.uploadBytes = exports.ref = exports.StorageReferenceImpl = void 0;
+exports.list = exports.listAll = exports.deleteObject = exports.updateMetadata = exports.getMetadata = exports.getDownloadURL = exports.uploadString = exports.uploadBytesResumable = exports.uploadBytes = exports.ref = exports.StorageReferenceImpl = void 0;
+const NexaStorageError_1 = require("./NexaStorageError");
 class StorageReferenceImpl {
     constructor(path, storage) {
-        this.path = path;
+        // Normalize path by stripping leading slashes
+        this.path = (path || '').replace(/^\/+/, '');
+        this.fullPath = this.path;
+        this.name = this.path.split('/').filter(Boolean).pop() || '';
+        this.bucket = storage.projectId || '';
         this.storage = storage;
     }
-    put(file, metadata) {
-        return this.storage.createUploadTask(this.path, file, metadata);
+    get root() {
+        return new StorageReferenceImpl('', this.storage);
     }
-    putString(data, format = 'raw', metadata) {
+    get parent() {
+        const parts = this.path.split('/').filter(Boolean);
+        if (parts.length <= 1)
+            return null;
+        parts.pop();
+        return new StorageReferenceImpl(parts.join('/'), this.storage);
+    }
+    put(data, metadata) {
         let blob;
-        if (format === 'base64') {
-            const byteCharacters = atob(data);
-            const byteNumbers = new Array(byteCharacters.length);
-            for (let i = 0; i < byteCharacters.length; i++) {
-                byteNumbers[i] = byteCharacters.charCodeAt(i);
-            }
-            const byteArray = new Uint8Array(byteNumbers);
-            blob = new Blob([byteArray]);
+        if (data instanceof Blob) {
+            blob = data;
+        }
+        else if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+            blob = new Blob([data], { type: metadata?.contentType || 'application/octet-stream' });
         }
         else {
             blob = new Blob([data]);
         }
+        return this.storage.createUploadTask(this.path, blob, metadata);
+    }
+    putString(data, format = 'raw', metadata) {
+        let blob;
+        try {
+            if (format === 'base64') {
+                const byteCharacters = atob(data);
+                const byteNumbers = new Uint8Array(byteCharacters.length);
+                for (let i = 0; i < byteCharacters.length; i++) {
+                    byteNumbers[i] = byteCharacters.charCodeAt(i);
+                }
+                blob = new Blob([byteNumbers], { type: metadata?.contentType || 'application/octet-stream' });
+            }
+            else if (format === 'base64url') {
+                let base64 = data.replace(/-/g, '+').replace(/_/g, '/');
+                while (base64.length % 4) {
+                    base64 += '=';
+                }
+                const byteCharacters = atob(base64);
+                const byteNumbers = new Uint8Array(byteCharacters.length);
+                for (let i = 0; i < byteCharacters.length; i++) {
+                    byteNumbers[i] = byteCharacters.charCodeAt(i);
+                }
+                blob = new Blob([byteNumbers], { type: metadata?.contentType || 'application/octet-stream' });
+            }
+            else if (format === 'data_url') {
+                const parts = data.split(',');
+                const mimeMatch = parts[0]?.match(/:(.*?);/);
+                const detectedMime = mimeMatch ? mimeMatch[1] : 'application/octet-stream';
+                const b64Data = parts[1] || '';
+                const byteCharacters = atob(b64Data);
+                const byteNumbers = new Uint8Array(byteCharacters.length);
+                for (let i = 0; i < byteCharacters.length; i++) {
+                    byteNumbers[i] = byteCharacters.charCodeAt(i);
+                }
+                blob = new Blob([byteNumbers], { type: metadata?.contentType || detectedMime });
+            }
+            else {
+                blob = new Blob([data], { type: metadata?.contentType || 'text/plain;charset=utf-8' });
+            }
+        }
+        catch (err) {
+            throw new NexaStorageError_1.NexaStorageError('storage/invalid-format', `Failed to parse data as ${format}: ${err.message}`);
+        }
         return this.put(blob, metadata);
     }
     getDownloadURL() {
@@ -46,27 +99,79 @@ class StorageReferenceImpl {
     // Legacy for backward compatibility
     async upload(file, options) {
         const task = this.put(file, options);
-        task.options = options; // Inject legacy options
+        task.options = options;
         await task;
         const url = await this.getDownloadURL();
         return { url, path: this.path };
     }
 }
 exports.StorageReferenceImpl = StorageReferenceImpl;
-const ref = (storage, path) => {
-    return new StorageReferenceImpl(path, storage);
+/**
+ * 1:1 Modular Firebase Storage API functions
+ */
+const ref = (storageOrRef, path) => {
+    if (!storageOrRef) {
+        throw new NexaStorageError_1.NexaStorageError('storage/invalid-path', 'No storage instance or reference provided');
+    }
+    if ('storage' in storageOrRef && typeof storageOrRef.storage?.ref === 'function') {
+        // First argument is a StorageReference, child path is appended
+        const parent = storageOrRef;
+        const combinedPath = path ? `${parent.path.replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}` : parent.path;
+        return new StorageReferenceImpl(combinedPath, parent.storage);
+    }
+    const storage = storageOrRef;
+    return new StorageReferenceImpl(path || '', storage);
 };
 exports.ref = ref;
-const uploadBytes = async (storageRef, file, metadata) => {
-    const task = storageRef.put(file, metadata);
-    return await task;
+const uploadBytes = async (storageRef, data, metadata) => {
+    const task = storageRef.put(data, metadata);
+    const snapshot = await task;
+    return {
+        bytesTransferred: snapshot.bytesTransferred,
+        totalBytes: snapshot.totalBytes,
+        state: snapshot.state,
+        metadata: snapshot.metadata,
+        ref: storageRef
+    };
 };
 exports.uploadBytes = uploadBytes;
+const uploadBytesResumable = (storageRef, data, metadata) => {
+    return storageRef.put(data, metadata);
+};
+exports.uploadBytesResumable = uploadBytesResumable;
+const uploadString = async (storageRef, value, format = 'raw', metadata) => {
+    const task = storageRef.putString(value, format, metadata);
+    const snapshot = await task;
+    return {
+        bytesTransferred: snapshot.bytesTransferred,
+        totalBytes: snapshot.totalBytes,
+        state: snapshot.state,
+        metadata: snapshot.metadata,
+        ref: storageRef
+    };
+};
+exports.uploadString = uploadString;
 const getDownloadURL = async (storageRef) => {
     return storageRef.getDownloadURL();
 };
 exports.getDownloadURL = getDownloadURL;
+const getMetadata = async (storageRef) => {
+    return storageRef.getMetadata();
+};
+exports.getMetadata = getMetadata;
+const updateMetadata = async (storageRef, metadata) => {
+    return storageRef.updateMetadata(metadata);
+};
+exports.updateMetadata = updateMetadata;
 const deleteObject = async (storageRef) => {
-    return storageRef.delete();
+    await storageRef.delete();
 };
 exports.deleteObject = deleteObject;
+const listAll = async (storageRef) => {
+    return storageRef.listAll();
+};
+exports.listAll = listAll;
+const list = async (storageRef, options) => {
+    return storageRef.list(options);
+};
+exports.list = list;

package/dist/storage/types.d.ts

@@ -1,4 +1,4 @@
-export type StorageErrorCode = 'storage/unauthenticated' | 'storage/unauthorized' | 'storage/object-not-found' | 'storage/object-already-exists' | 'storage/invalid-path' | 'storage/invalid-file' | 'storage/invalid-metadata' | 'storage/invalid-checksum' | 'storage/quota-exceeded' | 'storage/upload-session-expired' | 'storage/retry-limit-exceeded' | 'storage/canceled' | 'storage/conflict' | 'storage/network-error' | 'storage/server-error';
+export type StorageErrorCode = 'storage/unauthenticated' | 'storage/unauthorized' | 'storage/object-not-found' | 'storage/object-already-exists' | 'storage/invalid-path' | 'storage/invalid-file' | 'storage/invalid-format' | 'storage/invalid-metadata' | 'storage/invalid-checksum' | 'storage/quota-exceeded' | 'storage/upload-session-expired' | 'storage/retry-limit-exceeded' | 'storage/canceled' | 'storage/conflict' | 'storage/network-error' | 'storage/server-error';
 export interface StorageMetadata {
     name: string;
     bucket: string;
@@ -15,6 +15,7 @@ export interface StorageMetadata {
     contentLanguage?: string;
     contentType?: string;
     customMetadata?: Record<string, string>;
+    downloadTokens?: string;
 }
 export interface UploadMetadata {
     md5Hash?: string;
@@ -25,6 +26,8 @@ export interface UploadMetadata {
     contentType?: string;
     customMetadata?: Record<string, string>;
 }
+export type SettableMetadata = UploadMetadata;
+export type StringFormat = 'raw' | 'base64' | 'base64url' | 'data_url';
 export type TaskState = 'running' | 'paused' | 'success' | 'canceled' | 'error';
 export interface UploadTaskSnapshot {
     bytesTransferred: number;
@@ -34,3 +37,19 @@ export interface UploadTaskSnapshot {
     task: any;
     ref: any;
 }
+export interface UploadResult {
+    bytesTransferred: number;
+    totalBytes: number;
+    state: TaskState;
+    metadata?: StorageMetadata;
+    ref: any;
+}
+export interface ListOptions {
+    maxResults?: number;
+    pageToken?: string;
+}
+export interface ListResult {
+    items: any[];
+    prefixes: any[];
+    nextPageToken?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexabase-console",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "SDK Client resmi untuk NexaBase: Platform Sinkronisasi NoSQL, Realtime, File Storage, & Autentikasi Offline-First.",
   "main": "dist/index.cjs",
   "module": "dist/index.js",