tacel-canva 1.0.0

package/canva-api.js

@@ -0,0 +1,271 @@
+/**
+ * Tacel Canva Module - Backend API Handler Factory
+ * Registers IPC handlers for Canva Connect API operations
+ * 
+ * Usage in app's main.js:
+ *   const { initCanvaApi } = require('tacel-canva/canva-api');
+ *   initCanvaApi({
+ *     clientId: 'your-client-id',
+ *     clientSecret: 'your-client-secret',
+ *     redirectUri: 'http://localhost:3000/canva/callback',
+ *     channelPrefix: 'canva'
+ *   });
+ */
+
+const { ipcMain } = require('electron');
+const https = require('https');
+const { URL } = require('url');
+
+const CANVA_API_BASE = 'https://api.canva.com/rest/v1';
+const CANVA_AUTH_URL = 'https://www.canva.com/api/oauth/authorize';
+const CANVA_TOKEN_URL = 'https://api.canva.com/rest/v1/oauth/token';
+const CANVA_REVOKE_URL = 'https://api.canva.com/rest/v1/oauth/revoke';
+const CANVA_INTROSPECT_URL = 'https://api.canva.com/rest/v1/oauth/introspect';
+
+let config = null;
+
+/**
+ * Initialize Canva API handlers
+ * @param {Object} options - Configuration options
+ * @param {string} options.clientId - Canva client ID
+ * @param {string} options.clientSecret - Canva client secret
+ * @param {string} options.redirectUri - OAuth redirect URI
+ * @param {string} options.channelPrefix - IPC channel prefix (default: 'canva')
+ */
+function initCanvaApi(options) {
+  if (!options.clientId || !options.clientSecret || !options.redirectUri) {
+    throw new Error('Canva API: clientId, clientSecret, and redirectUri are required');
+  }
+
+  config = {
+    clientId: options.clientId,
+    clientSecret: options.clientSecret,
+    redirectUri: options.redirectUri,
+    channelPrefix: options.channelPrefix || 'canva',
+  };
+
+  registerHandlers();
+}
+
+function registerHandlers() {
+  const prefix = config.channelPrefix;
+
+  // Get OAuth authorization URL
+  ipcMain.handle(`${prefix}:get-auth-url`, async (event, { codeChallenge, userId }) => {
+    const params = new URLSearchParams({
+      code_challenge: codeChallenge,
+      code_challenge_method: 'S256',
+      response_type: 'code',
+      client_id: config.clientId,
+      redirect_uri: config.redirectUri,
+      scope: 'design:meta:read design:content:read folder:read',
+      state: userId, // Pass userId as state for verification
+    });
+
+    return `${CANVA_AUTH_URL}?${params.toString()}`;
+  });
+
+  // Exchange authorization code for tokens
+  ipcMain.handle(`${prefix}:exchange-token`, async (event, { code, codeVerifier, userId }) => {
+    const body = new URLSearchParams({
+      grant_type: 'authorization_code',
+      code,
+      code_verifier: codeVerifier,
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      redirect_uri: config.redirectUri,
+    });
+
+    const tokens = await makeRequest('POST', CANVA_TOKEN_URL, {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body.toString(),
+    });
+
+    return tokens;
+  });
+
+  // Refresh access token
+  ipcMain.handle(`${prefix}:refresh-token`, async (event, { refreshToken }) => {
+    const body = new URLSearchParams({
+      grant_type: 'refresh_token',
+      refresh_token: refreshToken,
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+    });
+
+    const tokens = await makeRequest('POST', CANVA_TOKEN_URL, {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body.toString(),
+    });
+
+    return tokens;
+  });
+
+  // List user's designs
+  ipcMain.handle(`${prefix}:list-designs`, async (event, { userId, accessToken, query = '', continuation = null }) => {
+    const params = new URLSearchParams();
+    if (query) params.append('query', query);
+    if (continuation) params.append('continuation', continuation);
+
+    const url = `${CANVA_API_BASE}/designs${params.toString() ? '?' + params.toString() : ''}`;
+
+    const result = await makeRequest('GET', url, {
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+      },
+    });
+
+    return result;
+  });
+
+  // Get design details
+  ipcMain.handle(`${prefix}:get-design`, async (event, { userId, accessToken, designId }) => {
+    const url = `${CANVA_API_BASE}/designs/${designId}`;
+
+    const result = await makeRequest('GET', url, {
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+      },
+    });
+
+    return result;
+  });
+
+  // Export design
+  ipcMain.handle(`${prefix}:export-design`, async (event, { userId, accessToken, designId, format = 'png' }) => {
+    const url = `${CANVA_API_BASE}/exports`;
+
+    const body = JSON.stringify({
+      design_id: designId,
+      format: {
+        type: format,
+      },
+    });
+
+    const result = await makeRequest('POST', url, {
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body,
+    });
+
+    return result;
+  });
+
+  // Get export job status
+  ipcMain.handle(`${prefix}:get-export`, async (event, { userId, accessToken, exportId }) => {
+    const url = `${CANVA_API_BASE}/exports/${exportId}`;
+
+    const result = await makeRequest('GET', url, {
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+      },
+    });
+
+    return result;
+  });
+
+  // List folders
+  ipcMain.handle(`${prefix}:list-folders`, async (event, { userId, accessToken, continuation = null }) => {
+    const params = new URLSearchParams();
+    if (continuation) params.append('continuation', continuation);
+
+    const url = `${CANVA_API_BASE}/folders${params.toString() ? '?' + params.toString() : ''}`;
+
+    const result = await makeRequest('GET', url, {
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+      },
+    });
+
+    return result;
+  });
+
+  // Revoke token
+  ipcMain.handle(`${prefix}:revoke-token`, async (event, { accessToken }) => {
+    const body = new URLSearchParams({
+      token: accessToken,
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+    });
+
+    await makeRequest('POST', CANVA_REVOKE_URL, {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body.toString(),
+    });
+
+    return { success: true };
+  });
+}
+
+/**
+ * Make HTTPS request to Canva API
+ * @param {string} method - HTTP method
+ * @param {string} url - Full URL
+ * @param {Object} options - Request options
+ * @returns {Promise<Object>} Response data
+ */
+function makeRequest(method, url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    
+    // Merge default headers with provided headers
+    const defaultHeaders = {
+      'User-Agent': 'TacelCanva/1.0.0',
+      'Accept': 'application/json',
+    };
+    
+    const requestOptions = {
+      hostname: urlObj.hostname,
+      path: urlObj.pathname + urlObj.search,
+      method,
+      headers: { ...defaultHeaders, ...options.headers },
+    };
+
+    const req = https.request(requestOptions, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          // Log raw response for debugging
+          console.log(`[Canva API] Status: ${res.statusCode}, Response:`, data.substring(0, 500));
+          
+          const parsed = data ? JSON.parse(data) : {};
+          
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(parsed);
+          } else {
+            reject(new Error(`Canva API error ${res.statusCode}: ${parsed.error || parsed.error_description || data}`));
+          }
+        } catch (err) {
+          reject(new Error(`Failed to parse response (Status ${res.statusCode}): ${err.message}. Raw response: ${data.substring(0, 200)}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => {
+      reject(new Error(`Request failed: ${err.message}`));
+    });
+
+    if (options.body) {
+      req.write(options.body);
+    }
+
+    req.end();
+  });
+}
+
+module.exports = {
+  initCanvaApi,
+};