@ductape/sdk 0.0.4-v6 → 0.0.4-v60

package/dist/storage/types/index.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Storage Types
+ */
+import { StorageProviders } from '../../types';
+/**
+ * Storage service configuration
+ */
+export interface IStorageServiceConfig {
+    workspace_id: string;
+    public_key: string;
+    user_id: string;
+    token: string;
+    env_type: string;
+    redis_client?: any;
+}
+/**
+ * Storage provider configuration
+ */
+export interface IStorageProviderConfig {
+    provider: StorageProviders;
+    awsConfig?: IAWSStorageConfig;
+    gcpConfig?: IGCPStorageConfig;
+    azureConfig?: IAzureStorageConfig;
+}
+/**
+ * AWS S3 configuration
+ */
+export interface IAWSStorageConfig {
+    bucketName: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    region: string;
+}
+/**
+ * GCP Cloud Storage configuration
+ */
+export interface IGCPStorageConfig {
+    bucketName: string;
+    config: {
+        type: string;
+        project_id: string;
+        private_key_id: string;
+        private_key: string;
+        client_email: string;
+        client_id: string;
+        auth_uri: string;
+        token_uri: string;
+        auth_provider_x509_cert_url: string;
+        client_x509_cert_url: string;
+    };
+}
+/**
+ * Azure Blob Storage configuration
+ */
+export interface IAzureStorageConfig {
+    containerName: string;
+    connectionString: string;
+}
+/**
+ * Upload request options
+ */
+export interface IUploadOptions {
+    product: string;
+    env: string;
+    storage: string;
+    fileName: string;
+    buffer: string | Buffer;
+    mimeType?: string;
+    cache?: string;
+    session?: string;
+}
+/**
+ * Download request options
+ */
+export interface IDownloadOptions {
+    product: string;
+    env: string;
+    storage: string;
+    fileName: string;
+    cache?: string;
+    session?: string;
+}
+/**
+ * Delete request options
+ */
+export interface IDeleteOptions {
+    product: string;
+    env: string;
+    storage: string;
+    fileName: string;
+    session?: string;
+}
+/**
+ * List files request options with pagination
+ */
+export interface IListFilesOptions {
+    product: string;
+    env: string;
+    storage: string;
+    prefix?: string;
+    /** Maximum results per page (default: 100, max: 1000) */
+    limit?: number;
+    /** Page number for offset-based pagination (1-indexed) */
+    page?: number;
+    /** Continuation token for cursor-based pagination (preferred for large datasets) */
+    continuationToken?: string;
+    session?: string;
+}
+/**
+ * Storage operation result
+ */
+export interface IStorageResult {
+    success: boolean;
+    url?: string;
+    fileName?: string;
+    size?: number;
+    mimeType?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Download result
+ */
+export interface IDownloadResult {
+    success: boolean;
+    data?: Buffer | string;
+    fileName?: string;
+    size?: number;
+    mimeType?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Delete result
+ */
+export interface IDeleteResult {
+    success: boolean;
+    fileName?: string;
+}
+/**
+ * List files result with pagination info
+ */
+export interface IListFilesResult {
+    success: boolean;
+    files: IStorageFileInfo[];
+    /** Total count of files (when available) */
+    total?: number;
+    /** Current page number */
+    page?: number;
+    /** Items per page */
+    limit?: number;
+    /** Next continuation token for cursor-based pagination */
+    nextToken?: string;
+    /** Whether there are more results */
+    hasMore: boolean;
+}
+/**
+ * Storage file info
+ */
+export interface IStorageFileInfo {
+    name: string;
+    size: number;
+    lastModified: Date;
+    url?: string;
+    mimeType?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Signed URL options
+ */
+export interface ISignedUrlOptions {
+    product: string;
+    env: string;
+    storage: string;
+    fileName: string;
+    expiresIn?: number;
+    action?: 'read' | 'write';
+    session?: string;
+}
+/**
+ * Signed URL result
+ */
+export interface ISignedUrlResult {
+    success: boolean;
+    url: string;
+    expiresAt: Date;
+}
+/**
+ * Storage dispatch options for background jobs
+ */
+export interface IStorageDispatchOptions {
+    product: string;
+    env: string;
+    storage: string;
+    fileName: string;
+    buffer?: string | Buffer;
+    mimeType?: string;
+    operation: 'upload' | 'delete';
+    startAt?: number;
+    /** Session token in format: session_tag:jwt_token */
+    session?: string;
+}
+/**
+ * Storage dispatch result
+ */
+export interface IStorageDispatchResult {
+    jobId: string;
+    status: 'queued' | 'processing' | 'completed' | 'failed';
+}

package/dist/storage/types/index.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Storage Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/storage/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/storage/types/index.ts"],"names":[],"mappings":";AAAA;;GAEG"}

package/dist/storage/utils/storage.util.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Storage utility functions for cloud provider operations
+ */
+import { IStorageProviderConfig, IDownloadResult, IDeleteResult, IListFilesResult, ISignedUrlResult } from '../types';
+interface UploadBlobOptions {
+    data: string | Buffer;
+    destinationPath: string;
+    config: IStorageProviderConfig;
+    mimeType?: string;
+}
+interface DownloadBlobOptions {
+    filePath: string;
+    config: IStorageProviderConfig;
+}
+interface DeleteBlobOptions {
+    filePath: string;
+    config: IStorageProviderConfig;
+}
+interface ListBlobsOptions {
+    prefix?: string;
+    maxResults?: number;
+    continuationToken?: string;
+    config: IStorageProviderConfig;
+}
+interface SignedUrlOptions {
+    filePath: string;
+    config: IStorageProviderConfig;
+    expiresIn?: number;
+    action?: 'read' | 'write';
+}
+/**
+ * Upload a file to cloud storage
+ */
+export declare function uploadBlobToCloud({ data, destinationPath, config, mimeType, }: UploadBlobOptions): Promise<string>;
+/**
+ * Download a file from cloud storage
+ */
+export declare function downloadBlobFromCloud({ filePath, config, }: DownloadBlobOptions): Promise<IDownloadResult>;
+/**
+ * Delete a file from cloud storage
+ */
+export declare function deleteBlobFromCloud({ filePath, config, }: DeleteBlobOptions): Promise<IDeleteResult>;
+/**
+ * List files in cloud storage with pagination
+ */
+export declare function listBlobsInCloud({ prefix, maxResults, continuationToken, config, }: ListBlobsOptions): Promise<IListFilesResult>;
+/**
+ * Generate a signed URL for temporary access
+ */
+export declare function generateSignedUrl({ filePath, config, expiresIn, action, }: SignedUrlOptions): Promise<ISignedUrlResult>;
+export {};

package/dist/storage/utils/storage.util.js

@@ -0,0 +1,402 @@
+"use strict";
+/**
+ * Storage utility functions for cloud provider operations
+ */
+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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadBlobToCloud = uploadBlobToCloud;
+exports.downloadBlobFromCloud = downloadBlobFromCloud;
+exports.deleteBlobFromCloud = deleteBlobFromCloud;
+exports.listBlobsInCloud = listBlobsInCloud;
+exports.generateSignedUrl = generateSignedUrl;
+const types_1 = require("../../types");
+/**
+ * Check if running in browser environment
+ */
+function isBrowser() {
+    return typeof window !== 'undefined';
+}
+/**
+ * Upload a file to cloud storage
+ */
+async function uploadBlobToCloud({ data, destinationPath, config, mimeType, }) {
+    if (isBrowser()) {
+        throw new Error('Cloud storage operations are not supported in browser environment');
+    }
+    const bufferData = typeof data === 'string' ? Buffer.from(data, 'base64') : data;
+    switch (config.provider) {
+        case types_1.StorageProviders.AWS: {
+            const AWS = await Promise.resolve().then(() => __importStar(require('aws-sdk')));
+            const { bucketName, accessKeyId, secretAccessKey, region } = config.awsConfig;
+            const s3 = new AWS.S3({ accessKeyId, secretAccessKey, region });
+            const params = {
+                Bucket: bucketName,
+                Key: destinationPath,
+                Body: bufferData,
+                ContentType: mimeType,
+            };
+            const result = await s3.upload(params).promise();
+            return result.Location;
+        }
+        case types_1.StorageProviders.GCP: {
+            const { Storage } = await Promise.resolve().then(() => __importStar(require('@google-cloud/storage')));
+            const { bucketName, config: credentials } = config.gcpConfig;
+            const normalizedCredentials = Object.assign(Object.assign({}, credentials), { private_key: credentials.private_key.replace(/\\n/g, '\n') });
+            const storage = new Storage({ credentials: normalizedCredentials });
+            const bucket = storage.bucket(bucketName);
+            const file = bucket.file(destinationPath);
+            await file.save(bufferData, { contentType: mimeType });
+            return `https://storage.googleapis.com/${bucketName}/${destinationPath}`;
+        }
+        case types_1.StorageProviders.AZURE: {
+            const { BlobServiceClient } = await Promise.resolve().then(() => __importStar(require('@azure/storage-blob')));
+            const { containerName, connectionString } = config.azureConfig;
+            const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+            const containerClient = blobServiceClient.getContainerClient(containerName);
+            const blockBlobClient = containerClient.getBlockBlobClient(destinationPath);
+            await blockBlobClient.upload(bufferData, bufferData.length, {
+                blobHTTPHeaders: { blobContentType: mimeType },
+            });
+            return blockBlobClient.url;
+        }
+        default:
+            throw new Error('Unsupported cloud provider');
+    }
+}
+/**
+ * Download a file from cloud storage
+ */
+async function downloadBlobFromCloud({ filePath, config, }) {
+    var _a, e_1, _b, _c;
+    if (isBrowser()) {
+        throw new Error('Cloud storage operations are not supported in browser environment');
+    }
+    switch (config.provider) {
+        case types_1.StorageProviders.AWS: {
+            const AWS = await Promise.resolve().then(() => __importStar(require('aws-sdk')));
+            const { bucketName, accessKeyId, secretAccessKey, region } = config.awsConfig;
+            const s3 = new AWS.S3({ accessKeyId, secretAccessKey, region });
+            const params = {
+                Bucket: bucketName,
+                Key: filePath,
+            };
+            const result = await s3.getObject(params).promise();
+            return {
+                success: true,
+                data: result.Body,
+                fileName: filePath,
+                size: result.ContentLength,
+                mimeType: result.ContentType,
+                metadata: result.Metadata,
+            };
+        }
+        case types_1.StorageProviders.GCP: {
+            const { Storage } = await Promise.resolve().then(() => __importStar(require('@google-cloud/storage')));
+            const { bucketName, config: credentials } = config.gcpConfig;
+            const normalizedCredentials = Object.assign(Object.assign({}, credentials), { private_key: credentials.private_key.replace(/\\n/g, '\n') });
+            const storage = new Storage({ credentials: normalizedCredentials });
+            const bucket = storage.bucket(bucketName);
+            const file = bucket.file(filePath);
+            const [data] = await file.download();
+            const [metadata] = await file.getMetadata();
+            return {
+                success: true,
+                data,
+                fileName: filePath,
+                size: metadata.size ? Number(metadata.size) : undefined,
+                mimeType: metadata.contentType,
+                metadata: metadata.metadata,
+            };
+        }
+        case types_1.StorageProviders.AZURE: {
+            const { BlobServiceClient } = await Promise.resolve().then(() => __importStar(require('@azure/storage-blob')));
+            const { containerName, connectionString } = config.azureConfig;
+            const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+            const containerClient = blobServiceClient.getContainerClient(containerName);
+            const blockBlobClient = containerClient.getBlockBlobClient(filePath);
+            const downloadResponse = await blockBlobClient.download();
+            const chunks = [];
+            if (downloadResponse.readableStreamBody) {
+                try {
+                    for (var _d = true, _e = __asyncValues(downloadResponse.readableStreamBody), _f; _f = await _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const chunk = _c;
+                        chunks.push(Buffer.from(chunk));
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            const data = Buffer.concat(chunks);
+            const properties = await blockBlobClient.getProperties();
+            return {
+                success: true,
+                data,
+                fileName: filePath,
+                size: properties.contentLength,
+                mimeType: properties.contentType,
+                metadata: properties.metadata,
+            };
+        }
+        default:
+            throw new Error('Unsupported cloud provider');
+    }
+}
+/**
+ * Delete a file from cloud storage
+ */
+async function deleteBlobFromCloud({ filePath, config, }) {
+    if (isBrowser()) {
+        throw new Error('Cloud storage operations are not supported in browser environment');
+    }
+    switch (config.provider) {
+        case types_1.StorageProviders.AWS: {
+            const AWS = await Promise.resolve().then(() => __importStar(require('aws-sdk')));
+            const { bucketName, accessKeyId, secretAccessKey, region } = config.awsConfig;
+            const s3 = new AWS.S3({ accessKeyId, secretAccessKey, region });
+            const params = {
+                Bucket: bucketName,
+                Key: filePath,
+            };
+            await s3.deleteObject(params).promise();
+            return { success: true, fileName: filePath };
+        }
+        case types_1.StorageProviders.GCP: {
+            const { Storage } = await Promise.resolve().then(() => __importStar(require('@google-cloud/storage')));
+            const { bucketName, config: credentials } = config.gcpConfig;
+            const normalizedCredentials = Object.assign(Object.assign({}, credentials), { private_key: credentials.private_key.replace(/\\n/g, '\n') });
+            const storage = new Storage({ credentials: normalizedCredentials });
+            const bucket = storage.bucket(bucketName);
+            const file = bucket.file(filePath);
+            await file.delete();
+            return { success: true, fileName: filePath };
+        }
+        case types_1.StorageProviders.AZURE: {
+            const { BlobServiceClient } = await Promise.resolve().then(() => __importStar(require('@azure/storage-blob')));
+            const { containerName, connectionString } = config.azureConfig;
+            const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+            const containerClient = blobServiceClient.getContainerClient(containerName);
+            const blockBlobClient = containerClient.getBlockBlobClient(filePath);
+            await blockBlobClient.delete();
+            return { success: true, fileName: filePath };
+        }
+        default:
+            throw new Error('Unsupported cloud provider');
+    }
+}
+/**
+ * List files in cloud storage with pagination
+ */
+async function listBlobsInCloud({ prefix, maxResults, continuationToken, config, }) {
+    if (isBrowser()) {
+        throw new Error('Cloud storage operations are not supported in browser environment');
+    }
+    const limit = Math.min(maxResults || 100, 1000); // Default 100, max 1000
+    switch (config.provider) {
+        case types_1.StorageProviders.AWS: {
+            const AWS = await Promise.resolve().then(() => __importStar(require('aws-sdk')));
+            const { bucketName, accessKeyId, secretAccessKey, region } = config.awsConfig;
+            const s3 = new AWS.S3({ accessKeyId, secretAccessKey, region });
+            const params = {
+                Bucket: bucketName,
+                Prefix: prefix,
+                MaxKeys: limit,
+                ContinuationToken: continuationToken,
+            };
+            const result = await s3.listObjectsV2(params).promise();
+            const hasMore = result.IsTruncated || false;
+            return {
+                success: true,
+                files: (result.Contents || []).map(item => ({
+                    name: item.Key || '',
+                    size: item.Size || 0,
+                    lastModified: item.LastModified || new Date(),
+                    url: `https://${bucketName}.s3.amazonaws.com/${item.Key}`,
+                })),
+                total: result.KeyCount,
+                limit,
+                nextToken: result.NextContinuationToken,
+                hasMore,
+            };
+        }
+        case types_1.StorageProviders.GCP: {
+            const { Storage } = await Promise.resolve().then(() => __importStar(require('@google-cloud/storage')));
+            const { bucketName, config: credentials } = config.gcpConfig;
+            const normalizedCredentials = Object.assign(Object.assign({}, credentials), { private_key: credentials.private_key.replace(/\\n/g, '\n') });
+            const storage = new Storage({ credentials: normalizedCredentials });
+            const bucket = storage.bucket(bucketName);
+            const [files, , apiResponse] = await bucket.getFiles({
+                prefix,
+                maxResults: limit,
+                pageToken: continuationToken,
+                autoPaginate: false,
+            });
+            const nextToken = apiResponse === null || apiResponse === void 0 ? void 0 : apiResponse.nextPageToken;
+            return {
+                success: true,
+                files: files.map(file => ({
+                    name: file.name,
+                    size: file.metadata.size ? Number(file.metadata.size) : 0,
+                    lastModified: new Date(file.metadata.updated || file.metadata.timeCreated),
+                    url: `https://storage.googleapis.com/${bucketName}/${file.name}`,
+                    mimeType: file.metadata.contentType,
+                })),
+                limit,
+                nextToken,
+                hasMore: !!nextToken,
+            };
+        }
+        case types_1.StorageProviders.AZURE: {
+            const { BlobServiceClient } = await Promise.resolve().then(() => __importStar(require('@azure/storage-blob')));
+            const { containerName, connectionString } = config.azureConfig;
+            const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+            const containerClient = blobServiceClient.getContainerClient(containerName);
+            const files = [];
+            let lastMarker;
+            let hasMore = false;
+            // Use the iterator with pagination
+            const iterator = containerClient.listBlobsFlat({ prefix }).byPage({
+                maxPageSize: limit,
+                continuationToken,
+            });
+            const page = await iterator.next();
+            if (!page.done && page.value) {
+                for (const blob of page.value.segment.blobItems) {
+                    files.push({
+                        name: blob.name,
+                        size: blob.properties.contentLength || 0,
+                        lastModified: blob.properties.lastModified || new Date(),
+                        url: `${containerClient.url}/${blob.name}`,
+                        mimeType: blob.properties.contentType,
+                    });
+                }
+                lastMarker = page.value.continuationToken;
+                hasMore = !!lastMarker;
+            }
+            return {
+                success: true,
+                files,
+                limit,
+                nextToken: lastMarker,
+                hasMore,
+            };
+        }
+        default:
+            throw new Error('Unsupported cloud provider');
+    }
+}
+/**
+ * Generate a signed URL for temporary access
+ */
+async function generateSignedUrl({ filePath, config, expiresIn = 3600, action = 'read', }) {
+    var _a, _b;
+    if (isBrowser()) {
+        throw new Error('Cloud storage operations are not supported in browser environment');
+    }
+    const expiresAt = new Date(Date.now() + expiresIn * 1000);
+    switch (config.provider) {
+        case types_1.StorageProviders.AWS: {
+            const AWS = await Promise.resolve().then(() => __importStar(require('aws-sdk')));
+            const { bucketName, accessKeyId, secretAccessKey, region } = config.awsConfig;
+            const s3 = new AWS.S3({ accessKeyId, secretAccessKey, region });
+            const params = {
+                Bucket: bucketName,
+                Key: filePath,
+                Expires: expiresIn,
+            };
+            const url = action === 'read'
+                ? s3.getSignedUrl('getObject', params)
+                : s3.getSignedUrl('putObject', params);
+            return { success: true, url, expiresAt };
+        }
+        case types_1.StorageProviders.GCP: {
+            const { Storage } = await Promise.resolve().then(() => __importStar(require('@google-cloud/storage')));
+            const { bucketName, config: credentials } = config.gcpConfig;
+            const normalizedCredentials = Object.assign(Object.assign({}, credentials), { private_key: credentials.private_key.replace(/\\n/g, '\n') });
+            const storage = new Storage({ credentials: normalizedCredentials });
+            const bucket = storage.bucket(bucketName);
+            const file = bucket.file(filePath);
+            const [url] = await file.getSignedUrl({
+                action: action === 'read' ? 'read' : 'write',
+                expires: expiresAt,
+            });
+            return { success: true, url, expiresAt };
+        }
+        case types_1.StorageProviders.AZURE: {
+            const { BlobServiceClient, generateBlobSASQueryParameters, BlobSASPermissions, StorageSharedKeyCredential } = await Promise.resolve().then(() => __importStar(require('@azure/storage-blob')));
+            const { containerName, connectionString } = config.azureConfig;
+            // Parse connection string to get account name and key
+            const accountName = (_a = connectionString.match(/AccountName=([^;]+)/)) === null || _a === void 0 ? void 0 : _a[1];
+            const accountKey = (_b = connectionString.match(/AccountKey=([^;]+)/)) === null || _b === void 0 ? void 0 : _b[1];
+            if (!accountName || !accountKey) {
+                throw new Error('Invalid Azure connection string');
+            }
+            const sharedKeyCredential = new StorageSharedKeyCredential(accountName, accountKey);
+            const permissions = action === 'read'
+                ? BlobSASPermissions.parse('r')
+                : BlobSASPermissions.parse('w');
+            const sasToken = generateBlobSASQueryParameters({
+                containerName,
+                blobName: filePath,
+                permissions,
+                expiresOn: expiresAt,
+            }, sharedKeyCredential).toString();
+            const blobServiceClient = BlobServiceClient.fromConnectionString(connectionString);
+            const containerClient = blobServiceClient.getContainerClient(containerName);
+            const blobClient = containerClient.getBlobClient(filePath);
+            return {
+                success: true,
+                url: `${blobClient.url}?${sasToken}`,
+                expiresAt,
+            };
+        }
+        default:
+            throw new Error('Unsupported cloud provider');
+    }
+}
+//# sourceMappingURL=storage.util.js.map