@hasna/connectors 1.3.43 → 1.3.45

package/connectors/uploadcare/src/api/client.ts

@@ -0,0 +1,192 @@
+import type { UploadcareConfig } from '../types';
+import { ConnectorApiError, parseApiError, UPLOADCARE_ACCEPT_VERSION } from '../types';
+
+const DEFAULT_BASE_URL = 'https://api.uploadcare.com';
+
+export interface RequestOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+  params?: Record<string, string | number | boolean | undefined>;
+  body?: Record<string, unknown> | unknown[] | string;
+  headers?: Record<string, string>;
+  retries?: number;
+  timeout?: number;
+}
+
+export function withTrailingSlash(path: string): string {
+  return path.endsWith('/') ? path : `${path}/`;
+}
+
+export class UploadcareClient {
+  private readonly publicKey: string;
+  private readonly secretKey: string;
+  private readonly baseUrl: string;
+
+  constructor(config: UploadcareConfig) {
+    if (!config.publicKey || !config.secretKey) {
+      throw new Error('Both publicKey and secretKey are required for Uploadcare API authentication');
+    }
+    this.publicKey = config.publicKey;
+    this.secretKey = config.secretKey;
+    this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+  }
+
+  private buildUrl(path: string, params?: Record<string, string | number | boolean | undefined>): string {
+    const normalizedPath = withTrailingSlash(path.startsWith('/') ? path : `/${path}`);
+    const url = new URL(`${this.baseUrl}${normalizedPath}`);
+
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+
+    return url.toString();
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  private getRetryDelay(attempt: number, baseDelay: number = 1000): number {
+    return baseDelay * Math.pow(2, attempt) + Math.random() * 1000;
+  }
+
+  private isRetryableStatus(status: number): boolean {
+    return status === 429 || (status >= 500 && status < 600);
+  }
+
+  async request<T>(path: string, options: RequestOptions = {}): Promise<T> {
+    const { method = 'GET', params, body, headers = {}, retries = 3, timeout = 30000 } = options;
+
+    const url = this.buildUrl(path, params);
+
+    const requestHeaders: Record<string, string> = {
+      Authorization: `Uploadcare.Simple ${this.publicKey}:${this.secretKey}`,
+      Accept: UPLOADCARE_ACCEPT_VERSION,
+      ...headers,
+    };
+
+    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+      requestHeaders['Content-Type'] = 'application/json';
+    }
+
+    const fetchOptions: RequestInit = {
+      method,
+      headers: requestHeaders,
+    };
+
+    if (body && ['POST', 'PUT', 'PATCH'].includes(method)) {
+      fetchOptions.body = typeof body === 'string' ? body : JSON.stringify(body);
+    }
+
+    let lastError: Error | null = null;
+    let lastStatus = 0;
+
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+        const response = await fetch(url, {
+          ...fetchOptions,
+          signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+        lastStatus = response.status;
+
+        if (response.status === 204) {
+          return {} as T;
+        }
+
+        let data: unknown;
+        const contentType = response.headers.get('content-type') || '';
+
+        if (contentType.includes('application/json')) {
+          const text = await response.text();
+          if (text) {
+            try {
+              data = JSON.parse(text);
+            } catch {
+              data = text;
+            }
+          }
+        } else {
+          data = await response.text();
+        }
+
+        if (!response.ok) {
+          if (this.isRetryableStatus(response.status) && attempt < retries) {
+            const retryAfter = response.headers.get('retry-after');
+            const delay = retryAfter
+              ? parseInt(retryAfter, 10) * 1000
+              : this.getRetryDelay(attempt);
+
+            await this.sleep(delay);
+            continue;
+          }
+
+          throw parseApiError(data, response.status);
+        }
+
+        return data as T;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+
+        if (lastError.name === 'AbortError') {
+          lastError = new Error(`Request timeout after ${timeout}ms`);
+        }
+
+        if (attempt < retries && !(err instanceof ConnectorApiError)) {
+          await this.sleep(this.getRetryDelay(attempt));
+          continue;
+        }
+
+        throw err;
+      }
+    }
+
+    throw lastError || new ConnectorApiError('Request failed', lastStatus);
+  }
+
+  async get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'GET', params });
+  }
+
+  async post<T>(
+    path: string,
+    body?: Record<string, unknown> | unknown[] | string,
+    params?: Record<string, string | number | boolean | undefined>
+  ): Promise<T> {
+    return this.request<T>(path, { method: 'POST', body: body as Record<string, unknown>, params });
+  }
+
+  async put<T>(
+    path: string,
+    body?: Record<string, unknown> | unknown[],
+    params?: Record<string, string | number | boolean | undefined>
+  ): Promise<T> {
+    return this.request<T>(path, { method: 'PUT', body: body as Record<string, unknown>, params });
+  }
+
+  async patch<T>(
+    path: string,
+    body?: Record<string, unknown>,
+    params?: Record<string, string | number | boolean | undefined>
+  ): Promise<T> {
+    return this.request<T>(path, { method: 'PATCH', body, params });
+  }
+
+  async delete<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T> {
+    return this.request<T>(path, { method: 'DELETE', params });
+  }
+
+  getCredentialPreview(): string {
+    if (this.publicKey.length > 10) {
+      return `Key: ${this.publicKey.substring(0, 6)}...`;
+    }
+    return 'Key: ***';
+  }
+}

