@oasis-path/gamma-sdk 1.0.8 → 1.0.9

package/dist/client.d.ts

@@ -1,14 +1,25 @@
-import { GammaFilesClientConfig, UploadFileOptions, UploadFileResponse, ListFilesResponse, FileMetadataResponse, DeleteFileResponse, PresignedUrlOptions, PresignedUrlResponse, ViewFileByTokenResult } from './types';
+import { GammaFilesClientConfig, UploadFileOptions, UploadFileResponse, UploadWithPresignedTokenOptions, DownloadFileWithPresignedTokenOptions, ListFilesResponse, FileMetadataResponse, DeleteFileResponse, PresignedUrlOptions, PresignedUrlResponse, PresignedUploadUrlResponse, PresignedFolderDownloadUrlOptions, PresignedFolderDownloadUrlResponse, PrepareFolderDownloadOptions, PrepareFolderDownloadResponse, CheckPreparedDownloadResponse, DownloadFolderOptions, ViewFileByTokenResult } from './types';
+import { GeneratePresignedUploadUrlOptions } from './methods/generatePresignedUploadUrl';
 export declare class GammaFilesClient {
     private baseUrl;
     private apiKey;
+    private jwtToken?;
     constructor(config: GammaFilesClientConfig);
+    setJwtToken(token: string): void;
     uploadFile(options: UploadFileOptions): Promise<UploadFileResponse>;
+    uploadFileWithPresignedToken(options: UploadWithPresignedTokenOptions): Promise<UploadFileResponse>;
+    uploadFileWithJWT(jwtToken: string, options: UploadFileOptions): Promise<UploadFileResponse>;
+    generatePresignedUploadUrl(options: GeneratePresignedUploadUrlOptions): Promise<PresignedUploadUrlResponse>;
     downloadFile(fileId: string): Promise<ArrayBuffer>;
+    downloadFileWithPresignedToken(options: DownloadFileWithPresignedTokenOptions): Promise<ArrayBuffer>;
     listFiles(folderId: string): Promise<ListFilesResponse>;
     deleteFile(fileId: string): Promise<DeleteFileResponse>;
     getFileMetadata(fileId: string): Promise<FileMetadataResponse>;
     generatePresignedUrl(options: PresignedUrlOptions): Promise<PresignedUrlResponse>;
     viewFileByToken(fileId: string, token: string, compressionValue?: number): Promise<ViewFileByTokenResult>;
+    generatePresignedFolderDownloadUrl(options: PresignedFolderDownloadUrlOptions): Promise<PresignedFolderDownloadUrlResponse>;
+    prepareFolderDownload(options: PrepareFolderDownloadOptions): Promise<PrepareFolderDownloadResponse>;
+    checkPreparedDownload(folderId: string): Promise<CheckPreparedDownloadResponse>;
+    downloadFolder(options: DownloadFolderOptions): Promise<ArrayBuffer>;
     private request;
 }

package/dist/client.js

@@ -2,24 +2,48 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GammaFilesClient = void 0;
 const uploadFile_1 = require("./methods/uploadFile");
+const uploadFileWithPresignedToken_1 = require("./methods/uploadFileWithPresignedToken");
+const uploadFileWithJWT_1 = require("./methods/uploadFileWithJWT");
 const downloadFile_1 = require("./methods/downloadFile");
+const downloadFileWithPresignedToken_1 = require("./methods/downloadFileWithPresignedToken");
 const listFiles_1 = require("./methods/listFiles");
 const deleteFile_1 = require("./methods/deleteFile");
 const getFileMetadata_1 = require("./methods/getFileMetadata");
 const generatePresignedUrl_1 = require("./methods/generatePresignedUrl");
+const generatePresignedUploadUrl_1 = require("./methods/generatePresignedUploadUrl");
 const viewFileByToken_1 = require("./methods/viewFileByToken");
