@canveletedotcom/sdk 2.0.0

package/dist/utils/validation.js

@@ -0,0 +1,126 @@
+/**
+ * Element validation utilities
+ */
+import { ValidationError } from '../errors';
+const VALID_ELEMENT_TYPES = [
+    'rectangle',
+    'circle',
+    'text',
+    'image',
+    'line',
+    'polygon',
+    'star',
+    'svg',
+    'bezier',
+    'container',
+    'table',
+    'qr',
+    'barcode',
+];
+/**
+ * Validate an element's basic properties
+ */
+export function validateElement(element) {
+    const errors = [];
+    // Required fields
+    if (!element.type) {
+        errors.push('Element type is required');
+    }
+    else if (!VALID_ELEMENT_TYPES.includes(element.type)) {
+        errors.push(`Invalid element type: ${element.type}. Valid types: ${VALID_ELEMENT_TYPES.join(', ')}`);
+    }
+    if (typeof element.x !== 'number') {
+        errors.push('Element x position must be a number');
+    }
+    if (typeof element.y !== 'number') {
+        errors.push('Element y position must be a number');
+    }
+    // Type-specific validation
+    if (element.type === 'text' && !element.text) {
+        errors.push('Text element requires text content');
+    }
+    if (element.type === 'image' && !element.src) {
+        errors.push('Image element requires src URL');
+    }
+    // Numeric range validation
+    if (element.opacity !== undefined && (element.opacity < 0 || element.opacity > 1)) {
+        errors.push('Opacity must be between 0 and 1');
+    }
+    if (element.fontSize !== undefined && element.fontSize <= 0) {
+        errors.push('Font size must be positive');
+    }
+    if (element.strokeWidth !== undefined && element.strokeWidth < 0) {
+        errors.push('Stroke width cannot be negative');
+    }
+    if (element.borderRadius !== undefined && element.borderRadius < 0) {
+        errors.push('Border radius cannot be negative');
+    }
+    if (errors.length > 0) {
+        throw new ValidationError(`Element validation failed: ${errors.join('; ')}`);
+    }
+}
+/**
+ * Validate canvas dimensions
+ */
+export function validateCanvasDimensions(width, height) {
+    const errors = [];
+    if (typeof width !== 'number' || width <= 0) {
+        errors.push('Width must be a positive number');
+    }
+    if (typeof height !== 'number' || height <= 0) {
+        errors.push('Height must be a positive number');
+    }
+    if (width > 10000) {
+        errors.push('Width cannot exceed 10000 pixels');
+    }
+    if (height > 10000) {
+        errors.push('Height cannot exceed 10000 pixels');
+    }
+    if (errors.length > 0) {
+        throw new ValidationError(`Canvas validation failed: ${errors.join('; ')}`);
+    }
+}
+/**
+ * Validate render options
+ */
+export function validateRenderOptions(options) {
+    const errors = [];
+    if (!options.designId && !options.templateId) {
+        errors.push('Either designId or templateId is required');
+    }
+    if (options.format && !['png', 'jpg', 'jpeg', 'pdf', 'svg'].includes(options.format)) {
+        errors.push('Invalid format. Valid formats: png, jpg, jpeg, pdf, svg');
+    }
+    if (options.quality !== undefined && (options.quality < 1 || options.quality > 100)) {
+        errors.push('Quality must be between 1 and 100');
+    }
+    if (errors.length > 0) {
+        throw new ValidationError(`Render options validation failed: ${errors.join('; ')}`);
+    }
+}
+/**
+ * Validate color format
+ */
+export function validateColor(color) {
+    // Hex color
+    if (/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8})$/.test(color)) {
+        return true;
+    }
+    // RGB/RGBA
+    if (/^rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+(,\s*[\d.]+)?\s*\)$/.test(color)) {
+        return true;
+    }
+    // HSL/HSLA
+    if (/^hsla?\(\s*\d+\s*,\s*\d+%\s*,\s*\d+%(,\s*[\d.]+)?\s*\)$/.test(color)) {
+        return true;
+    }
+    // Named colors (basic check)
+    const namedColors = [
+        'transparent', 'black', 'white', 'red', 'green', 'blue',
+        'yellow', 'orange', 'purple', 'pink', 'gray', 'grey',
+    ];
+    if (namedColors.includes(color.toLowerCase())) {
+        return true;
+    }
+    return false;
+}

