@canveletedotcom/sdk 2.0.0

package/dist/resources/templates.js

@@ -0,0 +1,76 @@
+/**
+ * Templates resource for managing design templates
+ */
+export class TemplatesResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * List available templates
+     */
+    async list(options = {}) {
+        const params = {
+            page: String(options.page || 1),
+            limit: String(options.limit || 20),
+        };
+        if (options.myOnly)
+            params.myOnly = 'true';
+        if (options.search)
+            params.search = options.search;
+        if (options.category)
+            params.category = options.category;
+        return await this.client.request('GET', '/api/automation/templates', { params });
+    }
+    /**
+     * Iterate through all templates with automatic pagination
+     */
+    async *iterateAll(options = {}) {
+        let page = 1;
+        const limit = options.limit || 50;
+        while (true) {
+            const response = await this.list({ ...options, page, limit });
+            const templates = response.data || [];
+            if (templates.length === 0)
+                break;
+            for (const template of templates) {
+                yield template;
+            }
+            if (page >= (response.pagination?.totalPages || 1))
+                break;
+            page++;
+        }
+    }
+    /**
+     * Get a specific template by ID
+     */
+    async get(id) {
+        return await this.client.request('GET', `/api/automation/designs/${id}`);
+    }
+    /**
+     * Apply a template to a design
+     */
+    async apply(options) {
+        const payload = {
+            templateId: options.templateId,
+        };
+        if (options.dynamicData) {
+            payload.dynamicData = options.dynamicData;
+        }
+        return await this.client.request('POST', `/api/automation/designs/${options.designId}/apply-template`, { json: payload });
+    }
+    /**
+     * Create a template from an existing design
+     */
+    async create(options) {
+        const payload = {
+            name: options.name,
+        };
+        if (options.description) {
+            payload.description = options.description;
+        }
+        if (options.category) {
+            payload.category = options.category;
+        }
+        return await this.client.request('POST', `/api/automation/designs/${options.designId}/save-as-template`, { json: payload });
+    }
+}

package/dist/resources/usage.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Usage tracking resource for monitoring API usage and credits
+ */
+import type { CanveleteClient } from '../client';
+import type { PaginatedResponse } from '../types';
+export interface UsageStats {
+    creditsUsed: number;
+    creditLimit: number;
+    creditsRemaining: number;
+    apiCalls: number;
+    apiCallLimit: number;
+    renders: number;
+    storageUsed: number;
+}
+export interface UsageEvent {
+    type: string;
+    creditsUsed: number;
+    timestamp: string;
+    details?: Record<string, any>;
+}
+export interface ApiStats {
+    endpoints: Record<string, number>;
+    totalCalls: number;
+    period: string;
+}
+export interface Activity {
+    action: string;
+    timestamp: string;
+    details?: Record<string, any>;
+}
+export interface Analytics {
+    totalRenders: number;
+    averagePerDay: number;
+    peakDay: string;
+    trend: 'increasing' | 'decreasing' | 'stable';
+    breakdown?: Record<string, number>;
+}
+export interface UsageHistoryOptions {
+    page?: number;
+    limit?: number;
+    startDate?: Date;
+    endDate?: Date;
+}
+export declare class UsageResource {
+    private client;
+    constructor(client: CanveleteClient);
+    /**
+     * Get current usage statistics
+     */
+    getStats(): Promise<{
+        data: UsageStats;
+    }>;
+    /**
+     * Get usage history
+     */
+    getHistory(options?: UsageHistoryOptions): Promise<PaginatedResponse<UsageEvent>>;
+    /**
+     * Get API usage statistics by endpoint
+     */
+    getApiStats(): Promise<{
+        data: ApiStats;
+    }>;
+    /**
+     * Get recent activities
+     */
+    getActivities(options?: {
+        page?: number;
+        limit?: number;
+    }): Promise<PaginatedResponse<Activity>>;
+    /**
+     * Get usage analytics
+     */
+    getAnalytics(period?: 'day' | 'week' | 'month' | 'year'): Promise<{
+        data: Analytics;
+    }>;
+}

package/dist/resources/usage.js