+const folderOperations_1 = require("./methods/folderOperations");
 const request_1 = require("./methods/request");
 class GammaFilesClient {
     constructor(config) {
         this.baseUrl = config.baseUrl.replace(/\/$/, '');
         this.apiKey = config.apiKey;
+        this.jwtToken = config.jwtToken;
+    }
+    setJwtToken(token) {
+        this.jwtToken = token;
     }
     async uploadFile(options) {
         return (0, uploadFile_1.uploadFile)(this.baseUrl, this.apiKey, options, this.request.bind(this));
     }
+    async uploadFileWithPresignedToken(options) {
+        return (0, uploadFileWithPresignedToken_1.uploadFileWithPresignedToken)(this.baseUrl, options, this.request.bind(this));
+    }
+    async uploadFileWithJWT(jwtToken, options) {
+        return (0, uploadFileWithJWT_1.uploadFileWithJWT)(this.baseUrl, jwtToken, options, this.request.bind(this));
+    }
+    async generatePresignedUploadUrl(options) {
+        if (!this.jwtToken) {
+            throw new Error('JWT token required. Call setJwtToken() first or use the jwtToken in constructor.');
+        }
+        return (0, generatePresignedUploadUrl_1.generatePresignedUploadUrl)(options, this.request.bind(this));
+    }
     async downloadFile(fileId) {
         return (0, downloadFile_1.downloadFile)(fileId, this.request.bind(this));
     }
+    async downloadFileWithPresignedToken(options) {
+        return (0, downloadFileWithPresignedToken_1.downloadFileWithPresignedToken)(this.baseUrl, options, this.request.bind(this));
+    }
     async listFiles(folderId) {
         return (0, listFiles_1.listFiles)(folderId, this.request.bind(this));
     }
@@ -35,6 +59,18 @@ class GammaFilesClient {
     async viewFileByToken(fileId, token, compressionValue) {
         return (0, viewFileByToken_1.viewFileByToken)(fileId, token, this.request.bind(this), compressionValue);
     }
+    async generatePresignedFolderDownloadUrl(options) {
+        return (0, folderOperations_1.generatePresignedFolderDownloadUrl)(options, this.request.bind(this));
+    }
+    async prepareFolderDownload(options) {
+        return (0, folderOperations_1.prepareFolderDownload)(options, this.request.bind(this));
+    }
+    async checkPreparedDownload(folderId) {
+        return (0, folderOperations_1.checkPreparedDownload)(folderId, this.request.bind(this));
+    }
+    async downloadFolder(options) {
+        return (0, folderOperations_1.downloadFolder)(this.baseUrl, options, this.request.bind(this));
+    }
     async request(method, path, options) {
         return (0, request_1.makeRequest)(method, path, this.baseUrl, this.apiKey, options);
     }

package/dist/index.d.ts

@@ -1,2 +1,61 @@
-export { GammaFilesClient } from './client';
-export * from './types';
+export interface GammaFilesClientConfig {
+    baseUrl: string;
+    apiKey?: string;
+}
+export interface FileMetadata {
+    id: string;
+    name: string;
+    originalName: string;
+    mimeType: string;
+    size: number;
+    folderId: string;
+    uploadedBy: string;
+    createdAt: string;
+    updatedAt: string | null;
+}
+export interface ListFolderFilesResponse {
+    success: true;
+    files: FileMetadata[];
+}
+export interface UploadPresignedOptions {
+    file: Buffer | Blob | File | NodeJS.ReadableStream;
+    filename: string;
+    mimeType?: string;
+    folderId?: string;
+    token: string;
+}
+export interface UploadPresignedResponse {
+    success: true;
+    file: {
+        id: string;
+        name: string;
+        originalName: string;
+        mimeType: string;
+        size: number;
+        folderId: string;
+        uploadedBy: string;
+        createdAt: string;
+    };
+}
+export interface ViewFileResult {
+    data: ArrayBuffer;
+    headers: {
+        contentType: string;
+        contentLength: number;
+        contentDisposition: string;
+        cacheControl?: string;
+        cdnCacheControl?: string;
+        contentEncoding?: string;
+        vary?: string;
+    };
+}
+export declare class GammaFilesClient {
+    private baseUrl;
+    private apiKey?;
+    constructor(config: GammaFilesClientConfig);
+    uploadPresigned(options: UploadPresignedOptions): Promise<UploadPresignedResponse>;
+    downloadPresigned(fileId: string, token: string): Promise<ArrayBuffer>;
+    downloadFolder(folderId: string, token: string): Promise<ArrayBuffer>;
+    viewFile(fileId: string, token: string, compressionValue?: number): Promise<ViewFileResult>;
+    listFolderFiles(folderId: string): Promise<ListFolderFilesResponse>;
+}

package/dist/index.js

@@ -1,20 +1,34 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GammaFilesClient = void 0;
-var client_1 = require("./client");
-Object.defineProperty(exports, "GammaFilesClient", { enumerable: true, get: function () { return client_1.GammaFilesClient; } });
-__exportStar(require("./types"), exports);
+const uploadPresigned_1 = require("./methods/uploadPresigned");
+const downloadPresigned_1 = require("./methods/downloadPresigned");
+const downloadFolder_1 = require("./methods/downloadFolder");
+const viewFile_1 = require("./methods/viewFile");
+const listFolderFiles_1 = require("./methods/listFolderFiles");
+// Client
+class GammaFilesClient {
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        this.apiKey = config.apiKey;
+    }
+    async uploadPresigned(options) {
+        return (0, uploadPresigned_1.uploadPresigned)(options, this.baseUrl);
+    }
+    async downloadPresigned(fileId, token) {
+        return (0, downloadPresigned_1.downloadPresigned)(fileId, token, this.baseUrl);
+    }
+    async downloadFolder(folderId, token) {
+        return (0, downloadFolder_1.downloadFolder)(folderId, token, this.baseUrl);
+    }
+    async viewFile(fileId, token, compressionValue) {
+        return (0, viewFile_1.viewFile)(fileId, token, this.baseUrl, compressionValue);
+    }
+    async listFolderFiles(folderId) {
+        if (!this.apiKey) {
+            throw new Error('API key is required for listFolderFiles method. Please provide apiKey in the constructor config.');
+        }
+        return (0, listFolderFiles_1.listFolderFiles)(folderId, this.apiKey, this.baseUrl);
+    }
+}
+exports.GammaFilesClient = GammaFilesClient;

package/dist/methods/downloadFileWithPresignedToken.d.ts

@@ -0,0 +1,2 @@
+import { DownloadFileWithPresignedTokenOptions } from '../types';
+export declare function downloadFileWithPresignedToken(baseUrl: string, options: DownloadFileWithPresignedTokenOptions, request: <T>(method: string, path: string, options?: any) => Promise<T>): Promise<ArrayBuffer>;

package/dist/methods/downloadFileWithPresignedToken.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFileWithPresignedToken = downloadFileWithPresignedToken;
+async function downloadFileWithPresignedToken(baseUrl, options, request) {
+    const { fileId, token } = options;
+    const url = `/api/files/download-presigned/${fileId}?token=${encodeURIComponent(token)}`;
+    return request('GET', url, {
+        binary: true,
+        skipAuth: true, // Presigned token is in URL
+    });
+}

package/dist/methods/downloadFolder.d.ts

@@ -0,0 +1 @@
+export declare function downloadFolder(folderId: string, token: string, baseUrl: string): Promise<ArrayBuffer>;

package/dist/methods/downloadFolder.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFolder = downloadFolder;
+async function downloadFolder(folderId, token, baseUrl) {
+    const url = new URL(`/api/files/download-folder/${folderId}`, baseUrl);
+    url.searchParams.append('token', token);
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        const errorText = await response.text();
+        let errorData;
+        try {
+            errorData = JSON.parse(errorText);
+        }
+        catch {
+            errorData = { error: errorText };
+        }
+        throw new Error(errorData.error || errorData.message || `Download folder failed with status ${response.status}`);
+    }
+    return await response.arrayBuffer();
+}

