How to Integrate Bolt.new with PrestaShop

1// lib/prestashop.ts
2const BASE_URL = process.env.PRESTASHOP_BASE_URL;
3const API_KEY = process.env.PRESTASHOP_API_KEY;
4
5// Basic auth: key as username, empty string as password
6const authHeader = `Basic ${Buffer.from(`${API_KEY}:`).toString('base64')}`;
7
8interface PrestaShopRequestOptions {
9  method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
10  body?: unknown;
11  params?: Record<string, string>;
12}
13
14export async function prestashopApi<T>(
15  path: string,
16  options: PrestaShopRequestOptions = {}
17): Promise<T> {
18  const url = new URL(`${BASE_URL}/api${path}`);
19  // CRITICAL: Always add output_format=JSON or PrestaShop returns XML
20  url.searchParams.set('output_format', 'JSON');
21  if (options.params) {
22    Object.entries(options.params).forEach(([k, v]) => url.searchParams.set(k, v));
23  }
24
25  const response = await fetch(url.toString(), {
26    method: options.method ?? 'GET',
27    headers: {
28      Authorization: authHeader,
29      'Content-Type': 'application/json',
30      Accept: 'application/json',
31    },
32    body: options.body ? JSON.stringify(options.body) : undefined,
33  });
34
35  if (!response.ok) {
36    const errorText = await response.text();
37    throw new Error(`PrestaShop API ${response.status}: ${errorText}`);
38  }
39
40  return response.json() as Promise<T>;
41}

1// app/api/products/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { prestashopApi } from '@/lib/prestashop';
4
5interface PSProductName { id: string; value: string; }
6interface PSProductImage { id: string; }
7
8interface PSProduct {
9  id: number;
10  name: PSProductName[] | string;
11  description_short: PSProductName[] | string;
12  price: string;
13  associations?: { images?: { id: string }[] };
14}
15
16interface PSProductsResponse {
17  products: PSProduct[];
18}
19
20function extractLangValue(field: PSProductName[] | string, langId = '1'): string {
21  if (typeof field === 'string') return field;
22  return field.find((f) => f.id === langId)?.value ?? field[0]?.value ?? '';
23}
24
25export async function GET(request: NextRequest) {
26  const page = parseInt(request.nextUrl.searchParams.get('page') ?? '1', 10);
27  const limit = 24;
28  const offset = (page - 1) * limit;
29  const baseUrl = process.env.PRESTASHOP_BASE_URL;
30
31  try {
32    const data = await prestashopApi<PSProductsResponse>('/products', {
33      params: {
34        display: 'full',
35        limit: String(limit),
36        offset: String(offset),
37        'filter[active]': '1',
38        sort: '[date_add_DESC]',
39      },
40    });
41
42    const products = (data.products ?? []).map((p) => {
43      const firstImageId = p.associations?.images?.[0]?.id;
44      return {
45        id: p.id,
46        name: extractLangValue(p.name),
47        description: extractLangValue(p.description_short),
48        price: parseFloat(p.price),
49        imageUrl: firstImageId
50          ? `${baseUrl}/api/images/products/${p.id}/${firstImageId}`
51          : null,
52      };
53    });
54
55    return NextResponse.json({ products });
56  } catch (error) {
57    return NextResponse.json({ error: 'Failed to fetch products' }, { status: 500 });
58  }
59}

1// app/api/orders/route.ts
2import { NextRequest, NextResponse } from 'next/server';
3import { prestashopApi } from '@/lib/prestashop';
4
5interface PSOrder {
6  id: number;
7  reference: string;
8  id_customer: string;
9  total_paid_tax_incl: string;
10  current_state: string;
11  date_add: string;
12  valid: string;
13}
14
15interface PSOrdersResponse {
16  orders: PSOrder[];
17}
18
19export async function GET(request: NextRequest) {
20  const statusFilter = request.nextUrl.searchParams.get('state');
21
22  const params: Record<string, string> = {
23    display: 'full',
24    limit: '30',
25    sort: '[date_add_DESC]',
26  };
27
28  if (statusFilter) {
29    params['filter[current_state]'] = statusFilter;
30  }
31
32  try {
33    const data = await prestashopApi<PSOrdersResponse>('/orders', { params });
34
35    const orders = (data.orders ?? []).map((o) => ({
36      id: o.id,
37      reference: o.reference,
38      customerId: o.id_customer,
39      total: parseFloat(o.total_paid_tax_incl),
40      statusId: parseInt(o.current_state, 10),
41      date: o.date_add,
42    }));
43
44    return NextResponse.json({ orders });
45  } catch (error) {
46    return NextResponse.json({ error: 'Failed to fetch orders' }, { status: 500 });
47  }
48}

1// app/api/webhooks/prestashop/route.ts
2// Works only after deployment to Netlify or Bolt Cloud
3// (Bolt's WebContainer has no public URL for incoming traffic)
4import { NextRequest, NextResponse } from 'next/server';
5
6interface PrestaShopWebhookPayload {
7  event: string;
8  id_order?: number;
9  id_order_state?: number;
10  reference?: string;
11  total?: number;
12  [key: string]: unknown;
13}
14
15export async function POST(request: NextRequest) {
16  const payload: PrestaShopWebhookPayload = await request.json();
17
18  switch (payload.event) {
19    case 'order_add':
20      console.log(`New PrestaShop order #${payload.reference} (ID: ${payload.id_order}), total: ${payload.total}`);
21      // TODO: send confirmation email, update inventory, notify fulfillment
22      break;
23
24    case 'order_status_update':
25      console.log(`Order #${payload.id_order} status updated to state ${payload.id_order_state}`);
26      // TODO: notify customer, update tracking
27      break;
28
29    default:
30      console.log(`Unhandled PrestaShop webhook event: ${payload.event}`, payload);
31  }
32
33  // Always return 200 quickly — webhook modules retry on non-200 responses
34  return NextResponse.json({ received: true });
35}