digital-tools 2.0.2 → 2.1.1

package/src/providers/media/cloudinary.js

@@ -0,0 +1,318 @@
+/**
+ * Cloudinary Media Provider
+ *
+ * Concrete implementation of MediaProvider using Cloudinary API.
+ *
+ * @packageDocumentation
+ */
+import { defineProvider } from '../registry.js';
+const CLOUDINARY_API_VERSION = 'v1_1';
+/**
+ * Cloudinary provider info
+ */
+export const cloudinaryInfo = {
+    id: 'media.cloudinary',
+    name: 'Cloudinary',
+    description: 'Cloud-based image and video management service',
+    category: 'media',
+    website: 'https://cloudinary.com',
+    docsUrl: 'https://cloudinary.com/documentation',
+    requiredConfig: ['cloudName', 'apiKey', 'apiSecret'],
+    optionalConfig: ['uploadPreset', 'secure'],
+};
+/**
+ * Create Cloudinary media provider
+ */
+export function createCloudinaryProvider(config) {
+    let cloudName;
+    let apiKey;
+    let apiSecret;
+    let secure;
+    function getApiUrl() {
+        return `https://api.cloudinary.com/${CLOUDINARY_API_VERSION}/${cloudName}`;
+    }
+    function getAuthHeader() {
+        return 'Basic ' + Buffer.from(`${apiKey}:${apiSecret}`).toString('base64');
+    }
+    function buildTransformUrl(publicId, resourceType, transforms) {
+        const protocol = secure ? 'https' : 'http';
+        const baseUrl = `${protocol}://res.cloudinary.com/${cloudName}`;
+        if (!transforms) {
+            return `${baseUrl}/${resourceType}/upload/${publicId}`;
+        }
+        const parts = [];
+        if (transforms.width)
+            parts.push(`w_${transforms.width}`);
+        if (transforms.height)
+            parts.push(`h_${transforms.height}`);
+        if (transforms.crop)
+            parts.push(`c_${transforms.crop}`);
+        if (transforms.quality)
+            parts.push(`q_${transforms.quality}`);
+        if (transforms.format)
+            parts.push(`f_${transforms.format}`);
+        const transformation = parts.length > 0 ? parts.join(',') + '/' : '';
+        return `${baseUrl}/${resourceType}/upload/${transformation}${publicId}`;
+    }
+    return {
+        info: cloudinaryInfo,
+        async initialize(cfg) {
+            cloudName = cfg.cloudName;
+            apiKey = cfg.apiKey;
+            apiSecret = cfg.apiSecret;
+            secure = cfg.secure !== false;
+            if (!cloudName || !apiKey || !apiSecret) {
+                throw new Error('Cloudinary requires cloudName, apiKey, and apiSecret');
+            }
+        },
+        async healthCheck() {
+            const start = Date.now();
+            try {
+                const response = await fetch(`${getApiUrl()}/resources/image`, {
+                    method: 'GET',
+                    headers: {
+                        Authorization: getAuthHeader(),
+                    },
+                });
+                return {
+                    healthy: response.ok,
+                    latencyMs: Date.now() - start,
+                    message: response.ok ? 'Connected' : `HTTP ${response.status}`,
+                    checkedAt: new Date(),
+                };
+            }
+            catch (error) {
+                return {
+                    healthy: false,
+                    latencyMs: Date.now() - start,
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                    checkedAt: new Date(),
+                };
+            }
+        },
+        async dispose() {
+            // No cleanup needed
+        },
+        async upload(file, options) {
+            const resourceType = options?.resourceType || 'auto';
+            const formData = new FormData();
+            if (typeof file === 'string') {
+                // URL or base64
+                formData.append('file', file);
+            }
+            else {
+                // Buffer - convert to ArrayBuffer for Blob
+                const arrayBuffer = file.buffer.slice(file.byteOffset, file.byteOffset + file.byteLength);
+                const blob = new Blob([arrayBuffer]);
+                formData.append('file', blob);
+            }
+            if (options?.publicId) {
+                formData.append('public_id', options.publicId);
+            }
+            if (options?.folder) {
+                formData.append('folder', options.folder);
+            }
+            if (options?.tags?.length) {
+                formData.append('tags', options.tags.join(','));
+            }
+            if (options?.metadata) {
+                formData.append('context', Object.entries(options.metadata).map(([k, v]) => `${k}=${v}`).join('|'));
+            }
+            try {
+                const response = await fetch(`${getApiUrl()}/${resourceType}/upload`, {
+                    method: 'POST',
+                    headers: {
+                        Authorization: getAuthHeader(),
+                    },
+                    body: formData,
+                });
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(errorData?.error?.message || `Upload failed: HTTP ${response.status}`);
+                }
+                const data = await response.json();
+                return {
+                    id: data.public_id,
+                    publicId: data.public_id,
+                    url: data.url,
+                    secureUrl: data.secure_url,
+                    resourceType: data.resource_type,
+                    format: data.format,
+                    bytes: data.bytes,
+                    width: data.width,
+                    height: data.height,
+                    duration: data.duration,
+                    createdAt: new Date(data.created_at),
+                };
+            }
+            catch (error) {
+                throw new Error(error instanceof Error ? error.message : 'Upload failed');
+            }
+        },
+        async get(assetId) {
+            try {
+                // Try image first
+                const response = await fetch(`${getApiUrl()}/resources/image/upload/${assetId}`, {
+                    method: 'GET',
+                    headers: {
+                        Authorization: getAuthHeader(),
+                    },
+                });
+                if (!response.ok) {
+                    // Try video
+                    const videoResponse = await fetch(`${getApiUrl()}/resources/video/upload/${assetId}`, {
+                        method: 'GET',
+                        headers: {
+                            Authorization: getAuthHeader(),
+                        },
+                    });
+                    if (!videoResponse.ok) {
+                        return null;
+                    }
+                    const data = await videoResponse.json();
+                    return {
+                        id: data.public_id,
+                        publicId: data.public_id,
+                        url: data.url,
+                        secureUrl: data.secure_url,
+                        resourceType: data.resource_type,
+                        format: data.format,
+                        bytes: data.bytes,
+                        width: data.width,
+                        height: data.height,
+                        duration: data.duration,
+                        createdAt: new Date(data.created_at),
+                    };
+                }
+                const data = await response.json();
+                return {
+                    id: data.public_id,
+                    publicId: data.public_id,
+                    url: data.url,
+                    secureUrl: data.secure_url,
+                    resourceType: data.resource_type,
+                    format: data.format,
+                    bytes: data.bytes,
+                    width: data.width,
+                    height: data.height,
+                    duration: data.duration,
+                    createdAt: new Date(data.created_at),
+                };
+            }
+            catch (error) {
+                return null;
+            }
+        },
+        async delete(assetId) {
+            try {
+                // Try deleting as image first
+                let response = await fetch(`${getApiUrl()}/resources/image/upload`, {
+                    method: 'DELETE',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: getAuthHeader(),
+                    },
+                    body: JSON.stringify({ public_ids: [assetId] }),
+                });
+                if (response.ok) {
+                    const result = await response.json();
+                    return result.deleted?.[assetId] === 'deleted';
+                }
+                // Try video if image failed
+                response = await fetch(`${getApiUrl()}/resources/video/upload`, {
+                    method: 'DELETE',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: getAuthHeader(),
+                    },
+                    body: JSON.stringify({ public_ids: [assetId] }),
+                });
+                if (response.ok) {
+                    const result = await response.json();
+                    return result.deleted?.[assetId] === 'deleted';
+                }
+                return false;
+            }
+            catch (error) {
+                return false;
+            }
+        },
+        async list(options) {
+            try {
+                const resourceType = options?.resourceType || 'image';
+                const params = new URLSearchParams();
+                if (options?.limit)
+                    params.append('max_results', options.limit.toString());
+                if (options?.cursor)
+                    params.append('next_cursor', options.cursor);
+                if (options?.folder)
+                    params.append('prefix', options.folder);
+                if (options?.tags?.length) {
+                    params.append('tags', 'true');
+                }
+                const response = await fetch(`${getApiUrl()}/resources/${resourceType}?${params.toString()}`, {
+                    method: 'GET',
+                    headers: {
+                        Authorization: getAuthHeader(),
+                    },
+                });
+                if (!response.ok) {
+                    throw new Error(`List failed: HTTP ${response.status}`);
+                }
+                const data = await response.json();
+                const items = (data.resources || []).map((resource) => ({
+                    id: resource.public_id,
+                    publicId: resource.public_id,
+                    url: resource.url,
+                    secureUrl: resource.secure_url,
+                    resourceType: resource.resource_type,
+                    format: resource.format,
+                    bytes: resource.bytes,
+                    width: resource.width,
+                    height: resource.height,
+                    duration: resource.duration,
+                    createdAt: new Date(resource.created_at),
+                }));
+                return {
+                    items,
+                    hasMore: !!data.next_cursor,
+                    nextCursor: data.next_cursor,
+                };
+            }
+            catch (error) {
+                throw new Error(error instanceof Error ? error.message : 'List failed');
+            }
+        },
+        async transform(assetId, transformations) {
+            // Get asset to determine resource type
+            const asset = await this.get(assetId);
+            if (!asset) {
+                throw new Error(`Asset not found: ${assetId}`);
+            }
+            return buildTransformUrl(assetId, asset.resourceType, transformations);
+        },
+        async getUrl(assetId, options) {
+            // Get asset to determine resource type
+            const asset = await this.get(assetId);
+            if (!asset) {
+                throw new Error(`Asset not found: ${assetId}`);
+            }
+            let url = buildTransformUrl(assetId, asset.resourceType, options?.transformation);
+            // Add signed URL parameters if requested
+            if (options?.signed) {
+                // For signed URLs, we'd need to implement signature generation
+                // This is a simplified version - production would need proper signing
+                const timestamp = options.expiration
+                    ? Math.floor(options.expiration.getTime() / 1000)
+                    : Math.floor(Date.now() / 1000) + 3600; // 1 hour default
+                // Note: This would need proper signature generation in production
+                url += `?timestamp=${timestamp}`;
+            }
+            return url;
+        },
+    };
+}
+/**
+ * Cloudinary provider definition
+ */
+export const cloudinaryProvider = defineProvider(cloudinaryInfo, async (config) => createCloudinaryProvider(config));