package/dist/methods/downloadPresigned.d.ts

@@ -0,0 +1 @@
+export declare function downloadPresigned(fileId: string, token: string, baseUrl: string): Promise<ArrayBuffer>;

package/dist/methods/downloadPresigned.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadPresigned = downloadPresigned;
+async function downloadPresigned(fileId, token, baseUrl) {
+    const url = new URL(`/api/files/download-presigned/${fileId}`, baseUrl);
+    url.searchParams.append('token', token);
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        const errorText = await response.text();
+        let errorData;
+        try {
+            errorData = JSON.parse(errorText);
+        }
+        catch {
+            errorData = { error: errorText };
+        }
+        throw new Error(errorData.error || errorData.message || `Download presigned failed with status ${response.status}`);
+    }
+    return await response.arrayBuffer();
+}

package/dist/methods/folderOperations.d.ts

@@ -0,0 +1,5 @@
+import { PresignedFolderDownloadUrlOptions, PresignedFolderDownloadUrlResponse, PrepareFolderDownloadOptions, PrepareFolderDownloadResponse, CheckPreparedDownloadResponse, DownloadFolderOptions } from '../types';
+export declare function generatePresignedFolderDownloadUrl(options: PresignedFolderDownloadUrlOptions, request: <T>(method: string, path: string, options?: any) => Promise<T>): Promise<PresignedFolderDownloadUrlResponse>;
+export declare function prepareFolderDownload(options: PrepareFolderDownloadOptions, request: <T>(method: string, path: string, options?: any) => Promise<T>): Promise<PrepareFolderDownloadResponse>;
+export declare function checkPreparedDownload(folderId: string, request: <T>(method: string, path: string, options?: any) => Promise<T>): Promise<CheckPreparedDownloadResponse>;
+export declare function downloadFolder(baseUrl: string, options: DownloadFolderOptions, request: <T>(method: string, path: string, options?: any) => Promise<T>): Promise<ArrayBuffer>;

