digital-tools 2.1.1 → 2.3.0

package/src/providers/ecommerce/shopify.js

@@ -1,378 +0,0 @@
-/**
- * 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

@@ -1,20 +0,0 @@
-/**
- * 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

@@ -1,258 +0,0 @@
-/**
- * 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));