ucpify 1.2.0 → 1.2.1

package/dist/oauth.js

@@ -1,211 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OAuthManager = exports.UCP_SCOPES = void 0;
-const crypto_1 = __importDefault(require("crypto"));
-const logger_1 = require("./logger");
-// ─── Constants ───────────────────────────────────────────────────────
-exports.UCP_SCOPES = ['ucp:scopes:checkout_session'];
-const ACCESS_TOKEN_TTL = 60 * 60; // 1 hour
-const REFRESH_TOKEN_TTL = 60 * 60 * 24 * 30; // 30 days
-const AUTH_CODE_TTL = 60 * 10; // 10 minutes
-// ─── Helpers ─────────────────────────────────────────────────────────
-function generateToken(bytes = 32) {
-    return crypto_1.default.randomBytes(bytes).toString('hex');
-}
-function hashSecret(secret) {
-    return crypto_1.default.createHash('sha256').update(secret).digest('hex');
-}
-function nowEpoch() {
-    return Math.floor(Date.now() / 1000);
-}
-// ─── OAuth Manager ───────────────────────────────────────────────────
-class OAuthManager {
-    clients = new Map();
-    codes = new Map();
-    accessTokens = new Map();
-    refreshTokens = new Map();
-    // ── Client Management ──
-    createClient(name, redirectUris) {
-        const clientId = `ucp_${generateToken(16)}`;
-        const clientSecret = `ucp_secret_${generateToken(24)}`;
-        const client = {
-            client_id: clientId,
-            client_secret: clientSecret,
-            client_secret_hash: hashSecret(clientSecret),
-            name,
-            redirect_uris: redirectUris,
-            created_at: new Date().toISOString(),
-        };
-        this.clients.set(clientId, client);
-        logger_1.logger.info({ clientId, name }, 'OAuth client created');
-        return client;
-    }
-    getClient(clientId) {
-        return this.clients.get(clientId);
-    }
-    authenticateClient(clientId, clientSecret) {
-        const client = this.clients.get(clientId);
-        if (!client)
-            return false;
-        return client.client_secret_hash === hashSecret(clientSecret);
-    }
-    // ── Authorization Code ──
-    createAuthorizationCode(clientId, userId, scope, redirectUri, codeChallenge, codeChallengeMethod) {
-        const code = generateToken(32);
-        const authCode = {
-            code,
-            client_id: clientId,
-            user_id: userId,
-            scope,
-            redirect_uri: redirectUri,
-            code_challenge: codeChallenge,
-            code_challenge_method: codeChallengeMethod,
-            expires_at: nowEpoch() + AUTH_CODE_TTL,
-            used: false,
-        };
-        this.codes.set(code, authCode);
-        logger_1.logger.info({ clientId, userId, scope }, 'Authorization code created');
-        return code;
-    }
-    exchangeCode(code, clientId, redirectUri, codeVerifier) {
-        const authCode = this.codes.get(code);
-        if (!authCode)
-            return { error: 'invalid_grant' };
-        if (authCode.used)
-            return { error: 'invalid_grant' };
-        if (authCode.client_id !== clientId)
-            return { error: 'invalid_grant' };
-        if (authCode.redirect_uri !== redirectUri)
-            return { error: 'invalid_grant' };
-        if (authCode.expires_at < nowEpoch())
-            return { error: 'invalid_grant' };
-        // PKCE verification
-        if (authCode.code_challenge) {
-            if (!codeVerifier)
-                return { error: 'invalid_grant' };
-            const method = authCode.code_challenge_method || 'S256';
-            let computed;
-            if (method === 'S256') {
-                computed = crypto_1.default.createHash('sha256').update(codeVerifier).digest('base64url');
-            }
-            else {
-                computed = codeVerifier;
-            }
-            if (computed !== authCode.code_challenge)
-                return { error: 'invalid_grant' };
-        }
-        // Mark code as used
-        authCode.used = true;
-        this.codes.set(code, authCode);
-        // Generate tokens
-        const accessToken = this.createAccessToken(clientId, authCode.user_id, authCode.scope);
-        const refreshToken = this.createRefreshToken(clientId, authCode.user_id, authCode.scope);
-        logger_1.logger.info({ clientId, userId: authCode.user_id }, 'Authorization code exchanged for tokens');
-        return {
-            access_token: accessToken,
-            refresh_token: refreshToken,
-            expires_in: ACCESS_TOKEN_TTL,
-            scope: authCode.scope,
-        };
-    }
-    // ── Token Management ──
-    createAccessToken(clientId, userId, scope) {
-        const token = generateToken(32);
-        this.accessTokens.set(token, {
-            token,
-            token_type: 'access',
-            client_id: clientId,
-            user_id: userId,
-            scope,
-            expires_at: nowEpoch() + ACCESS_TOKEN_TTL,
-            revoked: false,
-        });
-        return token;
-    }
-    createRefreshToken(clientId, userId, scope) {
-        const token = generateToken(32);
-        this.refreshTokens.set(token, {
-            token,
-            token_type: 'refresh',
-            client_id: clientId,
-            user_id: userId,
-            scope,
-            expires_at: nowEpoch() + REFRESH_TOKEN_TTL,
-            revoked: false,
-        });
-        return token;
-    }
-    refreshAccessToken(refreshToken, clientId) {
-        const rt = this.refreshTokens.get(refreshToken);
-        if (!rt)
-            return { error: 'invalid_grant' };
-        if (rt.revoked)
-            return { error: 'invalid_grant' };
-        if (rt.client_id !== clientId)
-            return { error: 'invalid_grant' };
-        if (rt.expires_at < nowEpoch())
-            return { error: 'invalid_grant' };
-        const accessToken = this.createAccessToken(clientId, rt.user_id, rt.scope);
-        logger_1.logger.info({ clientId, userId: rt.user_id }, 'Access token refreshed');
-        return {
-            access_token: accessToken,
-            expires_in: ACCESS_TOKEN_TTL,
-            scope: rt.scope,
-        };
-    }
-    validateAccessToken(token) {
-        const t = this.accessTokens.get(token);
-        if (!t)
-            return null;
-        if (t.revoked)
-            return null;
-        if (t.expires_at < nowEpoch())
-            return null;
-        return t;
-    }
-    revokeToken(token) {
-        // Check access tokens
-        const at = this.accessTokens.get(token);
-        if (at) {
-            at.revoked = true;
-            this.accessTokens.set(token, at);
-            logger_1.logger.info({ tokenType: 'access', clientId: at.client_id }, 'Token revoked');
-            return true;
-        }
-        // Check refresh tokens - also revoke all associated access tokens
-        const rt = this.refreshTokens.get(token);
-        if (rt) {
-            rt.revoked = true;
-            this.refreshTokens.set(token, rt);
-            // Revoke all access tokens for same client+user
-            for (const [key, accessToken] of this.accessTokens) {
-                if (accessToken.client_id === rt.client_id && accessToken.user_id === rt.user_id) {
-                    accessToken.revoked = true;
-                    this.accessTokens.set(key, accessToken);
-                }
-            }
-            logger_1.logger.info({ tokenType: 'refresh', clientId: rt.client_id }, 'Refresh token and associated access tokens revoked');
-            return true;
-        }
-        return false;
-    }
-    // ── Metadata ──
-    getServerMetadata(issuer) {
-        return {
-            issuer,
-            authorization_endpoint: `${issuer}/oauth2/authorize`,
-            token_endpoint: `${issuer}/oauth2/token`,
-            revocation_endpoint: `${issuer}/oauth2/revoke`,
-            scopes_supported: [...exports.UCP_SCOPES],
-            response_types_supported: ['code'],
-            grant_types_supported: ['authorization_code', 'refresh_token'],
-            token_endpoint_auth_methods_supported: ['client_secret_basic'],
-            code_challenge_methods_supported: ['S256'],
-            service_documentation: `${issuer}/docs/oauth2`,
-        };
-    }
-}
-exports.OAuthManager = OAuthManager;