@@ -0,0 +1,52 @@
+/**
+ * Usage tracking resource for monitoring API usage and credits
+ */
+export class UsageResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get current usage statistics
+     */
+    async getStats() {
+        return await this.client.request('GET', '/api/v1/usage/stats');
+    }
+    /**
+     * Get usage history
+     */
+    async getHistory(options = {}) {
+        const params = {
+            page: String(options.page || 1),
+            limit: String(options.limit || 20),
+        };
+        if (options.startDate) {
+            params.startDate = options.startDate.toISOString();
+        }
+        if (options.endDate) {
+            params.endDate = options.endDate.toISOString();
+        }
+        return await this.client.request('GET', '/api/v1/usage/history', { params });
+    }
+    /**
+     * Get API usage statistics by endpoint
+     */
+    async getApiStats() {
+        return await this.client.request('GET', '/api/v1/usage/api-stats');
+    }
+    /**
+     * Get recent activities
+     */
+    async getActivities(options = {}) {
+        const params = {
+            page: String(options.page || 1),
+            limit: String(options.limit || 20),
+        };
+        return await this.client.request('GET', '/api/usage/activities', { params });
+    }
+    /**
+     * Get usage analytics
+     */
+    async getAnalytics(period = 'month') {
+        return await this.client.request('GET', '/api/usage/analytics', { params: { period } });
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,197 @@
+/**
+ * Type definitions for Canvelete API
+ */
+export interface ElementBase {
+    id?: string;
+    type: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    rotation?: number;
+    opacity?: number;
+    visible?: boolean;
+    locked?: boolean;
+    name?: string;
+    groupId?: string;
+}
+export interface RectangleElement extends ElementBase {
+    type: 'rectangle';
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    borderRadius?: number;
+    borderRadiusTopLeft?: number;
+    borderRadiusTopRight?: number;
+    borderRadiusBottomLeft?: number;
+    borderRadiusBottomRight?: number;
+    boxShadow?: string;
+}
+export interface CircleElement extends ElementBase {
+    type: 'circle';
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+export interface TextElement extends ElementBase {
+    type: 'text';
+    text: string;
+    fontSize?: number;
+    fontFamily?: string;
+    fontWeight?: string;
+    fontStyle?: 'normal' | 'italic' | 'oblique';
+    fill?: string;
+    color?: string;
+    textAlign?: 'left' | 'center' | 'right' | 'justify';
+    textDecoration?: 'none' | 'underline' | 'line-through' | 'overline';
+    textTransform?: 'none' | 'uppercase' | 'lowercase' | 'capitalize';
+    lineHeight?: number;
+    letterSpacing?: number;
+    textStrokeColor?: string;
+    textStrokeWidth?: number;
+    textShadowColor?: string;
+    textShadowX?: number;
+    textShadowY?: number;
+    textShadowBlur?: number;
+    isDynamic?: boolean;
+}
+export interface ImageElement extends ElementBase {
+    type: 'image';
+    src: string;
+    objectFit?: 'fill' | 'contain' | 'cover' | 'none' | 'scale-down';
+    objectPosition?: string;
+    brightness?: number;
+    contrast?: number;
+    saturate?: number;
+    hueRotate?: number;
+    blur?: number;
+}
+export interface LineElement extends ElementBase {
+    type: 'line';
+    linePoints?: Array<{
+        x: number;
+        y: number;
+    }>;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: 'butt' | 'round' | 'square';
+    lineDash?: string;
+}
+export interface PolygonElement extends ElementBase {
+    type: 'polygon';
+    polygonPoints?: Array<{
+        x: number;
+        y: number;
+    }>;
+    polygonSides?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    svgPath?: string;
+    svgViewBox?: string;
+}
+export interface StarElement extends ElementBase {
+    type: 'star';
+    starPoints?: number;
+    starInnerRadius?: number;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+}
+export interface SvgElement extends ElementBase {
+    type: 'svg';
+    src?: string;
+    svgPath?: string;
+    svgViewBox?: string;
+    fill?: string;
+    stroke?: string;
+}
+export interface QrElement extends ElementBase {
+    type: 'qr';
+    qrValue: string;
+    qrColor?: string;
+    qrBgColor?: string;
+    qrErrorLevel?: 'L' | 'M' | 'Q' | 'H';
+    qrMargin?: number;
+}
+export interface BarcodeElement extends ElementBase {
+    type: 'barcode';
+    barcodeValue: string;
+    barcodeFormat?: 'CODE128' | 'CODE39' | 'EAN13' | 'EAN8' | 'UPC' | 'UPCE' | 'ITF14' | 'MSI' | 'pharmacode' | 'codabar';
+    barcodeLineColor?: string;
+    barcodeBackground?: string;
+    barcodeShowText?: boolean;
+    barcodeFontSize?: number;
+    barcodeTextAlign?: 'left' | 'center' | 'right';
+    barcodeTextMargin?: number;
+}
+export interface TableElement extends ElementBase {
+    type: 'table';
+    tableRows?: number;
+    tableColumns?: number;
+    tableCellData?: Array<Record<string, any>>;
+    tableHeaderData?: Array<Record<string, any>>;
+    tableHasHeader?: boolean;
+    tableHasVerticalHeader?: boolean;
+    tableBorderWidth?: number;
+    tableBorderColor?: string;
+    tableCellPadding?: number;
+    tableHeaderBackground?: string;
+    tableHeaderTextColor?: string;
+    tableAlternateRowColor?: string;
+    tableCellTextColor?: string;
+    tableCellFontSize?: number;
+    tableCellAlignment?: 'left' | 'center' | 'right';
+    tableHeaderAlignment?: 'left' | 'center' | 'right';
+    tableColumnWidths?: number[];
+    tableRowHeights?: number[];
+}
+export type CanvasElement = RectangleElement | CircleElement | TextElement | ImageElement | LineElement | PolygonElement | StarElement | SvgElement | QrElement | BarcodeElement | TableElement | ElementBase;
+export interface CanvasData {
+    elements: CanvasElement[];
+    background?: string;
+    [key: string]: any;
+}
+export interface Design {
+    id: string;
+    name: string;
+    description?: string;
+    canvasData: CanvasData;
+    width: number;
+    height: number;
+    status: 'DRAFT' | 'PUBLISHED' | 'ARCHIVED';
+    visibility: 'PRIVATE' | 'PUBLIC' | 'TEAM';
+    isTemplate: boolean;
+    thumbnailUrl?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Template extends Design {
+    isTemplate: true;
+    dynamicFields?: string[];
+    category?: string;
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
+}
+export interface APIKey {
+    id: string;
+    name: string;
+    keyPrefix: string;
+    status: 'ACTIVE' | 'REVOKED';
+    scopes: string[];
+    createdAt: string;
+    lastUsedAt?: string;
+    expiresAt?: string;
+}
+export interface ClientOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+}

package/dist/types/index.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for Canvelete API
+ */
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Utility exports
+ */
+export { withRetry, retryOnRateLimit, createRetryWrapper } from './retry';
+export type { RetryConfig } from './retry';
+export { verifyWebhookSignature, parseWebhookPayload, constructWebhookEvent, generateWebhookSignature, } from './webhooks';
+export type { WebhookEvent, WebhookVerifyOptions } from './webhooks';
+export { validateElement, validateCanvasDimensions, validateRenderOptions, validateColor, } from './validation';
+export type { ElementBase, RectangleElement, CircleElement, TextElement, ImageElement, LineElement, CanvasElement, } from './validation';

package/dist/utils/index.js

@@ -0,0 +1,6 @@
+/**
+ * Utility exports
+ */
+export { withRetry, retryOnRateLimit, createRetryWrapper } from './retry';
+export { verifyWebhookSignature, parseWebhookPayload, constructWebhookEvent, generateWebhookSignature, } from './webhooks';
+export { validateElement, validateCanvasDimensions, validateRenderOptions, validateColor, } from './validation';

package/dist/utils/retry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Retry logic with exponential backoff
+ */
+export interface RetryConfig {
+    maxAttempts: number;
+    backoffFactor: number;
+    initialDelay: number;
+    maxDelay: number;
+    retryOn: Array<new (...args: any[]) => Error>;
+}
+/**
+ * Execute a function with retry logic and exponential backoff
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, config?: Partial<RetryConfig>): Promise<T>;
+/**
+ * Create a retry wrapper for rate limit errors
+ */
+export declare function retryOnRateLimit<T>(fn: () => Promise<T>): Promise<T>;
+/**
+ * Decorator-style retry wrapper
+ */
+export declare function createRetryWrapper(config?: Partial<RetryConfig>): <T>(fn: () => Promise<T>) => Promise<T>;

package/dist/utils/retry.js

@@ -0,0 +1,70 @@
+/**
+ * Retry logic with exponential backoff
+ */
+import { RateLimitError, ServerError, CanveleteError } from '../errors';
+const defaultConfig = {
+    maxAttempts: 3,
+    backoffFactor: 2.0,
+    initialDelay: 1000,
+    maxDelay: 60000,
+    retryOn: [RateLimitError, ServerError],
+};
+/**
+ * Sleep for a specified duration
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Execute a function with retry logic and exponential backoff
+ */
+export async function withRetry(fn, config = {}) {
+    const cfg = { ...defaultConfig, ...config };
+    let attempt = 0;
+    let delay = cfg.initialDelay;
+    while (attempt < cfg.maxAttempts) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            attempt++;
+            // Check if we should retry this error
+            const shouldRetry = cfg.retryOn.some(ErrorClass => error instanceof ErrorClass);
+            if (!shouldRetry || attempt >= cfg.maxAttempts) {
+                throw error;
+            }
+            // Check for rate limit with retry-after header
+            if (error instanceof RateLimitError && error.retryAfter) {
+                delay = error.retryAfter * 1000;
+                console.warn(`Rate limited. Retrying after ${delay}ms (attempt ${attempt}/${cfg.maxAttempts})`);
+            }
+            else {
+                console.warn(`Attempt ${attempt}/${cfg.maxAttempts} failed: ${error.message}. ` +
+                    `Retrying in ${delay}ms...`);
+            }
+            await sleep(delay);
+            // Exponential backoff
+            delay = Math.min(delay * cfg.backoffFactor, cfg.maxDelay);
+        }
+    }
+    // This should never be reached, but TypeScript needs it
+    throw new CanveleteError('Max retry attempts reached');
+}
+/**
+ * Create a retry wrapper for rate limit errors
+ */
+export function retryOnRateLimit(fn) {
+    return withRetry(fn, {
+        maxAttempts: 5,
+        backoffFactor: 2,
+        retryOn: [RateLimitError, ServerError],
+    });
+}
+/**
+ * Decorator-style retry wrapper
+ */
+export function createRetryWrapper(config = {}) {
+    return function (fn) {
+        return withRetry(fn, config);
+    };
+}

