@wowsql/sdk 3.6.0 → 3.8.0

package/dist/storage.js

@@ -1,8 +1,11 @@
 "use strict";
 /**
- * WowSQL Storage SDK - S3 Storage management with automatic quota validation
+ * WowSQL Storage SDK - PostgreSQL-native file storage
  *
- * @version 2.1.0
+ * Files are stored as BYTEA inside each project's `storage` schema.
+ * No external S3 dependency — everything lives in PostgreSQL.
+ *
+ * @version 3.0.0
  * @license MIT
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -44,359 +47,267 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WowSQLStorage = exports.StorageLimitExceededError = exports.StorageError = void 0;
 const axios_1 = __importDefault(require("axios"));
-const fs = __importStar(require("fs"));
-class StorageError extends Error {
-    constructor(message, statusCode, response) {
-        super(message);
-        this.statusCode = statusCode;
-        this.response = response;
-        this.name = 'StorageError';
+const errors_1 = require("./errors");
+Object.defineProperty(exports, "StorageError", { enumerable: true, get: function () { return errors_1.StorageError; } });
+Object.defineProperty(exports, "StorageLimitExceededError", { enumerable: true, get: function () { return errors_1.StorageLimitExceededError; } });
+class StorageFileImpl {
+    constructor(data) {
+        this.id = data.id;
+        this.bucket_id = data.bucket_id;
+        this.name = data.name;
+        this.path = data.path;
+        this.mime_type = data.mime_type ?? null;
+        this.size = data.size ?? 0;
+        this.metadata = data.metadata ?? {};
+        this.created_at = data.created_at ?? '';
+        this.public_url = data.public_url;
     }
-}
-exports.StorageError = StorageError;
-class StorageLimitExceededError extends StorageError {
-    constructor(message, statusCode, response) {
-        super(message, statusCode, response);
-        this.name = 'StorageLimitExceededError';
+    get sizeMb() {
+        return this.size / (1024 * 1024);
+    }
+    get sizeGb() {
+        return this.size / (1024 * 1024 * 1024);
     }
 }
-exports.StorageLimitExceededError = StorageLimitExceededError;
 // ==================== Storage Client ====================
 /**
- * WowSQL Storage Client - Manage S3 storage with automatic quota validation
+ * WowSQL Storage Client — PostgreSQL-native file storage.
  *
- * Features:
- * - Automatic storage limit validation before upload
- * - Real-time quota checking
- * - File upload/download/delete operations
- * - Presigned URL generation
- * - Storage provisioning and management
+ * All files are stored directly in the project's PostgreSQL database
+ * inside the `storage` schema (buckets + objects as BYTEA).
  *
  * @example
  * ```typescript
  * const storage = new WowSQLStorage({
- *   projectSlug: 'myproject',
- *   apiKey: 'your_api_key'
+ *   projectUrl: 'myproject',
+ *   apiKey: 'wowsql_anon_...'
  * });
  *
- * // Check quota
- * const quota = await storage.getQuota();
- * console.log(`Available: ${quota.storage_available_gb.toFixed(2)} GB`);
+ * // Create a bucket
+ * const bucket = await storage.createBucket('avatars', { public: true });
  *
- * // Upload file (auto-validates limits)
- * const fileBuffer = fs.readFileSync('document.pdf');
- * const result = await storage.uploadFile(fileBuffer, 'document.pdf', {
- *   folder: 'documents'
- * });
+ * // Upload a file
+ * const file = document.querySelector('input[type="file"]').files[0];
+ * const result = await storage.upload('avatars', file, 'users/profile.jpg');
  *
  * // List files
- * const files = await storage.listFiles({ prefix: 'documents/' });
+ * const files = await storage.listFiles('avatars', { prefix: 'users/' });
+ *
+ * // Get public URL
+ * const url = storage.getPublicUrl('avatars', 'users/profile.jpg');
  * ```
  */
 class WowSQLStorage {
     constructor(config) {
-        this.projectSlug = config.projectSlug;
-        this.autoCheckQuota = config.autoCheckQuota !== false;
-        const baseUrl = config.baseUrl || 'https://api.wowsql.com';
-        // Create axios instance
+        const protocol = config.secure !== false ? 'https' : 'http';
+        if (config.baseUrl) {
+            this.baseUrl = config.baseUrl.replace(/\/+$/, '');
+        }
+        else if (config.projectUrl.startsWith('http://') || config.projectUrl.startsWith('https://')) {
+            this.baseUrl = config.projectUrl.replace(/\/+$/, '');
+        }
+        else {
+            const domain = config.baseDomain || 'wowsql.com';
+            if (config.projectUrl.includes(`.${domain}`) || config.projectUrl.endsWith(domain)) {
+                this.baseUrl = `${protocol}://${config.projectUrl}`;
+            }
+            else {
+                this.baseUrl = `${protocol}://${config.projectUrl}.${domain}`;
+            }
+        }
+        this.projectSlug = config.projectSlug || config.projectUrl.split('.')[0].replace(/^https?:\/\//, '');
         this.client = axios_1.default.create({
-            baseURL: baseUrl,
+            baseURL: `${this.baseUrl}/api/v1/storage`,
             headers: {
                 'Authorization': `Bearer ${config.apiKey}`,
             },
-            timeout: config.timeout || 60000, // 60s default for file uploads
+            timeout: config.timeout || 60000,
         });
-        // Add error interceptor
         this.client.interceptors.response.use((response) => response, (error) => {
             if (error.response) {
                 const errorData = error.response.data;
                 const errorMessage = errorData?.detail || errorData?.message || error.message;
-                // Check for storage limit exceeded
                 if (error.response.status === 413) {
-                    throw new StorageLimitExceededError(errorMessage, error.response.status, errorData);
+                    throw new errors_1.StorageLimitExceededError(errorMessage, 413, errorData);
                 }
-                throw new StorageError(errorMessage, error.response.status, errorData);
+                throw new errors_1.StorageError(errorMessage, error.response.status, errorData);
             }
-            throw new StorageError(error.message);
+            throw new errors_1.StorageError(error.message);
         });
     }
+    // ==================== Bucket Operations ====================
     /**
-     * Get storage quota and usage information
+     * Create a new storage bucket.
      *
-     * @param forceRefresh - Force refresh quota from server (default: false)
-     * @returns Storage quota details
-     *
-     * @example
-     * ```typescript
-     * const quota = await storage.getQuota();
-     * console.log(`Used: ${quota.storage_used_gb} GB`);
-     * console.log(`Available: ${quota.storage_available_gb} GB`);
-     * console.log(`Usage: ${quota.usage_percentage}%`);
-     * ```
+     * @param name - Bucket name (unique per project)
+     * @param options - Bucket configuration
      */
-    async getQuota(forceRefresh = false) {
-        if (this.quotaCache && !forceRefresh) {
-            return this.quotaCache;
-        }
-        const response = await this.client.get(`/api/v1/storage/s3/projects/${this.projectSlug}/quota`);
-        this.quotaCache = response.data;
+    async createBucket(name, options) {
+        const response = await this.client.post(`/projects/${this.projectSlug}/buckets`, {
+            name,
+            public: options?.public ?? false,
+            file_size_limit: options?.fileSizeLimit ?? null,
+            allowed_mime_types: options?.allowedMimeTypes ?? null,
+        });
         return response.data;
     }
     /**
-     * Check if file upload is allowed based on storage quota
-     *
-     * @param fileSizeBytes - Size of file to upload in bytes
-     * @returns Object with allowed status and message
-     *
-     * @example
-     * ```typescript
-     * const fileSize = 1024 * 1024 * 500; // 500 MB
-     * const check = await storage.checkUploadAllowed(fileSize);
-     * if (!check.allowed) {
-     *   console.error(check.message);
-     * }
-     * ```
+     * List all buckets in the project.
      */
-    async checkUploadAllowed(fileSizeBytes) {
-        const quota = await this.getQuota(true);
-        const fileSizeGB = fileSizeBytes / (1024 ** 3);
-        if (fileSizeGB > quota.storage_available_gb) {
-            return {
-                allowed: false,
-                message: `Storage limit exceeded! File size: ${fileSizeGB.toFixed(4)} GB, ` +
-                    `Available: ${quota.storage_available_gb.toFixed(4)} GB. ` +
-                    `Upgrade your plan to get more storage.`
-            };
-        }
-        return {
-            allowed: true,
-            message: `Upload allowed. ${quota.storage_available_gb.toFixed(4)} GB available.`
-        };
+    async listBuckets() {
+        const response = await this.client.get(`/projects/${this.projectSlug}/buckets`);
+        return response.data;
     }
     /**
-     * Upload a file to S3 storage with automatic quota validation
-     *
-     * @param fileData - File data as Buffer or Blob
-     * @param fileName - File name
-     * @param options - Upload options
-     * @returns Upload result
-     *
-     * @throws {StorageLimitExceededError} If storage quota would be exceeded
-     * @throws {StorageError} If upload fails
-     *
-     * @example
-     * ```typescript
-     * // Node.js - from file
-     * const fileBuffer = fs.readFileSync('photo.jpg');
-     * const result = await storage.uploadFile(fileBuffer, 'photo.jpg', {
-     *   folder: 'images',
-     *   contentType: 'image/jpeg'
-     * });
+     * Get a specific bucket by name.
+     */
+    async getBucket(name) {
+        const response = await this.client.get(`/projects/${this.projectSlug}/buckets/${name}`);
+        return response.data;
+    }
+    /**
+     * Update bucket settings.
+     */
+    async updateBucket(name, updates) {
+        const body = {};
+        if (updates.name !== undefined)
+            body.name = updates.name;
+        if (updates.public !== undefined)
+            body.public = updates.public;
+        if (updates.fileSizeLimit !== undefined)
+            body.file_size_limit = updates.fileSizeLimit;
+        if (updates.allowedMimeTypes !== undefined)
+            body.allowed_mime_types = updates.allowedMimeTypes;
+        const response = await this.client.patch(`/projects/${this.projectSlug}/buckets/${name}`, body);
+        return response.data;
+    }
+    /**
+     * Delete a bucket and all its files.
+     */
+    async deleteBucket(name) {
+        const response = await this.client.delete(`/projects/${this.projectSlug}/buckets/${name}`);
+        return response.data;
+    }
+    // ==================== File Operations ====================
+    /**
+     * Upload a file to a bucket.
      *
-     * // Browser - from File input
-     * const file = document.querySelector('input[type="file"]').files[0];
-     * const arrayBuffer = await file.arrayBuffer();
-     * const result = await storage.uploadFile(
-     *   Buffer.from(arrayBuffer),
-     *   file.name,
-     *   { folder: 'uploads' }
-     * );
-     * ```
+     * @param bucketName - Target bucket
+     * @param fileData - File data (File, Blob, or Buffer)
+     * @param path - Optional path within the bucket (e.g., 'users/avatar.png')
+     * @param fileName - Optional file name override
      */
-    async uploadFile(fileData, fileName, options) {
-        // Get file size
-        const fileSize = fileData instanceof Buffer ? fileData.length : fileData.size;
-        // Check quota if enabled
-        const shouldCheck = options?.checkQuota !== undefined ? options.checkQuota : this.autoCheckQuota;
-        if (shouldCheck) {
-            const check = await this.checkUploadAllowed(fileSize);
-            if (!check.allowed) {
-                throw new StorageLimitExceededError(check.message, 413);
-            }
-        }
-        // Prepare form data
+    async upload(bucketName, fileData, path, fileName) {
         const formData = new FormData();
         const blob = fileData instanceof Buffer ? new Blob([fileData]) : fileData;
-        formData.append('file', blob, fileName);
-        // Build URL with query params
+        const name = fileName || fileData.name || path || 'file';
+        formData.append('file', blob, name);
         const params = new URLSearchParams();
-        if (options?.folder) {
-            params.append('folder', options.folder);
+        if (path) {
+            const folder = path.includes('/') ? path.substring(0, path.lastIndexOf('/')) : '';
+            if (folder)
+                params.append('folder', folder);
         }
-        const url = `/api/v1/storage/s3/projects/${this.projectSlug}/upload${params.toString() ? '?' + params.toString() : ''}`;
-        // Upload
+        const url = `/projects/${this.projectSlug}/buckets/${bucketName}/files${params.toString() ? '?' + params.toString() : ''}`;
         const response = await this.client.post(url, formData, {
-            headers: {
-                'Content-Type': 'multipart/form-data',
-            },
+            headers: { 'Content-Type': 'multipart/form-data' },
         });
-        // Clear quota cache after upload
-        this.quotaCache = undefined;
-        return response.data;
+        return new StorageFileImpl(response.data);
     }
     /**
-     * Upload a file from filesystem path (Node.js only)
-     *
-     * @param filePath - Path to local file
-     * @param fileName - Optional file name in bucket (defaults to filename)
-     * @param options - Upload options
-     * @returns Upload result
+     * Upload a file (compatibility alias for upload).
      *
-     * @example
-     * ```typescript
-     * const result = await storage.uploadFromPath(
-     *   'documents/report.pdf',
-     *   'report.pdf',
-     *   { folder: 'reports' }
-     * );
-     * ```
+     * @param bucketName - Target bucket
+     * @param fileData - File data (File, Blob, or Buffer)
+     * @param path - Optional path within the bucket
+     * @param fileName - Optional file name override
      */
-    async uploadFromPath(filePath, fileName, options) {
-        if (!fs.existsSync(filePath)) {
-            throw new Error(`File not found: ${filePath}`);
-        }
-        const fileBuffer = fs.readFileSync(filePath);
-        const name = fileName || filePath.split('/').pop() || 'file';
-        return this.uploadFile(fileBuffer, name, options);
+    async uploadFile(bucketName, fileData, path, fileName) {
+        return this.upload(bucketName, fileData, path, fileName);
     }
     /**
-     * List files in S3 bucket
+     * Upload a file from a local file path (Node.js only).
      *
-     * @param options - List options
-     * @returns Array of storage files
+     * @param filePath - Local file path to upload
+     * @param bucketName - Target bucket (defaults to 'default')
+     * @param path - Optional path within the bucket
+     */
+    async uploadFromPath(filePath, bucketName = 'default', path) {
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        const nodePath = await Promise.resolve().then(() => __importStar(require('path')));
+        const data = fs.readFileSync(filePath);
+        const fileName = nodePath.basename(filePath);
+        return this.upload(bucketName, Buffer.from(data), path || fileName, fileName);
+    }
+    /**
+     * List files in a bucket.
      *
-     * @example
-     * ```typescript
-     * const files = await storage.listFiles({ prefix: 'documents/' });
-     * for (const file of files) {
-     *   console.log(`${file.key}: ${(file.size / 1024 / 1024).toFixed(2)} MB`);
-     * }
-     * ```
+     * @param bucketName - Bucket to list
+     * @param options - Filter and pagination options
      */
-    async listFiles(options) {
+    async listFiles(bucketName, options) {
         const params = {};
         if (options?.prefix)
             params.prefix = options.prefix;
-        if (options?.maxKeys)
-            params.max_keys = options.maxKeys;
-        const response = await this.client.get(`/api/v1/storage/s3/projects/${this.projectSlug}/files`, { params });
-        return response.data.files || [];
+        if (options?.limit)
+            params.limit = options.limit;
+        if (options?.offset)
+            params.offset = options.offset;
+        const response = await this.client.get(`/projects/${this.projectSlug}/buckets/${bucketName}/files`, { params });
+        return response.data.map((f) => new StorageFileImpl(f));
     }
     /**
-     * Delete a file from S3 bucket
-     *
-     * @param fileKey - Path to file in bucket
-     * @returns Deletion result
+     * Download a file. Returns binary data as ArrayBuffer.
      *
-     * @example
-     * ```typescript
-     * const result = await storage.deleteFile('documents/old-file.pdf');
-     * console.log(result.message);
-     * ```
+     * @param bucketName - Bucket name
+     * @param filePath - Path to file within the bucket
      */
-    async deleteFile(fileKey) {
-        const response = await this.client.delete(`/api/v1/storage/s3/projects/${this.projectSlug}/files/${fileKey}`);
-        // Clear quota cache after delete
-        this.quotaCache = undefined;
+    async download(bucketName, filePath) {
+        const response = await this.client.get(`/projects/${this.projectSlug}/files/${bucketName}/${filePath}`, { responseType: 'arraybuffer' });
         return response.data;
     }
     /**
-     * Get presigned URL for file access
+     * Download a file and save to a local path (Node.js only).
      *
-     * @param fileKey - Path to file in bucket
-     * @param expiresIn - URL validity in seconds (default: 3600 = 1 hour)
-     * @returns File URL and metadata
-     *
-     * @example
-     * ```typescript
-     * const urlData = await storage.getFileUrl('photo.jpg', 7200);
-     * console.log(urlData.file_url); // Use this for downloads
-     * ```
+     * @param bucketName - Bucket name
+     * @param filePath - Path to file within the bucket
+     * @param localPath - Local file path to save to
      */
-    async getFileUrl(fileKey, expiresIn = 3600) {
-        const response = await this.client.get(`/api/v1/storage/s3/projects/${this.projectSlug}/files/${fileKey}/url`, { params: { expires_in: expiresIn } });
-        return response.data;
+    async downloadToFile(bucketName, filePath, localPath) {
+        const data = await this.download(bucketName, filePath);
+        const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+        fs.writeFileSync(localPath, Buffer.from(data));
     }
     /**
-     * Generate presigned URL for file operations
-     *
-     * @param fileKey - Path to file in bucket
-     * @param options - Presigned URL options
-     * @returns Presigned URL string
-     *
-     * @example
-     * ```typescript
-     * // Download URL
-     * const downloadUrl = await storage.getPresignedUrl('file.pdf');
+     * Delete a file from a bucket.
      *
-     * // Upload URL
-     * const uploadUrl = await storage.getPresignedUrl('new-file.pdf', {
-     *   operation: 'put_object',
-     *   expiresIn: 1800
-     * });
-     * ```
+     * @param bucketName - Bucket name
+     * @param filePath - Path to file within the bucket
      */
-    async getPresignedUrl(fileKey, options) {
-        const response = await this.client.post(`/api/v1/storage/s3/projects/${this.projectSlug}/presigned-url`, {
-            file_key: fileKey,
-            expires_in: options?.expiresIn || 3600,
-            operation: options?.operation || 'get_object',
-        });
-        return response.data.url;
+    async deleteFile(bucketName, filePath) {
+        const response = await this.client.delete(`/projects/${this.projectSlug}/files/${bucketName}/${filePath}`);
+        return response.data;
     }
+    // ==================== Utilities ====================
     /**
-     * Get S3 storage information for the project
-     *
-     * @returns Storage information
-     *
-     * @example
-     * ```typescript
-     * const info = await storage.getStorageInfo();
-     * console.log(`Bucket: ${info.bucket_name}`);
-     * console.log(`Region: ${info.region}`);
-     * console.log(`Objects: ${info.total_objects}`);
-     * console.log(`Size: ${info.total_size_gb.toFixed(2)} GB`);
-     * ```
+     * Get the public URL for a file in a public bucket.
+     * This URL works without authentication.
      */
-    async getStorageInfo() {
-        const response = await this.client.get(`/api/v1/storage/s3/projects/${this.projectSlug}/info`);
-        return response.data;
+    getPublicUrl(bucketName, filePath) {
+        return `${this.baseUrl}/storage/v1/object/public/${bucketName}/${filePath}`;
     }
     /**
-     * Provision S3 storage for the project
-     *
-     * **IMPORTANT**: Save the credentials returned! They're only shown once.
-     *
-     * @param region - AWS region (default: 'us-east-1')
-     * @returns Provisioning result with credentials
-     *
-     * @example
-     * ```typescript
-     * const result = await storage.provisionStorage('us-west-2');
-     * console.log(`Bucket: ${result.bucket_name}`);
-     * console.log(`Access Key: ${result.credentials.access_key_id}`);
-     * // SAVE THESE CREDENTIALS SECURELY!
-     * ```
+     * Get storage statistics for the project.
      */
-    async provisionStorage(region = 'us-east-1') {
-        const response = await this.client.post(`/api/v1/storage/s3/projects/${this.projectSlug}/provision`, { region });
+    async getStats() {
+        const response = await this.client.get(`/projects/${this.projectSlug}/stats`);
         return response.data;
     }
     /**
-     * Get list of available S3 regions with pricing
-     *
-     * @returns Array of available regions
-     *
-     * @example
-     * ```typescript
-     * const regions = await storage.getAvailableRegions();
-     * for (const region of regions) {
-     *   console.log(`${region.name}: $${region.storage_price_gb}/GB/month`);
-     * }
-     * ```
+     * Get storage quota for the project.
      */
-    async getAvailableRegions() {
-        const response = await this.client.get('/api/v1/storage/s3/regions');
+    async getQuota() {
+        const response = await this.client.get(`/projects/${this.projectSlug}/quota`);
         return response.data;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wowsql/sdk",
-  "version": "3.6.0",
+  "version": "3.8.0",
   "description": "Official TypeScript/JavaScript SDK for WowSQL - MySQL Backend-as-a-Service with S3 Storage, type-safe queries and fluent API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",