package/src/providers/media/index.js

@@ -0,0 +1,17 @@
+/**
+ * Media Providers
+ *
+ * @packageDocumentation
+ */
+export { cloudinaryInfo, cloudinaryProvider, createCloudinaryProvider } from './cloudinary.js';
+import { cloudinaryProvider } from './cloudinary.js';
+/**
+ * Register all media providers
+ */
+export function registerMediaProviders() {
+    cloudinaryProvider.register();
+}
+/**
+ * All media providers
+ */
+export const mediaProviders = [cloudinaryProvider];

package/src/providers/messaging/index.js

@@ -0,0 +1,20 @@
+/**
+ * Messaging Providers
+ *
+ * @packageDocumentation
+ */
+export { slackInfo, slackProvider, createSlackProvider } from './slack.js';
+export { twilioSmsInfo, twilioSmsProvider, createTwilioSmsProvider } from './twilio-sms.js';
+import { slackProvider } from './slack.js';
+import { twilioSmsProvider } from './twilio-sms.js';
+/**
+ * Register all messaging providers
+ */
+export function registerMessagingProviders() {
+    slackProvider.register();
+    twilioSmsProvider.register();
+}
+/**
+ * All messaging providers
+ */
+export const messagingProviders = [slackProvider, twilioSmsProvider];