ucpify 1.0.0

package/dist/express-app.js

@@ -0,0 +1,318 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpressApp = createExpressApp;
+const express_1 = __importDefault(require("express"));
+const express_rate_limit_1 = __importDefault(require("express-rate-limit"));
+const ucp_server_1 = require("./ucp-server");
+const ucp_server_db_1 = require("./ucp-server-db");
+const schema_1 = require("./schema");
+const db_1 = require("./db");
+const logger_1 = require("./logger");
+const stripe_1 = require("./stripe");
+const paypal_1 = require("./paypal");
+// Rate limiters
+const apiLimiter = (0, express_rate_limit_1.default)({
+    windowMs: 60 * 1000, // 1 minute
+    max: 100, // 100 requests per minute
+    standardHeaders: true,
+    legacyHeaders: false,
+    message: { error: 'Too many requests, please try again later' },
+});
+const checkoutLimiter = (0, express_rate_limit_1.default)({
+    windowMs: 60 * 1000,
+    max: 20, // 20 checkout creates per minute
+    standardHeaders: true,
+    legacyHeaders: false,
+    message: { error: 'Too many checkout requests' },
+});
+function createExpressApp(config, options) {
+    const app = (0, express_1.default)();
+    const ucpServer = options?.useDb
+        ? new ucp_server_db_1.UCPServerDB(config)
+        : new ucp_server_1.UCPServer(config);
+    const useDb = options?.useDb ?? false;
+    // Apply rate limiting to API routes
+    app.use('/ucp/v1/', apiLimiter);
+    // Stripe webhook needs raw body - must come before json parser
+    app.post('/webhooks/stripe', express_1.default.raw({ type: 'application/json' }), (req, res) => {
+        const signature = req.headers['stripe-signature'];
+        if (!signature) {
+            res.status(400).json({ error: 'Missing stripe-signature header' });
+            return;
+        }
+        const event = (0, stripe_1.constructWebhookEvent)(req.body, signature);
+        if (!event) {
+            res.status(400).json({ error: 'Invalid webhook signature' });
+            return;
+        }
+        logger_1.logger.info({ eventType: event.type, eventId: event.id }, 'Stripe webhook received');
+        switch (event.type) {
+            case 'payment_intent.succeeded': {
+                const paymentIntent = event.data.object;
+                const checkoutId = paymentIntent.metadata?.checkout_id;
+                const orderId = paymentIntent.metadata?.order_id;
+                if (checkoutId && useDb) {
+                    db_1.db.prepare(`UPDATE checkouts SET payment_status = 'succeeded', updated_at = ? WHERE id = ?`)
+                        .run(new Date().toISOString(), checkoutId);
+                    if (orderId) {
+                        db_1.db.prepare(`UPDATE orders SET payment_status = 'succeeded' WHERE id = ?`).run(orderId);
+                    }
+                    logger_1.logger.info({ checkoutId, orderId, paymentIntentId: paymentIntent.id }, 'Payment succeeded');
+                }
+                break;
+            }
+            case 'payment_intent.payment_failed': {
+                const paymentIntent = event.data.object;
+                const checkoutId = paymentIntent.metadata?.checkout_id;
+                const orderId = paymentIntent.metadata?.order_id;
+                if (checkoutId && useDb) {
+                    db_1.db.prepare(`UPDATE checkouts SET payment_status = 'failed', updated_at = ? WHERE id = ?`)
+                        .run(new Date().toISOString(), checkoutId);
+                    if (orderId) {
+                        db_1.db.prepare(`UPDATE orders SET payment_status = 'failed' WHERE id = ?`).run(orderId);
+                    }
+                    logger_1.logger.error({
+                        checkoutId, orderId, paymentIntentId: paymentIntent.id,
+                        error: paymentIntent.last_payment_error?.message
+                    }, 'Payment failed');
+                }
+                break;
+            }
+        }
+        res.json({ received: true });
+    });
+    // PayPal webhook - capture completed orders
+    app.post('/webhooks/paypal', express_1.default.json(), async (req, res) => {
+        const eventType = req.body.event_type;
+        const resource = req.body.resource;
+        logger_1.logger.info({ eventType, resourceId: resource?.id }, 'PayPal webhook received');
+        if (eventType === 'CHECKOUT.ORDER.APPROVED' && resource?.id) {
+            try {
+                // Capture the payment
+                const capturedOrder = await (0, paypal_1.capturePayPalOrder)(resource.id);
+                if (capturedOrder && capturedOrder.status === 'COMPLETED') {
+                    // Get the checkout ID from the order
+                    const orderDetails = await (0, paypal_1.getPayPalOrder)(resource.id);
+                    const checkoutId = orderDetails?.customId;
+                    if (checkoutId && useDb) {
+                        const now = new Date().toISOString();
+                        db_1.db.prepare(`UPDATE checkouts SET payment_status = 'succeeded', updated_at = ? WHERE paypal_order_id = ?`)
+                            .run(now, resource.id);
+                        db_1.db.prepare(`UPDATE orders SET payment_status = 'succeeded' WHERE paypal_order_id = ?`)
+                            .run(resource.id);
+                        logger_1.logger.info({ checkoutId, paypalOrderId: resource.id }, 'PayPal payment captured and succeeded');
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.logger.error({ error, paypalOrderId: resource.id }, 'Failed to capture PayPal order');
+            }
+        }
+        else if (eventType === 'PAYMENT.CAPTURE.DENIED' && resource?.id) {
+            if (useDb) {
+                const now = new Date().toISOString();
+                db_1.db.prepare(`UPDATE checkouts SET payment_status = 'failed', updated_at = ? WHERE paypal_order_id = ?`)
+                    .run(now, resource.supplementary_data?.related_ids?.order_id);
+                db_1.db.prepare(`UPDATE orders SET payment_status = 'failed' WHERE paypal_order_id = ?`)
+                    .run(resource.supplementary_data?.related_ids?.order_id);
+                logger_1.logger.error({ paypalOrderId: resource.id }, 'PayPal payment denied');
+            }
+        }
+        res.json({ received: true });
+    });
+    app.use(express_1.default.json());
+    // Request logging middleware
+    app.use((req, res, next) => {
+        const start = Date.now();
+        res.on('finish', () => {
+            logger_1.logger.info({
+                method: req.method,
+                path: req.path,
+                status: res.statusCode,
+                duration: Date.now() - start,
+            }, 'Request completed');
+        });
+        next();
+    });
+    // CORS middleware
+    app.use((_req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        res.header('Access-Control-Allow-Headers', 'Content-Type, UCP-Agent, Authorization');
+        next();
+    });
+    // UCP Discovery endpoint
+    app.get('/.well-known/ucp', (_req, res) => {
+        res.json(ucpServer.getProfile());
+    });
+    // Create Checkout Session
+    app.post('/ucp/v1/checkout-sessions', checkoutLimiter, (req, res) => {
+        const parsed = schema_1.CreateCheckoutRequestSchema.safeParse(req.body);
+        if (!parsed.success) {
+            res.status(400).json({ error: 'Validation failed', details: parsed.error.issues });
+            return;
+        }
+        try {
+            const session = ucpServer.createCheckout(parsed.data);
+            res.status(201).json(session);
+        }
+        catch (error) {
+            res.status(400).json({ error: 'Invalid request', details: String(error) });
+        }
+    });
+    // Get Checkout Session
+    app.get('/ucp/v1/checkout-sessions/:id', (req, res) => {
+        const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+        const session = ucpServer.getCheckout(id);
+        if (!session) {
+            res.status(404).json({ error: 'Checkout session not found' });
+            return;
+        }
+        res.json(session);
+    });
+    // Update Checkout Session
+    app.put('/ucp/v1/checkout-sessions/:id', (req, res) => {
+        const parsed = schema_1.UpdateCheckoutRequestSchema.safeParse(req.body);
+        if (!parsed.success) {
+            res.status(400).json({ error: 'Validation failed', details: parsed.error.issues });
+            return;
+        }
+        try {
+            const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+            const session = ucpServer.updateCheckout(id, parsed.data);
+            if (!session) {
+                res.status(404).json({ error: 'Checkout session not found' });
+                return;
+            }
+            res.json(session);
+        }
+        catch (error) {
+            res.status(400).json({ error: 'Invalid request', details: String(error) });
+        }
+    });
+    // Complete Checkout
+    app.post('/ucp/v1/checkout-sessions/:id/complete', async (req, res) => {
+        const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+        try {
+            const result = await ucpServer.completeCheckout(id);
+            if ('error' in result) {
+                res.status(400).json(result);
+                return;
+            }
+            res.status(201).json(result);
+        }
+        catch (error) {
+            logger_1.logger.error({ error, checkoutId: id }, 'Failed to complete checkout');
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    });
+    // Cancel Checkout
+    app.post('/ucp/v1/checkout-sessions/:id/cancel', (req, res) => {
+        const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+        const session = ucpServer.cancelCheckout(id);
+        if (!session) {
+            res.status(404).json({ error: 'Checkout session not found' });
+            return;
+        }
+        res.json(session);
+    });
+    // Get Order
+    app.get('/ucp/v1/orders/:id', (req, res) => {
+        const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+        const order = ucpServer.getOrder(id);
+        if (!order) {
+            res.status(404).json({ error: 'Order not found' });
+            return;
+        }
+        res.json(order);
+    });
+    // List Orders
+    app.get('/ucp/v1/orders', (_req, res) => {
+        res.json(ucpServer.listOrders());
+    });
+    // Product catalog (convenience endpoint)
+    app.get('/ucp/v1/items', (_req, res) => {
+        res.json(ucpServer.getConfig().items);
+    });
+    // Admin stats endpoint
+    app.get('/admin/stats', (_req, res) => {
+        if (!useDb) {
+            res.status(501).json({ error: 'Stats require database mode' });
+            return;
+        }
+        try {
+            const checkoutStats = db_1.db.prepare(`
+        SELECT status, COUNT(*) as count FROM checkouts GROUP BY status
+      `).all();
+            const orderStats = db_1.db.prepare(`
+        SELECT payment_status, payment_provider, COUNT(*) as count 
+        FROM orders GROUP BY payment_status, payment_provider
+      `).all();
+            const revenueResult = db_1.db.prepare(`
+        SELECT SUM(json_extract(totals_json, '$[?(@.type=="total")].amount')) as total
+        FROM orders WHERE payment_status = 'succeeded'
+      `).get();
+            const todayOrders = db_1.db.prepare(`
+        SELECT COUNT(*) as count FROM orders 
+        WHERE date(created_at) = date('now')
+      `).get();
+            res.json({
+                checkouts: Object.fromEntries(checkoutStats.map(s => [s.status, s.count])),
+                orders: {
+                    by_payment_status: Object.fromEntries(orderStats.map(s => [`${s.payment_provider || 'none'}_${s.payment_status}`, s.count])),
+                    today: todayOrders.count,
+                },
+                revenue: {
+                    total_succeeded: revenueResult.total || 0,
+                },
+                timestamp: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Failed to get admin stats');
+            res.status(500).json({ error: 'Failed to get stats' });
+        }
+    });
+    // Admin dashboard HTML
+    app.get('/admin', (_req, res) => {
+        res.send(`<!DOCTYPE html>
+<html><head><title>UCP Admin</title>
+<style>
+  body { font-family: system-ui; max-width: 800px; margin: 40px auto; padding: 20px; }
+  .card { background: #f5f5f5; padding: 20px; border-radius: 8px; margin: 10px 0; }
+  .stat { font-size: 2em; font-weight: bold; color: #333; }
+  .label { color: #666; font-size: 0.9em; }
+  .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; }
+  h1 { color: #333; }
+</style>
+</head><body>
+<h1>🛒 UCP Server Admin</h1>
+<div class="grid" id="stats">Loading...</div>
+<script>
+fetch('/admin/stats').then(r=>r.json()).then(d=>{
+  document.getElementById('stats').innerHTML = \`
+    <div class="card"><div class="stat">\${Object.values(d.checkouts).reduce((a,b)=>a+b,0)}</div><div class="label">Total Checkouts</div></div>
+    <div class="card"><div class="stat">\${d.checkouts.completed||0}</div><div class="label">Completed</div></div>
+    <div class="card"><div class="stat">\${d.orders.today||0}</div><div class="label">Orders Today</div></div>
+    <div class="card"><div class="stat">$\${(d.revenue.total_succeeded/100).toFixed(2)}</div><div class="label">Revenue</div></div>
+  \`;
+}).catch(e=>document.getElementById('stats').innerHTML='Error loading stats');
+</script>
+</body></html>`);
+    });
+    // Health check
+    app.get('/health', (_req, res) => {
+        const dbHealthy = (0, db_1.isDbHealthy)();
+        const status = dbHealthy ? 'ok' : 'degraded';
+        res.status(dbHealthy ? 200 : 503).json({
+            status,
+            ucp_version: schema_1.UCP_VERSION,
+            database: dbHealthy ? 'connected' : 'disconnected',
+            timestamp: new Date().toISOString(),
+        });
+    });
+    return app;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { MerchantConfigSchema, ItemSchema, ShippingOptionSchema, PaymentHandlerSchema } from './schema';
+export type { MerchantConfig, Item, ShippingOption, PaymentHandler, CheckoutSession, Order } from './schema';
+export { UCPServer } from './ucp-server';
+export { createExpressApp } from './express-app';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpressApp = exports.UCPServer = exports.PaymentHandlerSchema = exports.ShippingOptionSchema = exports.ItemSchema = exports.MerchantConfigSchema = void 0;
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "MerchantConfigSchema", { enumerable: true, get: function () { return schema_1.MerchantConfigSchema; } });
+Object.defineProperty(exports, "ItemSchema", { enumerable: true, get: function () { return schema_1.ItemSchema; } });
+Object.defineProperty(exports, "ShippingOptionSchema", { enumerable: true, get: function () { return schema_1.ShippingOptionSchema; } });
+Object.defineProperty(exports, "PaymentHandlerSchema", { enumerable: true, get: function () { return schema_1.PaymentHandlerSchema; } });
+var ucp_server_1 = require("./ucp-server");
+Object.defineProperty(exports, "UCPServer", { enumerable: true, get: function () { return ucp_server_1.UCPServer; } });
+var express_app_1 = require("./express-app");
+Object.defineProperty(exports, "createExpressApp", { enumerable: true, get: function () { return express_app_1.createExpressApp; } });

package/dist/logger.d.ts

@@ -0,0 +1,3 @@
+import pino from 'pino';
+export declare const logger: pino.Logger<never, boolean>;
+export type Logger = typeof logger;

package/dist/logger.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const pino_1 = __importDefault(require("pino"));
+const config_1 = require("./config");
+exports.logger = (0, pino_1.default)({
+    level: config_1.config.logLevel,
+    transport: config_1.config.nodeEnv === 'development'
+        ? { target: 'pino-pretty', options: { colorize: true } }
+        : undefined,
+    base: { service: 'ucp-server' },
+});

package/dist/paypal.d.ts

@@ -0,0 +1,20 @@
+export declare function isPayPalConfigured(): boolean;
+export interface CreatePayPalOrderParams {
+    amount: number;
+    currency: string;
+    checkoutId: string;
+    description?: string;
+}
+export declare function createPayPalOrder(params: CreatePayPalOrderParams): Promise<{
+    id: string;
+    status: string;
+} | null>;
+export declare function capturePayPalOrder(orderId: string): Promise<{
+    id: string;
+    status: string;
+} | null>;
+export declare function getPayPalOrder(orderId: string): Promise<{
+    id: string;
+    status: string;
+    customId?: string;
+} | null>;

package/dist/paypal.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPayPalConfigured = isPayPalConfigured;
+exports.createPayPalOrder = createPayPalOrder;
+exports.capturePayPalOrder = capturePayPalOrder;
+exports.getPayPalOrder = getPayPalOrder;
+const paypal_server_sdk_1 = require("@paypal/paypal-server-sdk");
+const config_1 = require("./config");
+const logger_1 = require("./logger");
+let paypalClient = null;
+let ordersController = null;
+function getPayPalClient() {
+    if (!config_1.config.paypalClientId || !config_1.config.paypalClientSecret) {
+        return null;
+    }
+    if (!paypalClient) {
+        paypalClient = new paypal_server_sdk_1.Client({
+            clientCredentialsAuthCredentials: {
+                oAuthClientId: config_1.config.paypalClientId,
+                oAuthClientSecret: config_1.config.paypalClientSecret,
+            },
+            environment: config_1.config.paypalMode === 'live' ? paypal_server_sdk_1.Environment.Production : paypal_server_sdk_1.Environment.Sandbox,
+        });
+        ordersController = new paypal_server_sdk_1.OrdersController(paypalClient);
+        logger_1.logger.info('PayPal client initialized');
+    }
+    return paypalClient;
+}
+function isPayPalConfigured() {
+    return !!(config_1.config.paypalClientId && config_1.config.paypalClientSecret);
+}
+async function createPayPalOrder(params) {
+    const client = getPayPalClient();
+    if (!client || !ordersController) {
+        logger_1.logger.warn('PayPal not configured, skipping order creation');
+        return null;
+    }
+    // Convert cents to dollars with 2 decimal places
+    const amountValue = (params.amount / 100).toFixed(2);
+    try {
+        const response = await ordersController.createOrder({
+            body: {
+                intent: paypal_server_sdk_1.CheckoutPaymentIntent.Capture,
+                purchaseUnits: [
+                    {
+                        amount: {
+                            currencyCode: params.currency.toUpperCase(),
+                            value: amountValue,
+                        },
+                        description: params.description || `Checkout ${params.checkoutId}`,
+                        customId: params.checkoutId,
+                    },
+                ],
+            },
+            prefer: 'return=representation',
+        });
+        const order = response.result;
+        logger_1.logger.info({
+            paypalOrderId: order.id,
+            checkoutId: params.checkoutId,
+            amount: params.amount,
+        }, 'PayPal order created');
+        return { id: order.id, status: order.status };
+    }
+    catch (error) {
+        if (error instanceof paypal_server_sdk_1.ApiError) {
+            logger_1.logger.error({ error: error.message, checkoutId: params.checkoutId }, 'Failed to create PayPal order');
+        }
+        throw error;
+    }
+}
+async function capturePayPalOrder(orderId) {
+    const client = getPayPalClient();
+    if (!client || !ordersController)
+        return null;
+    try {
+        const response = await ordersController.captureOrder({
+            id: orderId,
+            prefer: 'return=representation',
+        });
+        const order = response.result;
+        logger_1.logger.info({ paypalOrderId: orderId, status: order.status }, 'PayPal order captured');
+        return { id: order.id, status: order.status };
+    }
+    catch (error) {
+        if (error instanceof paypal_server_sdk_1.ApiError) {
+            logger_1.logger.error({ error: error.message, paypalOrderId: orderId }, 'Failed to capture PayPal order');
+        }
+        throw error;
+    }
+}
+async function getPayPalOrder(orderId) {
+    const client = getPayPalClient();
+    if (!client || !ordersController)
+        return null;
+    try {
+        const response = await ordersController.getOrder({ id: orderId });
+        const order = response.result;
+        return {
+            id: order.id,
+            status: order.status,
+            customId: order.purchaseUnits?.[0]?.customId,
+        };
+    }
+    catch (error) {
+        if (error instanceof paypal_server_sdk_1.ApiError) {
+            logger_1.logger.error({ error: error.message, paypalOrderId: orderId }, 'Failed to get PayPal order');
+        }
+        throw error;
+    }
+}