package/connectors/uploadcare/src/api/files.ts

@@ -0,0 +1,53 @@
+import type { UploadcareClient } from './client';
+import type { UploadcareFile, UploadcareFileList } from '../types';
+
+function filePath(uuid: string): string {
+  return `/files/${encodeURIComponent(uuid)}`;
+}
+
+export class FilesApi {
+  constructor(private readonly client: UploadcareClient) {}
+
+  async list(params?: {
+    limit?: number;
+    from?: string;
+    to?: string;
+    stored?: boolean;
+    removed?: boolean;
+    ordering?: string;
+  }): Promise<UploadcareFileList> {
+    return this.client.get<UploadcareFileList>('/files', params);
+  }
+
+  async get(uuid: string): Promise<UploadcareFile> {
+    return this.client.get<UploadcareFile>(filePath(uuid));
+  }
+
+  async store(uuid: string): Promise<UploadcareFile> {
+    return this.client.put<UploadcareFile>(`${filePath(uuid)}/storage`);
+  }
+
+  async delete(uuid: string): Promise<void> {
+    await this.client.delete(`${filePath(uuid)}`);
+  }
+
+  async copyLocal(uuid: string, body: Record<string, unknown>): Promise<UploadcareFile> {
+    return this.client.post<UploadcareFile>(`${filePath(uuid)}/local_copy`, body);
+  }
+
+  async copyRemote(uuid: string, body: Record<string, unknown>): Promise<UploadcareFile> {
+    return this.client.post<UploadcareFile>(`${filePath(uuid)}/remote_copy`, body);
+  }
+
+  async getMetadata(uuid: string): Promise<Record<string, string>> {
+    return this.client.get<Record<string, string>>(`${filePath(uuid)}/metadata`);
+  }
+
+  async updateMetadata(uuid: string, metadata: Record<string, string>): Promise<Record<string, string>> {
+    return this.client.patch<Record<string, string>>(`${filePath(uuid)}/metadata`, metadata);
+  }
+
+  async deleteMetadataKey(uuid: string, key: string): Promise<void> {
+    await this.client.delete(`${filePath(uuid)}/metadata/${encodeURIComponent(key)}`);
+  }
+}

package/connectors/uploadcare/src/api/groups.ts

@@ -0,0 +1,27 @@
+import type { UploadcareClient } from './client';
+import type { UploadcareGroup, UploadcareGroupList } from '../types';
+
+function groupPath(uuid: string): string {
+  return `/groups/${encodeURIComponent(uuid)}`;
+}
+
+export class GroupsApi {
+  constructor(private readonly client: UploadcareClient) {}
+
+  async list(params?: {
+    limit?: number;
+    from?: string;
+    to?: string;
+    ordering?: string;
+  }): Promise<UploadcareGroupList> {
+    return this.client.get<UploadcareGroupList>('/groups', params);
+  }
+
+  async get(uuid: string): Promise<UploadcareGroup> {
+    return this.client.get<UploadcareGroup>(groupPath(uuid));
+  }
+
+  async delete(uuid: string): Promise<void> {
+    await this.client.delete(groupPath(uuid));
+  }
+}

package/connectors/uploadcare/src/api/index.ts