package/dist/utils/validation.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Element validation utilities
+ */
+export interface ElementBase {
+    type: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+}
+export interface RectangleElement extends ElementBase {
+    type: 'rectangle';
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    borderRadius?: number;
+    opacity?: number;
+}
+export interface CircleElement extends ElementBase {
+    type: 'circle';
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    opacity?: number;
+}
+export interface TextElement extends ElementBase {
+    type: 'text';
+    text: string;
+    fontSize?: number;
+    fontFamily?: string;
+    fontWeight?: string;
+    fontStyle?: string;
+    fill?: string;
+    textAlign?: 'left' | 'center' | 'right' | 'justify';
+    lineHeight?: number;
+}
+export interface ImageElement extends ElementBase {
+    type: 'image';
+    src: string;
+    objectFit?: 'fill' | 'contain' | 'cover' | 'none' | 'scale-down';
+    opacity?: number;
+}
+export interface LineElement extends ElementBase {
+    type: 'line';
+    linePoints?: Array<{
+        x: number;
+        y: number;
+    }>;
+    stroke?: string;
+    strokeWidth?: number;
+    lineCap?: 'butt' | 'round' | 'square';
+}
+export type CanvasElement = RectangleElement | CircleElement | TextElement | ImageElement | LineElement | ElementBase;
+/**
+ * Validate an element's basic properties
+ */
+export declare function validateElement(element: Record<string, any>): void;
+/**
+ * Validate canvas dimensions
+ */
+export declare function validateCanvasDimensions(width: number, height: number): void;
+/**
+ * Validate render options
+ */
+export declare function validateRenderOptions(options: Record<string, any>): void;
+/**
+ * Validate color format
+ */
+export declare function validateColor(color: string): boolean;