package/dist/paypal.d.ts

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

@@ -1,111 +0,0 @@
-"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;
-    }
-}

package/dist/schema.d.ts

@@ -1,287 +0,0 @@
-import { z } from 'zod';
-export declare const UCP_VERSION = "2026-01-11";
-export declare const ItemSchema: z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    price: z.ZodNumber;
-    image_url: z.ZodOptional<z.ZodString>;
-    sku: z.ZodOptional<z.ZodString>;
-    stock: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strip>;
-export declare const ShippingOptionSchema: z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    price: z.ZodNumber;
-    estimated_days: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const PaymentHandlerSchema: z.ZodObject<{
-    namespace: z.ZodString;
-    id: z.ZodString;
-    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-export declare const OAuthConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    provider: z.ZodLiteral<"built-in">;
-}, z.core.$strip>, z.ZodObject<{
-    provider: z.ZodLiteral<"external">;
-    issuer: z.ZodString;
-    authorization_endpoint: z.ZodString;
-    token_endpoint: z.ZodString;
-    revocation_endpoint: z.ZodOptional<z.ZodString>;
-    jwks_uri: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>], "provider">;
-export type OAuthConfig = z.infer<typeof OAuthConfigSchema>;
-export declare const MerchantConfigSchema: z.ZodObject<{
-    name: z.ZodString;
-    domain: z.ZodString;
-    currency: z.ZodDefault<z.ZodString>;
-    terms_url: z.ZodOptional<z.ZodString>;
-    privacy_url: z.ZodOptional<z.ZodString>;
-    items: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        price: z.ZodNumber;
-        image_url: z.ZodOptional<z.ZodString>;
-        sku: z.ZodOptional<z.ZodString>;
-        stock: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    shipping_options: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        description: z.ZodOptional<z.ZodString>;
-        price: z.ZodNumber;
-        estimated_days: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>>;
-    payment_handlers: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        namespace: z.ZodString;
-        id: z.ZodString;
-        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>>>;
-    tax_rate: z.ZodDefault<z.ZodNumber>;
-    port: z.ZodDefault<z.ZodNumber>;
-    oauth: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        provider: z.ZodLiteral<"built-in">;
-    }, z.core.$strip>, z.ZodObject<{
-        provider: z.ZodLiteral<"external">;
-        issuer: z.ZodString;
-        authorization_endpoint: z.ZodString;
-        token_endpoint: z.ZodString;
-        revocation_endpoint: z.ZodOptional<z.ZodString>;
-        jwks_uri: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>], "provider">>;
-}, z.core.$strip>;
-export type Item = z.infer<typeof ItemSchema>;
-export type ShippingOption = z.infer<typeof ShippingOptionSchema>;
-export type PaymentHandler = z.infer<typeof PaymentHandlerSchema>;
-export type MerchantConfig = z.infer<typeof MerchantConfigSchema>;
-export type CheckoutStatus = 'incomplete' | 'requires_escalation' | 'ready_for_complete' | 'complete_in_progress' | 'completed' | 'canceled';
-export interface Buyer {
-    email?: string;
-    first_name?: string;
-    last_name?: string;
-    phone?: string;
-}
-export interface Address {
-    id?: string;
-    first_name?: string;
-    last_name?: string;
-    street_address: string;
-    address_locality: string;
-    address_region: string;
-    postal_code: string;
-    address_country: string;
-}
-export interface LineItem {
-    id: string;
-    item: Item;
-    quantity: number;
-    totals?: {
-        type: string;
-        amount: number;
-    }[];
-}
-export interface FulfillmentOption {
-    id: string;
-    title: string;
-    description?: string;
-    totals: {
-        type: string;
-        amount: number;
-    }[];
-}
-export interface FulfillmentGroup {
-    id: string;
-    line_item_ids: string[];
-    selected_option_id?: string;
-    options: FulfillmentOption[];
-}
-export interface FulfillmentMethod {
-    id: string;
-    type: 'shipping' | 'pickup' | 'digital';
-    line_item_ids: string[];
-    selected_destination_id?: string;
-    destinations: Address[];
-    groups: FulfillmentGroup[];
-}
-export interface Fulfillment {
-    methods: FulfillmentMethod[];
-}
-export interface PaymentInstrument {
-    id: string;
-    handler_id: string;
-    type: string;
-    selected?: boolean;
-    display?: Record<string, unknown>;
-}
-export interface Payment {
-    instruments: PaymentInstrument[];
-}
-export interface CheckoutMessage {
-    type: 'error' | 'warning' | 'info';
-    code: string;
-    path?: string;
-    content: string;
-    severity: 'recoverable' | 'requires_buyer_input' | 'requires_buyer_review';
-}
-export interface OrderConfirmation {
-    id: string;
-    permalink_url?: string;
-}
-export interface CheckoutSession {
-    ucp: {
-        version: string;
-        capabilities: Record<string, {
-            version: string;
-        }[]>;
-        payment_handlers?: Record<string, {
-            id: string;
-            version: string;
-            config?: Record<string, unknown>;
-        }[]>;
-    };
-    id: string;
-    status: CheckoutStatus;
-    messages?: CheckoutMessage[];
-    currency: string;
-    buyer?: Buyer;
-    line_items: LineItem[];
-    totals: {
-        type: string;
-        amount: number;
-    }[];
-    links: {
-        type: string;
-        url: string;
-        title?: string;
-    }[];
-    fulfillment?: Fulfillment;
-    payment?: Payment;
-    continue_url?: string;
-    expires_at?: string;
-    order?: OrderConfirmation;
-}
-export interface Order {
-    ucp: {
-        version: string;
-        capabilities: Record<string, {
-            version: string;
-        }[]>;
-    };
-    id: string;
-    checkout_id: string;
-    permalink_url?: string;
-    line_items: LineItem[];
-    buyer?: Buyer;
-    totals: {
-        type: string;
-        amount: number;
-    }[];
-    fulfillment?: {
-        expectations: {
-            id: string;
-            line_items: {
-                id: string;
-                quantity: number;
-            }[];
-            method_type: string;
-            destination?: Address;
-            description?: string;
-            fulfillable_on?: string;
-        }[];
-        events: {
-            id: string;
-            occurred_at: string;
-            type: string;
-            line_items: {
-                id: string;
-                quantity: number;
-            }[];
-            tracking_number?: string;
-            tracking_url?: string;
-            description?: string;
-        }[];
-    };
-    created_at: string;
-}
-export declare const CreateCheckoutRequestSchema: z.ZodObject<{
-    line_items: z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        item: z.ZodObject<{
-            id: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-            price: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
-        quantity: z.ZodNumber;
-    }, z.core.$strip>>;
-    buyer: z.ZodOptional<z.ZodObject<{
-        email: z.ZodOptional<z.ZodString>;
-        first_name: z.ZodOptional<z.ZodString>;
-        last_name: z.ZodOptional<z.ZodString>;
-        phone: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    fulfillment: z.ZodOptional<z.ZodObject<{
-        methods: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodOptional<z.ZodString>;
-            type: z.ZodEnum<{
-                shipping: "shipping";
-                pickup: "pickup";
-                digital: "digital";
-            }>;
-            line_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            selected_destination_id: z.ZodOptional<z.ZodString>;
-            destinations: z.ZodArray<z.ZodObject<{
-                id: z.ZodOptional<z.ZodString>;
-                first_name: z.ZodOptional<z.ZodString>;
-                last_name: z.ZodOptional<z.ZodString>;
-                street_address: z.ZodString;
-                address_locality: z.ZodString;
-                address_region: z.ZodString;
-                postal_code: z.ZodString;
-                address_country: z.ZodString;
-            }, z.core.$strip>>;
-            groups: z.ZodOptional<z.ZodArray<z.ZodAny>>;
-        }, z.core.$strip>>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const UpdateCheckoutRequestSchema: z.ZodObject<{
-    buyer: z.ZodOptional<z.ZodObject<{
-        email: z.ZodOptional<z.ZodString>;
-        first_name: z.ZodOptional<z.ZodString>;
-        last_name: z.ZodOptional<z.ZodString>;
-        phone: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    line_items: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        item: z.ZodObject<{
-            id: z.ZodString;
-            title: z.ZodOptional<z.ZodString>;
-            price: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>;
-        quantity: z.ZodNumber;
-    }, z.core.$strip>>>;
-    fulfillment: z.ZodOptional<z.ZodAny>;
-}, z.core.$strip>;
-export type CreateCheckoutRequest = z.infer<typeof CreateCheckoutRequestSchema>;
-export type UpdateCheckoutRequest = z.infer<typeof UpdateCheckoutRequestSchema>;