@@ -0,0 +1,83 @@
+import type { UploadcareConfig } from '../types';
+import { UploadcareClient } from './client';
+import { FilesApi } from './files';
+import { GroupsApi } from './groups';
+import { WebhooksApi } from './webhooks';
+import { ProjectApi } from './project';
+import {
+  getPublicKey,
+  getSecretKey,
+  getBaseUrl,
+} from '../utils/config';
+
+export class Uploadcare {
+  private readonly client: UploadcareClient;
+
+  public readonly files: FilesApi;
+  public readonly groups: GroupsApi;
+  public readonly webhooks: WebhooksApi;
+  public readonly project: ProjectApi;
+
+  constructor(config: UploadcareConfig) {
+    this.client = new UploadcareClient(config);
+    this.files = new FilesApi(this.client);
+    this.groups = new GroupsApi(this.client);
+    this.webhooks = new WebhooksApi(this.client);
+    this.project = new ProjectApi(this.client);
+  }
+
+  static create(): Uploadcare {
+    const publicKey = getPublicKey();
+    const secretKey = getSecretKey();
+    const baseUrl = getBaseUrl();
+
+    if (!publicKey || !secretKey) {
+      throw new Error(
+        'Uploadcare credentials not configured. ' +
+        'Set UPLOADCARE_PUBLIC_KEY and UPLOADCARE_SECRET_KEY environment variables, ' +
+        'or run "connect-uploadcare config set-credentials <publicKey> <secretKey>"'
+      );
+    }
+
+    return new Uploadcare({ publicKey, secretKey, baseUrl });
+  }
+
+  static fromEnv(): Uploadcare {
+    const publicKey = process.env.UPLOADCARE_PUBLIC_KEY;
+    const secretKey = process.env.UPLOADCARE_SECRET_KEY;
+    const baseUrl = process.env.UPLOADCARE_BASE_URL;
+
+    if (!publicKey || !secretKey) {
+      throw new Error(
+        'UPLOADCARE_PUBLIC_KEY and UPLOADCARE_SECRET_KEY environment variables are required'
+      );
+    }
+
+    return new Uploadcare({ publicKey, secretKey, baseUrl });
+  }
+
+  getCredentialPreview(): string {
+    return this.client.getCredentialPreview();
+  }
+
+  getClient(): UploadcareClient {
+    return this.client;
+  }
+
+  async rawRequest(
+    path: string,
+    options: {
+      method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+      params?: Record<string, string | number | boolean | undefined>;
+      body?: Record<string, unknown> | unknown[] | string;
+    } = {}
+  ): Promise<unknown> {
+    return this.client.request(path, options);
+  }
+}
+
+export { UploadcareClient } from './client';
+export { FilesApi } from './files';
+export { GroupsApi } from './groups';
+export { WebhooksApi } from './webhooks';
+export { ProjectApi } from './project';

package/connectors/uploadcare/src/api/project.ts

@@ -0,0 +1,10 @@
+import type { UploadcareClient } from './client';
+import type { UploadcareProject } from '../types';
+
+export class ProjectApi {
+  constructor(private readonly client: UploadcareClient) {}
+
+  async get(): Promise<UploadcareProject> {
+    return this.client.get<UploadcareProject>('/project');
+  }
+}

package/connectors/uploadcare/src/api/webhooks.ts

@@ -0,0 +1,31 @@
+import type { UploadcareClient } from './client';
+import type { UploadcareWebhook, UploadcareWebhookList } from '../types';
+
+function webhookPath(id: string): string {
+  return `/webhooks/${encodeURIComponent(id)}`;
+}
+
+export class WebhooksApi {
+  constructor(private readonly client: UploadcareClient) {}
+
+  async list(params?: {
+    limit?: number;
+    from?: string;
+    to?: string;
+    ordering?: string;
+  }): Promise<UploadcareWebhookList> {
+    return this.client.get<UploadcareWebhookList>('/webhooks', params);
+  }
+
+  async create(body: Record<string, unknown>): Promise<UploadcareWebhook> {
+    return this.client.post<UploadcareWebhook>('/webhooks', body);
+  }
+
+  async update(id: string, body: Record<string, unknown>): Promise<UploadcareWebhook> {
+    return this.client.put<UploadcareWebhook>(webhookPath(id), body);
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.client.delete(webhookPath(id));
+  }
+}