package/dist/utils/webhooks.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Webhook signature verification utilities
+ */
+export interface WebhookEvent {
+    id: string;
+    type: string;
+    timestamp: string;
+    data: Record<string, any>;
+}
+export interface WebhookVerifyOptions {
+    payload: string | Buffer;
+    signature: string;
+    secret: string;
+    tolerance?: number;
+}
+/**
+ * Verify a webhook signature
+ */
+export declare function verifyWebhookSignature(options: WebhookVerifyOptions): boolean;
+/**
+ * Parse a webhook payload
+ */
+export declare function parseWebhookPayload(payload: string | Buffer): WebhookEvent;
+/**
+ * Construct a webhook event from verified payload
+ */
+export declare function constructWebhookEvent(payload: string | Buffer, signature: string, secret: string): WebhookEvent;
+/**
+ * Generate a webhook signature (for testing)
+ */
+export declare function generateWebhookSignature(payload: string, secret: string): string;

package/dist/utils/webhooks.js

@@ -0,0 +1,70 @@
+/**
+ * Webhook signature verification utilities
+ */
+import { createHmac, timingSafeEqual } from 'crypto';
+/**
+ * Verify a webhook signature
+ */
+export function verifyWebhookSignature(options) {
+    const { payload, signature, secret, tolerance = 300 } = options;
+    // Parse the signature header (format: t=timestamp,v1=signature)
+    const parts = signature.split(',');
+    const signatureParts = {};
+    for (const part of parts) {
+        const [key, value] = part.split('=');
+        if (key && value) {
+            signatureParts[key] = value;
+        }
+    }
+    const timestamp = signatureParts['t'];
+    const v1Signature = signatureParts['v1'];
+    if (!timestamp || !v1Signature) {
+        return false;
+    }
+    // Check timestamp tolerance
+    const timestampNum = parseInt(timestamp, 10);
+    const now = Math.floor(Date.now() / 1000);
+    if (Math.abs(now - timestampNum) > tolerance) {
+        return false;
+    }
+    // Compute expected signature
+    const payloadStr = typeof payload === 'string' ? payload : payload.toString('utf8');
+    const signedPayload = `${timestamp}.${payloadStr}`;
+    const expectedSignature = createHmac('sha256', secret)
+        .update(signedPayload)
+        .digest('hex');
+    // Timing-safe comparison
+    try {
+        return timingSafeEqual(Buffer.from(v1Signature), Buffer.from(expectedSignature));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse a webhook payload
+ */
+export function parseWebhookPayload(payload) {
+    const payloadStr = typeof payload === 'string' ? payload : payload.toString('utf8');
+    return JSON.parse(payloadStr);
+}
+/**
+ * Construct a webhook event from verified payload
+ */
+export function constructWebhookEvent(payload, signature, secret) {
+    if (!verifyWebhookSignature({ payload, signature, secret })) {
+        throw new Error('Invalid webhook signature');
+    }
+    return parseWebhookPayload(payload);
+}
+/**
+ * Generate a webhook signature (for testing)
+ */
+export function generateWebhookSignature(payload, secret) {
+    const timestamp = Math.floor(Date.now() / 1000);
+    const signedPayload = `${timestamp}.${payload}`;
+    const signature = createHmac('sha256', secret)
+        .update(signedPayload)
+        .digest('hex');
+    return `t=${timestamp},v1=${signature}`;
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+    "name": "@canveletedotcom/sdk",
+    "version": "2.0.0",
+    "description": "Official TypeScript SDK for the Canvelete API",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "type": "module",
+    "exports": {
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/index.d.ts"
+        },
+        "./utils": {
+            "import": "./dist/utils/index.js",
+            "types": "./dist/utils/index.d.ts"
+        }
+    },
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "test:coverage": "vitest run --coverage",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "canvelete",
+        "typescript",
+        "sdk",
+        "api",
+        "image",
+        "generation",
+        "pdf",
+        "design",
+        "automation"
+    ],
+    "author": "Canvelete",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/canvelete/canvelete-sdk.git"
+    },
+    "homepage": "https://docs.canvelete.com",
+    "devDependencies": {
+        "typescript": "^5.0.0",
+        "@types/node": "^18.0.0",
+        "vitest": "^1.0.0",
+        "@vitest/coverage-v8": "^1.0.0"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    }
+}