package/dist/methods/folderOperations.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePresignedFolderDownloadUrl = generatePresignedFolderDownloadUrl;
+exports.prepareFolderDownload = prepareFolderDownload;
+exports.checkPreparedDownload = checkPreparedDownload;
+exports.downloadFolder = downloadFolder;
+async function generatePresignedFolderDownloadUrl(options, request) {
+    const url = '/api/files/presigned-download-folder-url';
+    const payload = {
+        folderId: options.folderId,
+        expiresIn: options.expiresIn || 3600
+    };
+    return request('POST', url, {
+        body: JSON.stringify(payload),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}
+async function prepareFolderDownload(options, request) {
+    const url = '/api/files/prepare-folder-download';
+    const payload = {
+        folderId: options.folderId
+    };
+    return request('POST', url, {
+        body: JSON.stringify(payload),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}
+async function checkPreparedDownload(folderId, request) {
+    const url = `/api/files/check-prepared-download/${folderId}`;
+    return request('GET', url);
+}
+async function downloadFolder(baseUrl, options, request) {
+    const { folderId, token } = options;
+    const url = `/api/files/download-folder/${folderId}?token=${encodeURIComponent(token)}`;
+    return request('GET', url, {
+        binary: true,
+        skipAuth: true, // Presigned token is in URL
+    });
+}

package/dist/methods/generatePresignedUploadUrl.d.ts

@@ -0,0 +1,6 @@
+import { PresignedUploadUrlResponse } from '../types';
+export interface GeneratePresignedUploadUrlOptions {
+    folderId?: string;
+    expiresIn?: number;
+}
+export declare function generatePresignedUploadUrl(options: GeneratePresignedUploadUrlOptions, request: <T>(method: string, path: string, options?: any) => Promise<T>): Promise<PresignedUploadUrlResponse>;

package/dist/methods/generatePresignedUploadUrl.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePresignedUploadUrl = generatePresignedUploadUrl;
+async function generatePresignedUploadUrl(options, request) {
+    const url = '/api/files/presigned-upload-url';
+    const payload = {
+        folderId: options.folderId,
+        expiresIn: options.expiresIn || 3600
+    };
+    return request('POST', url, {
+        body: JSON.stringify(payload),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}

package/dist/methods/listFolderFiles.d.ts

@@ -0,0 +1,16 @@
+export interface FileMetadata {
+    id: string;
+    name: string;
+    originalName: string;
+    mimeType: string;
+    size: number;
+    folderId: string;
+    uploadedBy: string;
+    createdAt: string;
+    updatedAt: string | null;
+}
+export interface ListFolderFilesResponse {
+    success: true;
+    files: FileMetadata[];
+}
+export declare function listFolderFiles(folderId: string, apiKey: string, baseUrl: string): Promise<ListFolderFilesResponse>;

package/dist/methods/listFolderFiles.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listFolderFiles = listFolderFiles;
+const request_1 = require("./request");
+async function listFolderFiles(folderId, apiKey, baseUrl) {
+    return (0, request_1.makeRequest)('GET', `/trpc/listFolderFiles?input=${encodeURIComponent(JSON.stringify({ folderId }))}`, baseUrl, apiKey);
+}

package/dist/methods/request.d.ts

@@ -1,7 +1,5 @@
 export declare function makeRequest<T>(method: string, path: string, baseUrl: string, apiKey: string, options?: {
     body?: any;
     headers?: Record<string, string>;
-    binary?: boolean;
-    skipAuth?: boolean;
-    includeHeaders?: boolean;
+    query?: Record<string, string>;
 }): Promise<T>;

package/dist/methods/request.js

@@ -1,122 +1,46 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeRequest = makeRequest;
-const https = __importStar(require("https"));
-const http = __importStar(require("http"));
-const url_1 = require("url");
-const form_data_1 = __importDefault(require("form-data"));
-async function makeRequest(method, path, baseUrl, apiKey, options = {}) {
-    const url = new url_1.URL(path, baseUrl);
-    const isHttps = url.protocol === 'https:';
-    const lib = isHttps ? https : http;
-    return new Promise((resolve, reject) => {
-        const headers = {
-            ...options.headers,
-        };
-        if (!options.skipAuth) {
-            headers['Authorization'] = `Bearer ${apiKey}`;
-        }
-        if (options.body && !(options.body instanceof form_data_1.default)) {
-            if (typeof options.body === 'string') {
-                headers['Content-Length'] = Buffer.byteLength(options.body).toString();
+async function makeRequest(method, path, baseUrl, apiKey, options) {
+    const url = new URL(path, baseUrl);
+    if (options?.query) {
+        Object.entries(options.query).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                url.searchParams.append(key, value);
             }
-        }
-        const reqOptions = {
-            method,
-            headers,
-        };
-        const req = lib.request(url, reqOptions, (res) => {
-            const chunks = [];
-            res.on('data', (chunk) => {
-                chunks.push(chunk);
-            });
-            res.on('end', () => {
-                const buffer = Buffer.concat(chunks);
-                const responseText = buffer.toString();
-                if (res.statusCode && res.statusCode >= 400) {
-                    const errorBody = JSON.parse(responseText);
-                    const fullError = new Error(errorBody.error || errorBody.message || `HTTP ${res.statusCode}`);
-                    fullError.statusCode = res.statusCode;
-                    fullError.responseBody = errorBody;
-                    reject(fullError);
-                    return;
-                }
-                if (options.binary) {
-                    const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-                    if (options.includeHeaders) {
-                        const result = {
-                            data: arrayBuffer,
-                            headers: {
-                                contentType: res.headers['content-type'] || '',
-                                contentLength: parseInt(res.headers['content-length'] || '0', 10),
-                                contentDisposition: res.headers['content-disposition'] || '',
-                                etag: res.headers['etag'],
-                                cacheControl: res.headers['cache-control'],
-                                cfCacheTag: res.headers['cf-cache-tag'],
-                            }
-                        };
-                        resolve(result);
-                    }
-                    else {
-                        resolve(arrayBuffer);
-                    }
-                }
-                else {
-                    const data = JSON.parse(responseText);
-                    resolve(data);
-                }
-            });
-        });
-        req.on('error', (err) => {
-            reject(err);
         });
-        if (options.body) {
-            if (options.body instanceof form_data_1.default) {
-                options.body.pipe(req);
-            }
-            else {
-                req.write(options.body);
-                req.end();
-            }
+    }
+    const headers = {
+        'X-API-Key': apiKey,
+        ...options?.headers,
+    };
+    if (options?.body && typeof options.body === 'object' && !(options.body instanceof FormData)) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const fetchOptions = {
+        method,
+        headers,
+    };
+    if (options?.body) {
+        fetchOptions.body = options.body instanceof FormData || typeof options.body === 'string'
+            ? options.body
+            : JSON.stringify(options.body);
+    }
+    const response = await fetch(url.toString(), fetchOptions);
+    if (!response.ok) {
+        const errorText = await response.text();
+        let errorData;
+        try {
+            errorData = JSON.parse(errorText);
         }
-        else {
-            req.end();
+        catch {
+            errorData = { error: errorText };
         }
-    });
+        throw new Error(errorData.error || errorData.message || `Request failed with status ${response.status}`);
+    }
+    const contentType = response.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+        return await response.json();
+    }
+    return response;
 }

package/dist/methods/uploadFileWithJWT.d.ts

@@ -0,0 +1,2 @@
+import { UploadFileOptions, UploadFileResponse } from '../types';
+export declare function uploadFileWithJWT(baseUrl: string, jwtToken: string, options: UploadFileOptions, request: <T>(method: string, path: string, options?: any) => Promise<T>): Promise<UploadFileResponse>;

package/dist/methods/uploadFileWithJWT.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFileWithJWT = uploadFileWithJWT;
+const form_data_1 = __importDefault(require("form-data"));
+const stream_1 = require("stream");
+async function uploadFileWithJWT(baseUrl, jwtToken, options, request) {
+    const { file, filename, mimeType, folderId } = options;
+    const form = new form_data_1.default();
+    let contentType = mimeType || 'application/octet-stream';
+    // Handle different file input types
+    if (file instanceof stream_1.Readable || file.pipe) {
+        form.append('file', file, {
+            filename,
+            contentType,
+        });
+    }
+    else if (Buffer.isBuffer(file)) {
+        form.append('file', file, {
+            filename,
+            contentType,
+        });
+    }
+    else if (typeof file === 'string') {
+        const fileBuffer = Buffer.from(file, 'base64');
+        form.append('file', fileBuffer, {
+            filename,
+            contentType,
+        });
+    }
+    else if (typeof Blob !== 'undefined' && file instanceof Blob) {
+        const arrayBuffer = await file.arrayBuffer();
+        const fileBuffer = Buffer.from(arrayBuffer);
+        contentType = mimeType || file.type || 'application/octet-stream';
+        form.append('file', fileBuffer, {
+            filename,
+            contentType,
+        });
+    }
+    else if (typeof File !== 'undefined' && file instanceof File) {
+        const arrayBuffer = await file.arrayBuffer();
+        const fileBuffer = Buffer.from(arrayBuffer);
+        contentType = mimeType || file.type || 'application/octet-stream';
+        form.append('file', fileBuffer, {
+            filename,
+            contentType,
+        });
+    }
+    else {
+        throw new Error('Unsupported file type. Supported types: Buffer, Stream, Blob, File, or base64 string');
+    }
+    const url = folderId
+        ? `/api/files/upload-auth/${folderId}`
+        : '/api/files/upload-auth';
+    const headers = {
+        ...form.getHeaders(),
+        'Authorization': `Bearer ${jwtToken}`
+    };
+    return request('POST', url, {
+        body: form,
+        headers: headers,
+        skipAuth: true, // Using JWT instead of API key
+    });
+}

package/dist/methods/uploadFileWithPresignedToken.d.ts

@@ -0,0 +1,2 @@
+import { UploadWithPresignedTokenOptions, UploadFileResponse } from '../types';
+export declare function uploadFileWithPresignedToken(baseUrl: string, options: UploadWithPresignedTokenOptions, request: <T>(method: string, path: string, options?: any) => Promise<T>): Promise<UploadFileResponse>;

package/dist/methods/uploadFileWithPresignedToken.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFileWithPresignedToken = uploadFileWithPresignedToken;
+const form_data_1 = __importDefault(require("form-data"));
+const stream_1 = require("stream");
+async function uploadFileWithPresignedToken(baseUrl, options, request) {
+    const { file, filename, mimeType, token, folderId } = options;
+    const form = new form_data_1.default();
+    let contentType = mimeType || 'application/octet-stream';
+    // Handle different file input types
+    if (file instanceof stream_1.Readable || file.pipe) {
+        // Stream support for Node.js - efficient for large files
+        form.append('file', file, {
+            filename,
+            contentType,
+        });
+    }
+    else if (Buffer.isBuffer(file)) {
+        // Direct buffer support
+        form.append('file', file, {
+            filename,
+            contentType,
+        });
+    }
+    else if (typeof file === 'string') {
+        // Handle base64 string - convert to buffer
+        const fileBuffer = Buffer.from(file, 'base64');
+        form.append('file', fileBuffer, {
+            filename,
+            contentType,
+        });
+    }
+    else if (typeof Blob !== 'undefined' && file instanceof Blob) {
+        // Browser Blob support - must convert to buffer
+        const arrayBuffer = await file.arrayBuffer();
+        const fileBuffer = Buffer.from(arrayBuffer);
+        contentType = mimeType || file.type || 'application/octet-stream';
+        form.append('file', fileBuffer, {
+            filename,
+            contentType,
+        });
+    }
+    else if (typeof File !== 'undefined' && file instanceof File) {
+        // Browser File support - must convert to buffer
+        const arrayBuffer = await file.arrayBuffer();
+        const fileBuffer = Buffer.from(arrayBuffer);
+        contentType = mimeType || file.type || 'application/octet-stream';
+        form.append('file', fileBuffer, {
+            filename,
+            contentType,
+        });
+    }
+    else {
+        throw new Error('Unsupported file type. Supported types: Buffer, Stream, Blob, File, or base64 string');
+    }
+    const url = folderId
+        ? `/api/files/upload-presigned/${folderId}?token=${encodeURIComponent(token)}`
+        : `/api/files/upload-presigned?token=${encodeURIComponent(token)}`;
+    return request('POST', url, {
+        body: form,
+        headers: form.getHeaders(),
+        skipAuth: true, // Presigned token is in URL
+    });
+}

package/dist/methods/uploadPresigned.d.ts

@@ -0,0 +1,21 @@
+export interface UploadPresignedOptions {
+    file: Buffer | Blob | File | NodeJS.ReadableStream;
+    filename: string;
+    mimeType?: string;
+    folderId?: string;
+    token: string;
+}
+export interface UploadPresignedResponse {
+    success: true;
+    file: {
+        id: string;
+        name: string;
+        originalName: string;
+        mimeType: string;
+        size: number;
+        folderId: string;
+        uploadedBy: string;
+        createdAt: string;
+    };
+}
+export declare function uploadPresigned(options: UploadPresignedOptions, baseUrl: string): Promise<UploadPresignedResponse>;

package/dist/methods/uploadPresigned.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadPresigned = uploadPresigned;
+async function uploadPresigned(options, baseUrl) {
+    const { file, filename, mimeType, folderId, token } = options;
+    const formData = new FormData();
+    // Handle different file input types
+    if (file instanceof Buffer) {
+        const blob = new Blob([file], { type: mimeType || 'application/octet-stream' });
+        formData.append('file', blob, filename);
+    }
+    else if (typeof file === 'object' && 'pipe' in file) {
+        // NodeJS.ReadableStream - not directly supported in FormData in browser
+        throw new Error('ReadableStream not supported in browser environment. Use Buffer or Blob.');
+    }
+    else {
+        // Blob or File
+        formData.append('file', file, filename);
+    }
+    const url = new URL(`/api/files/upload-presigned/${folderId || ''}`, baseUrl);
+    url.searchParams.append('token', token);
+    const response = await fetch(url.toString(), {
+        method: 'POST',
+        body: formData,
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        let errorData;
+        try {
+            errorData = JSON.parse(errorText);
+        }
+        catch {
+            errorData = { error: errorText };
+        }
+        throw new Error(errorData.error || errorData.message || `Upload presigned failed with status ${response.status}`);
+    }
+    return await response.json();
+}

package/dist/methods/viewFile.d.ts

@@ -0,0 +1,13 @@
+export interface ViewFileResult {
+    data: ArrayBuffer;
+    headers: {
+        contentType: string;
+        contentLength: number;
+        contentDisposition: string;
+        cacheControl?: string;
+        cdnCacheControl?: string;
+        contentEncoding?: string;
+        vary?: string;
+    };
+}
+export declare function viewFile(fileId: string, token: string, baseUrl: string, compressionValue?: number): Promise<ViewFileResult>;

package/dist/methods/viewFile.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewFile = viewFile;
+async function viewFile(fileId, token, baseUrl, compressionValue) {
+    const url = new URL(`/api/files/view/${fileId}`, baseUrl);
+    url.searchParams.append('token', token);
+    if (compressionValue !== undefined) {
+        url.searchParams.append('compressionValue', compressionValue.toString());
+    }
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+        const errorText = await response.text();
+        let errorData;
+        try {
+            errorData = JSON.parse(errorText);
+        }
+        catch {
+            errorData = { error: errorText };
+        }
+        throw new Error(errorData.error || errorData.message || `View file failed with status ${response.status}`);
+    }
+    const data = await response.arrayBuffer();
+    return {
+        data,
+        headers: {
+            contentType: response.headers.get('content-type') || 'application/octet-stream',
+            contentLength: parseInt(response.headers.get('content-length') || '0', 10),
+            contentDisposition: response.headers.get('content-disposition') || '',
+            cacheControl: response.headers.get('cache-control') || undefined,
+            cdnCacheControl: response.headers.get('cdn-cache-control') || undefined,
+            contentEncoding: response.headers.get('content-encoding') || undefined,
+            vary: response.headers.get('vary') || undefined,
+        },
+    };
+}

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 export interface GammaFilesClientConfig {
     baseUrl: string;
     apiKey: string;
+    jwtToken?: string;
 }
 export interface FileMetadata {
     id: string;
@@ -60,6 +61,52 @@ export interface ViewFileByTokenResult {
         cfCacheTag?: string;
     };
 }
+export interface UploadWithPresignedTokenOptions {
+    file: Buffer | Blob | File | string | NodeJS.ReadableStream;
+    filename: string;
+    mimeType?: string;
+    token: string;
+    folderId?: string;
+}
+export interface DownloadFileWithPresignedTokenOptions {
+    fileId: string;
+    token: string;
+}
+export interface PresignedUploadUrlResponse {
+    success: true;
+    token: string;
+    url: string;
+    expiresAt: string;
+}
+export interface PresignedFolderDownloadUrlOptions {
+    folderId: string;
+    expiresIn?: number;
+}
+export interface PresignedFolderDownloadUrlResponse {
+    success: true;
+    token: string;
+    url: string;
+    expiresAt: string;
+}
+export interface PrepareFolderDownloadOptions {
+    folderId: string;
+}
+export interface PrepareFolderDownloadResponse {
+    success: true;
+    message: string;
+    zipPath: string;
+    size: number;
+}
+export interface CheckPreparedDownloadResponse {
+    success: true;
+    exists: boolean;
+    zipPath?: string;
+    size?: number;
+}
+export interface DownloadFolderOptions {
+    folderId: string;
+    token: string;
+}
 export interface ApiErrorResponse {
     success: false;
     error: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oasis-path/gamma-sdk",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "TypeScript SDK for Gamma Files API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +8,8 @@
   "scripts": {
     "build": "tsc",
     "watch": "tsc --watch",
-    "prepublishOnly": "pnpm run build"
+    "prepublishOnly": "pnpm run build",
+    "publish": "pnpm run build && git add . && git commit -m 'chore: publish new version' && git push && pnpm publish --no-git-checks"
   },
   "keywords": [
     "gamma",