digital-tools 2.0.2 → 2.1.1

package/src/providers/ecommerce/shopify.js

@@ -0,0 +1,378 @@
+/**
+ * Shopify E-commerce Provider
+ *
+ * Concrete implementation of EcommerceProvider using Shopify Admin REST API.
+ *
+ * @packageDocumentation
+ */
+import { defineProvider } from '../registry.js';
+const API_VERSION = '2023-10';
+/**
+ * Shopify provider info
+ */
+export const shopifyInfo = {
+    id: 'ecommerce.shopify',
+    name: 'Shopify',
+    description: 'Shopify e-commerce platform',
+    category: 'ecommerce',
+    website: 'https://www.shopify.com',
+    docsUrl: 'https://shopify.dev/docs/api/admin-rest',
+    requiredConfig: ['shopDomain', 'accessToken'],
+    optionalConfig: [],
+};
+/**
+ * Create Shopify e-commerce provider
+ */
+export function createShopifyProvider(config) {
+    let shopDomain;
+    let accessToken;
+    let baseUrl;
+    function getHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            'X-Shopify-Access-Token': accessToken,
+        };
+    }
+    async function makeRequest(endpoint, method = 'GET', body) {
+        const response = await fetch(`${baseUrl}${endpoint}`, {
+            method,
+            headers: getHeaders(),
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`Shopify API error: ${response.status} - ${errorData?.errors || response.statusText}`);
+        }
+        return response.json();
+    }
+    return {
+        info: shopifyInfo,
+        async initialize(cfg) {
+            shopDomain = cfg.shopDomain;
+            accessToken = cfg.accessToken;
+            if (!shopDomain) {
+                throw new Error('Shopify shop domain is required');
+            }
+            if (!accessToken) {
+                throw new Error('Shopify access token is required');
+            }
+            // Ensure domain has proper format
+            const domain = shopDomain.includes('.myshopify.com')
+                ? shopDomain
+                : `${shopDomain}.myshopify.com`;
+            baseUrl = `https://${domain}/admin/api/${API_VERSION}`;
+        },
+        async healthCheck() {
+            const start = Date.now();
+            try {
+                await makeRequest('/shop.json', 'GET');
+                return {
+                    healthy: true,
+                    latencyMs: Date.now() - start,
+                    message: 'Connected',
+                    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 createProduct(product) {
+            const shopifyProduct = {
+                title: product.title,
+                body_html: product.description,
+                vendor: 'Default',
+                product_type: '',
+                tags: product.tags?.join(', ') || '',
+                status: product.status || 'active',
+            };
+            // Add variants
+            if (product.variants && product.variants.length > 0) {
+                shopifyProduct.variants = product.variants.map((v) => ({
+                    title: v.title,
+                    price: v.price.toString(),
+                    sku: v.sku,
+                    inventory_quantity: v.inventory || 0,
+                }));
+            }
+            else {
+                // Single variant
+                shopifyProduct.variants = [
+                    {
+                        title: 'Default Title',
+                        price: product.price.toString(),
+                        sku: product.sku,
+                        inventory_quantity: product.inventory || 0,
+                    },
+                ];
+            }
+            // Add images
+            if (product.images && product.images.length > 0) {
+                shopifyProduct.images = product.images.map((url) => ({ src: url }));
+            }
+            const response = await makeRequest('/products.json', 'POST', {
+                product: shopifyProduct,
+            });
+            return mapShopifyProduct(response.product);
+        },
+        async getProduct(productId) {
+            try {
+                const response = await makeRequest(`/products/${productId}.json`, 'GET');
+                return mapShopifyProduct(response.product);
+            }
+            catch (error) {
+                return null;
+            }
+        },
+        async updateProduct(productId, updates) {
+            const shopifyUpdates = {};
+            if (updates.title)
+                shopifyUpdates.title = updates.title;
+            if (updates.description)
+                shopifyUpdates.body_html = updates.description;
+            if (updates.tags)
+                shopifyUpdates.tags = updates.tags.join(', ');
+            if (updates.status)
+                shopifyUpdates.status = updates.status;
+            // Handle images update
+            if (updates.images) {
+                shopifyUpdates.images = updates.images.map((url) => ({ src: url }));
+            }
+            const response = await makeRequest(`/products/${productId}.json`, 'PUT', {
+                product: shopifyUpdates,
+            });
+            return mapShopifyProduct(response.product);
+        },
+        async deleteProduct(productId) {
+            try {
+                await makeRequest(`/products/${productId}.json`, 'DELETE');
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        },
+        async listProducts(options) {
+            const params = new URLSearchParams();
+            if (options?.limit)
+                params.append('limit', options.limit.toString());
+            if (options?.status)
+                params.append('status', options.status);
+            if (options?.vendor)
+                params.append('vendor', options.vendor);
+            if (options?.cursor)
+                params.append('page_info', options.cursor);
+            const queryString = params.toString();
+            const endpoint = `/products.json${queryString ? `?${queryString}` : ''}`;
+            const response = await makeRequest(endpoint, 'GET');
+            return {
+                items: response.products.map(mapShopifyProduct),
+                hasMore: response.products.length === (options?.limit || 50),
+                total: undefined, // Shopify doesn't provide total count in products endpoint
+            };
+        },
+        async getOrder(orderId) {
+            try {
+                const response = await makeRequest(`/orders/${orderId}.json`, 'GET');
+                return mapShopifyOrder(response.order);
+            }
+            catch (error) {
+                return null;
+            }
+        },
+        async listOrders(options) {
+            const params = new URLSearchParams();
+            if (options?.limit)
+                params.append('limit', options.limit.toString());
+            if (options?.status)
+                params.append('status', options.status);
+            if (options?.financialStatus)
+                params.append('financial_status', options.financialStatus);
+            if (options?.fulfillmentStatus)
+                params.append('fulfillment_status', options.fulfillmentStatus);
+            if (options?.customerId)
+                params.append('customer_id', options.customerId);
+            if (options?.since)
+                params.append('created_at_min', options.since.toISOString());
+            if (options?.until)
+                params.append('created_at_max', options.until.toISOString());
+            if (options?.cursor)
+                params.append('page_info', options.cursor);
+            const queryString = params.toString();
+            const endpoint = `/orders.json${queryString ? `?${queryString}` : ''}`;
+            const response = await makeRequest(endpoint, 'GET');
+            return {
+                items: response.orders.map(mapShopifyOrder),
+                hasMore: response.orders.length === (options?.limit || 50),
+                total: undefined,
+            };
+        },
+        async updateOrderStatus(orderId, status) {
+            const response = await makeRequest(`/orders/${orderId}.json`, 'PUT', {
+                order: {
+                    id: orderId,
+                    tags: status,
+                },
+            });
+            return mapShopifyOrder(response.order);
+        },
+        async getEcommerceCustomer(customerId) {
+            try {
+                const response = await makeRequest(`/customers/${customerId}.json`, 'GET');
+                return mapShopifyCustomer(response.customer);
+            }
+            catch (error) {
+                return null;
+            }
+        },
+        async listEcommerceCustomers(options) {
+            const params = new URLSearchParams();
+            if (options?.limit)
+                params.append('limit', options.limit.toString());
+            if (options?.cursor)
+                params.append('page_info', options.cursor);
+            const queryString = params.toString();
+            const endpoint = `/customers.json${queryString ? `?${queryString}` : ''}`;
+            const response = await makeRequest(endpoint, 'GET');
+            return {
+                items: response.customers.map(mapShopifyCustomer),
+                hasMore: response.customers.length === (options?.limit || 50),
+                total: undefined,
+            };
+        },
+        async updateInventory(productId, variantId, quantity) {
+            try {
+                // First get the inventory item ID from the variant
+                const variantResponse = await makeRequest(`/variants/${variantId}.json`, 'GET');
+                const inventoryItemId = variantResponse.variant.inventory_item_id;
+                // Get inventory levels
+                const levelsResponse = await makeRequest(`/inventory_levels.json?inventory_item_ids=${inventoryItemId}`, 'GET');
+                if (levelsResponse.inventory_levels.length === 0) {
+                    throw new Error('No inventory levels found for this variant');
+                }
+                const locationId = levelsResponse.inventory_levels[0].location_id;
+                // Set the inventory level
+                await makeRequest('/inventory_levels/set.json', 'POST', {
+                    location_id: locationId,
+                    inventory_item_id: inventoryItemId,
+                    available: quantity,
+                });
+                return true;
+            }
+            catch (error) {
+                return false;
+            }
+        },
+    };
+}
+/**
+ * Map Shopify product to our format
+ */
+function mapShopifyProduct(product) {
+    const firstVariant = product.variants?.[0];
+    return {
+        id: product.id.toString(),
+        title: product.title,
+        description: product.body_html,
+        price: parseFloat(firstVariant?.price || '0'),
+        compareAtPrice: firstVariant?.compare_at_price
+            ? parseFloat(firstVariant.compare_at_price)
+            : undefined,
+        sku: firstVariant?.sku,
+        inventory: firstVariant?.inventory_quantity,
+        images: product.images?.map((img) => img.src) || [],
+        variants: product.variants?.map((v) => ({
+            id: v.id.toString(),
+            title: v.title,
+            price: parseFloat(v.price),
+            sku: v.sku,
+            inventory: v.inventory_quantity,
+        })) || [],
+        tags: product.tags ? product.tags.split(', ') : [],
+        status: product.status,
+        url: product.admin_graphql_api_id,
+        createdAt: new Date(product.created_at),
+        updatedAt: new Date(product.updated_at),
+    };
+}
+/**
+ * Map Shopify order to our format
+ */
+function mapShopifyOrder(order) {
+    return {
+        id: order.id.toString(),
+        orderNumber: order.name || order.order_number?.toString(),
+        status: order.cancelled_at ? 'cancelled' : order.closed_at ? 'closed' : 'open',
+        financialStatus: order.financial_status,
+        fulfillmentStatus: order.fulfillment_status || 'unfulfilled',
+        customerId: order.customer?.id?.toString(),
+        email: order.email || order.customer?.email || '',
+        lineItems: order.line_items?.map((item) => ({
+            productId: item.product_id?.toString() || '',
+            variantId: item.variant_id?.toString(),
+            title: item.title,
+            quantity: item.quantity,
+            price: parseFloat(item.price),
+        })) || [],
+        subtotal: parseFloat(order.subtotal_price || '0'),
+        tax: parseFloat(order.total_tax || '0'),
+        shipping: parseFloat(order.total_shipping_price_set?.shop_money?.amount || '0'),
+        total: parseFloat(order.total_price || '0'),
+        currency: order.currency,
+        shippingAddress: order.shipping_address
+            ? {
+                firstName: order.shipping_address.first_name,
+                lastName: order.shipping_address.last_name,
+                address1: order.shipping_address.address1,
+                address2: order.shipping_address.address2,
+                city: order.shipping_address.city,
+                province: order.shipping_address.province,
+                postalCode: order.shipping_address.zip,
+                country: order.shipping_address.country,
+                phone: order.shipping_address.phone,
+            }
+            : undefined,
+        billingAddress: order.billing_address
+            ? {
+                firstName: order.billing_address.first_name,
+                lastName: order.billing_address.last_name,
+                address1: order.billing_address.address1,
+                address2: order.billing_address.address2,
+                city: order.billing_address.city,
+                province: order.billing_address.province,
+                postalCode: order.billing_address.zip,
+                country: order.billing_address.country,
+                phone: order.billing_address.phone,
+            }
+            : undefined,
+        createdAt: new Date(order.created_at),
+        updatedAt: new Date(order.updated_at),
+    };
+}
+/**
+ * Map Shopify customer to our format
+ */
+function mapShopifyCustomer(customer) {
+    return {
+        id: customer.id.toString(),
+        email: customer.email,
+        firstName: customer.first_name,
+        lastName: customer.last_name,
+        phone: customer.phone,
+        ordersCount: customer.orders_count || 0,
+        totalSpent: parseFloat(customer.total_spent || '0'),
+        createdAt: new Date(customer.created_at),
+    };
+}
+/**
+ * Shopify provider definition
+ */
+export const shopifyProvider = defineProvider(shopifyInfo, async (config) => createShopifyProvider(config));

package/src/providers/email/index.js

@@ -0,0 +1,20 @@
+/**
+ * Email Providers
+ *
+ * @packageDocumentation
+ */
+export { sendgridInfo, sendgridProvider, createSendGridProvider } from './sendgrid.js';
+export { resendInfo, resendProvider, createResendProvider } from './resend.js';
+import { sendgridProvider } from './sendgrid.js';
+import { resendProvider } from './resend.js';
+/**
+ * Register all email providers
+ */
+export function registerEmailProviders() {
+    sendgridProvider.register();
+    resendProvider.register();
+}
+/**
+ * All email providers
+ */
+export const emailProviders = [sendgridProvider, resendProvider];

package/src/providers/email/resend.js

@@ -0,0 +1,258 @@
+/**
+ * Resend Email Provider
+ *
+ * Concrete implementation of EmailProvider using Resend API.
+ *
+ * @packageDocumentation
+ */
+import { defineProvider } from '../registry.js';
+const RESEND_API_URL = 'https://api.resend.com';
+/**
+ * Resend provider info
+ */
+export const resendInfo = {
+    id: 'email.resend',
+    name: 'Resend',
+    description: 'Modern email API for developers',
+    category: 'email',
+    website: 'https://resend.com',
+    docsUrl: 'https://resend.com/docs',
+    requiredConfig: ['apiKey'],
+    optionalConfig: ['defaultFrom'],
+};
+/**
+ * Create Resend email provider
+ */
+export function createResendProvider(config) {
+    let apiKey;
+    let defaultFrom;
+    return {
+        info: resendInfo,
+        async initialize(cfg) {
+            apiKey = cfg.apiKey;
+            defaultFrom = cfg.defaultFrom;
+            if (!apiKey) {
+                throw new Error('Resend API key is required');
+            }
+        },
+        async healthCheck() {
+            const start = Date.now();
+            try {
+                const response = await fetch(`${RESEND_API_URL}/domains`, {
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                });
+                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 send(options) {
+            const from = options.from || defaultFrom;
+            if (!from) {
+                return {
+                    success: false,
+                    error: { code: 'MISSING_FROM', message: 'From address is required' },
+                };
+            }
+            const body = {
+                from,
+                to: options.to,
+                subject: options.subject,
+                ...(options.cc && { cc: options.cc }),
+                ...(options.bcc && { bcc: options.bcc }),
+                ...(options.replyTo && { reply_to: options.replyTo }),
+                ...(options.text && { text: options.text }),
+                ...(options.html && { html: options.html }),
+                ...(options.headers && { headers: options.headers }),
+                ...(options.tags && { tags: options.tags.map((name) => ({ name })) }),
+            };
+            if (options.attachments?.length) {
+                body.attachments = options.attachments.map((att) => ({
+                    filename: att.filename,
+                    content: typeof att.content === 'string' ? att.content : att.content.toString('base64'),
+                    content_type: att.contentType,
+                }));
+            }
+            if (options.sendAt) {
+                body.scheduled_at = options.sendAt.toISOString();
+            }
+            try {
+                const response = await fetch(`${RESEND_API_URL}/emails`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                    body: JSON.stringify(body),
+                });
+                const data = await response.json();
+                if (response.ok) {
+                    return {
+                        success: true,
+                        messageId: data.id,
+                    };
+                }
+                return {
+                    success: false,
+                    error: {
+                        code: data.name || `HTTP_${response.status}`,
+                        message: data.message || response.statusText,
+                    },
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NETWORK_ERROR',
+                        message: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                };
+            }
+        },
+        async sendBatch(emails) {
+            // Resend has a batch endpoint
+            const from = defaultFrom;
+            const batch = emails.map((options) => ({
+                from: options.from || from,
+                to: options.to,
+                subject: options.subject,
+                ...(options.cc && { cc: options.cc }),
+                ...(options.bcc && { bcc: options.bcc }),
+                ...(options.replyTo && { reply_to: options.replyTo }),
+                ...(options.text && { text: options.text }),
+                ...(options.html && { html: options.html }),
+            }));
+            try {
+                const response = await fetch(`${RESEND_API_URL}/emails/batch`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                    body: JSON.stringify(batch),
+                });
+                const data = await response.json();
+                if (response.ok) {
+                    return data.data.map((item) => ({
+                        success: true,
+                        messageId: item.id,
+                    }));
+                }
+                // If batch fails, return error for all
+                return emails.map(() => ({
+                    success: false,
+                    error: {
+                        code: data.name || `HTTP_${response.status}`,
+                        message: data.message || response.statusText,
+                    },
+                }));
+            }
+            catch (error) {
+                return emails.map(() => ({
+                    success: false,
+                    error: {
+                        code: 'NETWORK_ERROR',
+                        message: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                }));
+            }
+        },
+        async get(messageId) {
+            try {
+                const response = await fetch(`${RESEND_API_URL}/emails/${messageId}`, {
+                    headers: {
+                        Authorization: `Bearer ${apiKey}`,
+                    },
+                });
+                if (!response.ok) {
+                    if (response.status === 404)
+                        return null;
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const data = (await response.json());
+                return {
+                    id: data.id,
+                    from: data.from,
+                    to: Array.isArray(data.to) ? data.to : [data.to],
+                    cc: data.cc,
+                    bcc: data.bcc,
+                    subject: data.subject,
+                    text: data.text,
+                    html: data.html,
+                    status: mapResendStatus(data.last_event),
+                    sentAt: data.created_at ? new Date(data.created_at) : undefined,
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+        async verifyDomain(domain) {
+            const response = await fetch(`${RESEND_API_URL}/domains`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify({ name: domain }),
+            });
+            const data = (await response.json());
+            return {
+                domain: data.name,
+                verified: data.status === 'verified',
+                dnsRecords: data.records?.map((r) => ({
+                    type: r.type,
+                    name: r.name,
+                    value: r.value,
+                    verified: r.status === 'verified',
+                })) || [],
+            };
+        },
+        async listDomains() {
+            const response = await fetch(`${RESEND_API_URL}/domains`, {
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                },
+            });
+            const data = (await response.json());
+            return data.data?.map((d) => ({
+                domain: d.name,
+                verified: d.status === 'verified',
+                createdAt: new Date(d.created_at),
+            })) || [];
+        },
+    };
+}
+function mapResendStatus(event) {
+    switch (event) {
+        case 'delivered':
+            return 'delivered';
+        case 'bounced':
+            return 'bounced';
+        case 'complained':
+            return 'failed';
+        default:
+            return 'sent';
+    }
+}
+/**
+ * Resend provider definition
+ */
+export const resendProvider = defineProvider(resendInfo, async (config) => createResendProvider(config));