@jazzdev/dpd-local-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1106 @@
+// src/config/index.ts
+var DPD_API = {
+  BASE_URL: "https://api.dpdlocal.co.uk",
+  ENDPOINTS: {
+    AUTH: "/user/?action=login",
+    SHIPMENT: "/shipping/shipment",
+    LABEL: "/shipping/shipment",
+    // Will append /{shipmentId}/label/
+    TRACKING: "/shipping/network/"
+    // Note: Address validation uses postcodes.io API instead of DPD
+  },
+  TIMEOUT: 3e4,
+  // 30 seconds
+  RETRY_ATTEMPTS: 3,
+  RETRY_DELAY: 1e3
+  // 1 second
+};
+var SERVICE_NAMES = {
+  "12": "Next Day Delivery",
+  "07": "By 12 PM Delivery"
+};
+var SERVICE_DESCRIPTIONS = {
+  "12": "Standard next day delivery - most affordable option",
+  "07": "Premium delivery by 12 PM the next day"
+};
+function createDPDConfig(options) {
+  const defaultPricing = {
+    freeDeliveryThreshold: 60,
+    // £60
+    flatDeliveryFee: 6,
+    // £6.00
+    minimumOrderValue: 25,
+    // £25
+    services: {
+      "12": {
+        // Next Day
+        basePrice: 6,
+        perKgPrice: 0.3,
+        customerPrice: 6
+      },
+      "07": {
+        // By 12
+        basePrice: 7,
+        perKgPrice: 0.42,
+        customerPrice: 7
+      }
+    }
+  };
+  const defaultServices = {
+    enabled: ["12", "07"],
+    default: "12"
+  };
+  const defaultLabels = {
+    format: "thermal",
+    printer: {
+      model: "TSC-DA210",
+      dpi: 203,
+      speed: 6,
+      connection: "USB"
+    }
+  };
+  const defaultNotifications = {
+    email: {
+      enabled: true,
+      provider: "resend",
+      fromEmail: options.notifications?.email?.fromEmail || "",
+      adminEmail: options.notifications?.email?.adminEmail || ""
+    },
+    sms: {
+      enabled: true,
+      provider: "dpd"
+    }
+  };
+  return {
+    credentials: options.credentials,
+    business: options.business,
+    services: {
+      ...defaultServices,
+      ...options.services
+    },
+    pricing: {
+      ...defaultPricing,
+      ...options.pricing,
+      services: {
+        ...defaultPricing.services,
+        ...options.pricing?.services
+      }
+    },
+    labels: {
+      ...defaultLabels,
+      ...options.labels
+    },
+    notifications: {
+      ...defaultNotifications,
+      ...options.notifications
+    },
+    testMode: options.testMode ?? process.env.NODE_ENV !== "production"
+  };
+}
+var calculateDeliveryFee = (subtotal, service = "12", config2) => {
+  if (subtotal >= config2.pricing.freeDeliveryThreshold) {
+    return 0;
+  }
+  return config2.pricing.services[service]?.customerPrice || config2.pricing.flatDeliveryFee;
+};
+var calculateDPDCost = (weight, service, config2) => {
+  const serviceConfig = config2.pricing.services[service];
+  if (!serviceConfig) {
+    throw new Error(`Invalid service code: ${service}`);
+  }
+  const basePrice = serviceConfig.basePrice;
+  const weightCharge = weight * serviceConfig.perKgPrice;
+  return basePrice + weightCharge;
+};
+var qualifiesForFreeDelivery = (subtotal, config2) => {
+  return subtotal >= config2.pricing.freeDeliveryThreshold;
+};
+var meetsMinimumOrderValue = (subtotal, config2) => {
+  return subtotal >= config2.pricing.minimumOrderValue;
+};
+var getNextCollectionDate = () => {
+  const now = /* @__PURE__ */ new Date();
+  const collectionDate = new Date(now);
+  if (collectionDate.getDay() === 0) {
+    collectionDate.setDate(collectionDate.getDate() + 1);
+  }
+  return collectionDate.toISOString().split("T")[0];
+};
+var getEstimatedDeliveryDate = (_service, collectionDate) => {
+  const collection = collectionDate ? new Date(collectionDate) : /* @__PURE__ */ new Date();
+  const delivery = new Date(collection);
+  delivery.setDate(delivery.getDate() + 1);
+  if (delivery.getDay() === 0) {
+    delivery.setDate(delivery.getDate() + 1);
+  }
+  return delivery.toISOString().split("T")[0];
+};
+var getTrackingUrl = (parcelNumber) => {
+  return `https://track.dpdlocal.co.uk/?parcelNumber=${parcelNumber}`;
+};
+var isValidServiceCode = (code, config2) => {
+  return config2.services.enabled.includes(code);
+};
+var getServiceName = (code) => {
+  return SERVICE_NAMES[code] || code;
+};
+var getServiceDescription = (code) => {
+  return SERVICE_DESCRIPTIONS[code] || "";
+};
+
+// src/lib/auth.ts
+var tokenCache = {
+  geoSession: null,
+  expiry: null
+};
+async function authenticate(credentials) {
+  const { username, password } = credentials;
+  const authHeader = Buffer.from(`${username}:${password}`).toString("base64");
+  const response = await fetch(`${DPD_API.BASE_URL}${DPD_API.ENDPOINTS.AUTH}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `Basic ${authHeader}`
+    },
+    signal: AbortSignal.timeout(DPD_API.TIMEOUT)
+  });
+  const raw = await response.text();
+  let payload;
+  try {
+    payload = raw ? JSON.parse(raw) : null;
+  } catch {
+    if (!response.ok) {
+      throw new Error(`Authentication failed: ${raw || response.statusText}`);
+    }
+    throw new Error("Invalid JSON response from DPD API");
+  }
+  if (!response.ok) {
+    throw new Error(
+      payload?.error?.errorMessage ?? `Authentication failed: ${response.status} ${response.statusText}`
+    );
+  }
+  if (payload?.error) {
+    throw new Error(payload.error.errorMessage ?? "Authentication failed");
+  }
+  const geoSession = payload?.data?.geoSession;
+  if (!geoSession) {
+    throw new Error("No GeoSession token received from DPD");
+  }
+  tokenCache.geoSession = geoSession;
+  tokenCache.expiry = new Date(Date.now() + 90 * 60 * 1e3);
+  return geoSession;
+}
+async function getGeoSession(credentials, forceRefresh = false) {
+  if (!forceRefresh && tokenCache.geoSession && tokenCache.expiry && tokenCache.expiry > /* @__PURE__ */ new Date()) {
+    return tokenCache.geoSession;
+  }
+  return await authenticate(credentials);
+}
+function clearGeoSession() {
+  tokenCache.geoSession = null;
+  tokenCache.expiry = null;
+}
+function hasValidToken() {
+  return !!(tokenCache.geoSession && tokenCache.expiry && tokenCache.expiry > /* @__PURE__ */ new Date());
+}
+function getTokenExpiry() {
+  return tokenCache.expiry;
+}
+async function authenticatedRequest(credentials, options) {
+  const {
+    method,
+    endpoint,
+    body,
+    headers = {},
+    retry = true,
+    retryAttempts = DPD_API.RETRY_ATTEMPTS
+  } = options;
+  let lastError = null;
+  for (let attempt = 0; attempt < retryAttempts; attempt++) {
+    try {
+      const geoSession = await getGeoSession(credentials, attempt > 0);
+      const url = endpoint.startsWith("http") ? endpoint : `${DPD_API.BASE_URL}${endpoint}`;
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          GeoSession: geoSession,
+          ...headers
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: AbortSignal.timeout(DPD_API.TIMEOUT)
+      });
+      const raw = await response.text();
+      const acceptHeader = headers.Accept || headers.accept;
+      const isLabelRequest = acceptHeader === "text/vnd.citizen-clp" || acceptHeader === "text/vnd.eltron-epl" || acceptHeader === "text/html";
+      let data = null;
+      if (isLabelRequest) {
+        if (!response.ok) {
+          throw new Error(
+            `Label request failed: ${response.status} ${response.statusText}`
+          );
+        }
+        return raw;
+      }
+      try {
+        data = raw ? JSON.parse(raw) : null;
+      } catch {
+        if (!response.ok) {
+          throw new Error(raw || response.statusText);
+        }
+        throw new Error("Invalid JSON response from DPD API");
+      }
+      const hasData = data?.data && Object.keys(data.data).length > 0;
+      const hasError = data?.error;
+      if (!response.ok || hasError && !hasData) {
+        if (hasError) {
+          console.error(`
+\u274C DPD API Error Response:`);
+          console.error(
+            `   HTTP Status: ${response.status} ${response.statusText}`
+          );
+          console.error(
+            `   Error Object:`,
+            JSON.stringify(data.error, null, 2)
+          );
+          console.error(`   Full Response:`, JSON.stringify(data, null, 2));
+        }
+        if (response.status === 401 && retry && attempt < retryAttempts - 1) {
+          clearGeoSession();
+          await delay(DPD_API.RETRY_DELAY * (attempt + 1));
+          continue;
+        }
+        throw new Error(
+          data?.error?.errorMessage ?? data?.error?.errorAction ?? data?.error?.obj ?? JSON.stringify(data?.error) ?? `Request failed: ${response.statusText}`
+        );
+      }
+      if (hasError && hasData) {
+        console.warn(`
+\u26A0\uFE0F DPD API Warning (data was still returned):`);
+        console.warn(`   Warning:`, JSON.stringify(data.error, null, 2));
+        console.warn(`   Data returned successfully despite warning`);
+      }
+      return data;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error("Unknown error");
+      if (!retry || attempt >= retryAttempts - 1) {
+        throw lastError;
+      }
+      await delay(DPD_API.RETRY_DELAY * (attempt + 1));
+    }
+  }
+  throw lastError ?? new Error("Request failed after retries");
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function testConnection(credentials) {
+  try {
+    clearGeoSession();
+    const geoSession = await authenticate(credentials);
+    if (!geoSession) {
+      return {
+        success: false,
+        message: "Authentication succeeded but no token received"
+      };
+    }
+    return {
+      success: true,
+      message: "Successfully connected to DPD API"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : "Failed to connect to DPD API"
+    };
+  }
+}
+
+// src/lib/shipment.ts
+async function createShipment(credentials, params, businessConfig) {
+  try {
+    const {
+      orderId,
+      orderRef,
+      service,
+      deliveryAddress,
+      totalWeight,
+      numberOfParcels,
+      customerEmail,
+      customerPhone,
+      deliveryInstructions,
+      collectionDate
+    } = params;
+    const weightPerParcel = totalWeight / numberOfParcels;
+    const parcels = Array.from(
+      { length: numberOfParcels },
+      () => ({
+        weight: parseFloat(weightPerParcel.toFixed(2))
+      })
+    );
+    const consignment = {
+      consignmentNumber: null,
+      consignmentRef: orderRef,
+      parcel: parcels,
+      collectionDetails: {
+        address: businessConfig.collectionAddress,
+        contactDetails: {
+          name: businessConfig.contactName,
+          telephone: businessConfig.contactPhone,
+          email: businessConfig.contactEmail
+        }
+      },
+      deliveryDetails: {
+        address: {
+          organisation: deliveryAddress.organisation || "",
+          property: deliveryAddress.property,
+          street: deliveryAddress.street,
+          locality: deliveryAddress.locality || "",
+          town: deliveryAddress.town,
+          county: deliveryAddress.county || "",
+          postcode: deliveryAddress.postcode,
+          countryCode: deliveryAddress.countryCode
+        },
+        contactDetails: {
+          name: deliveryAddress.contactName,
+          telephone: deliveryAddress.contactPhone,
+          email: customerEmail
+        },
+        notificationDetails: {
+          email: customerEmail,
+          mobile: customerPhone
+        }
+      },
+      networkCode: service,
+      numberOfParcels,
+      totalWeight: parseFloat(totalWeight.toFixed(2)),
+      shippingRef1: orderId,
+      shippingRef2: orderRef,
+      shippingRef3: `FJ-${Date.now()}`,
+      // Unique reference
+      deliveryInstructions: deliveryInstructions || void 0,
+      liability: false
+    };
+    const shipmentRequest = {
+      jobId: null,
+      collectionOnDelivery: false,
+      invoice: null,
+      collectionDate: collectionDate || getNextCollectionDate(),
+      consolidate: false,
+      consignment: [consignment]
+    };
+    const response = await authenticatedRequest(
+      credentials,
+      {
+        method: "POST",
+        endpoint: DPD_API.ENDPOINTS.SHIPMENT,
+        body: shipmentRequest
+      }
+    );
+    const responseData = response.data;
+    const shipmentId = responseData?.shipmentId;
+    const consignmentNumber = responseData?.consignment?.[0]?.consignmentNumber || responseData?.consignmentDetail?.[0]?.consignmentNumber;
+    const parcelNumbers = responseData?.consignment?.[0]?.parcelNumbers || responseData?.consignmentDetail?.[0]?.parcelNumbers;
+    const parcelNumber = parcelNumbers?.[0];
+    if (!consignmentNumber || !shipmentId || !parcelNumber) {
+      return {
+        success: false,
+        error: `Missing required data: ${!shipmentId ? "shipmentId" : !consignmentNumber ? "consignmentNumber" : "parcelNumber"}`,
+        errorCode: "INCOMPLETE_RESPONSE"
+      };
+    }
+    const trackingUrl = getTrackingUrl(parcelNumber);
+    return {
+      success: true,
+      shipmentId,
+      consignmentNumber,
+      parcelNumber,
+      trackingUrl
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      errorCode: "SHIPMENT_CREATION_FAILED"
+    };
+  }
+}
+async function generateLabel(credentials, params) {
+  try {
+    const { shipmentId, format } = params;
+    const contentType = format === "thermal" ? "text/vnd.citizen-clp" : "text/html";
+    const endpoint = `${DPD_API.ENDPOINTS.LABEL}/${shipmentId}/label/`;
+    const response = await authenticatedRequest(credentials, {
+      method: "GET",
+      endpoint,
+      headers: {
+        Accept: contentType
+      }
+    });
+    if (!response || typeof response === "object" && !response.data) {
+      return {
+        success: false,
+        error: "No label data received from DPD"
+      };
+    }
+    return {
+      success: true,
+      labelData: typeof response === "string" ? response : response.data
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function validateAddress(_credentials, params) {
+  try {
+    const { postcode, town } = params;
+    const cleanPostcode = postcode.replace(/\s/g, "").toUpperCase();
+    const postcodeRegex = /^[A-Z]{1,2}\d{1,2}[A-Z]?\d[A-Z]{2}$/;
+    if (!postcodeRegex.test(cleanPostcode)) {
+      return {
+        valid: false,
+        serviceable: false,
+        message: "Invalid UK postcode format"
+      };
+    }
+    const response = await fetch(
+      `https://api.postcodes.io/postcodes/${encodeURIComponent(cleanPostcode)}`
+    );
+    if (!response.ok) {
+      if (response.status === 404) {
+        return {
+          valid: false,
+          serviceable: false,
+          message: "Postcode not found in UK database"
+        };
+      }
+      throw new Error(`Postcode lookup failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.result) {
+      return {
+        valid: false,
+        serviceable: false,
+        message: "Invalid postcode"
+      };
+    }
+    const country = data.result.country;
+    const serviceable = ["England", "Wales", "Scotland"].includes(country);
+    const returnedTown = data.result.admin_district || data.result.parish || "";
+    const townMatch = town ? returnedTown.toLowerCase().includes(town.toLowerCase()) || town.toLowerCase().includes(returnedTown.toLowerCase()) : true;
+    if (!townMatch) {
+      return {
+        valid: true,
+        serviceable,
+        message: `Postcode valid but town mismatch. Expected: ${returnedTown}`
+      };
+    }
+    return {
+      valid: true,
+      serviceable,
+      message: serviceable ? "Address is valid and serviceable by DPD" : `Address is valid but may not be serviceable by DPD (${country})`
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      serviceable: false,
+      message: error instanceof Error ? error.message : "Address validation failed"
+    };
+  }
+}
+async function trackShipment(credentials, params) {
+  try {
+    const { consignmentNumber } = params;
+    const response = await authenticatedRequest(
+      credentials,
+      {
+        method: "GET",
+        endpoint: `${DPD_API.ENDPOINTS.TRACKING}${consignmentNumber}`
+      }
+    );
+    if (!response.data) {
+      return {
+        success: false,
+        error: "No tracking data available"
+      };
+    }
+    const status = mapDPDStatus(response.data.status ?? "UNKNOWN");
+    const statusHistory = response.data.history ? response.data.history.map(
+      (event) => ({
+        status: mapDPDStatus(event.status),
+        timestamp: new Date(event.timestamp).toISOString(),
+        message: event.message,
+        location: event.location
+      })
+    ) : void 0;
+    return {
+      success: true,
+      status,
+      statusHistory,
+      estimatedDelivery: response.data.estimatedDelivery,
+      actualDelivery: response.data.actualDelivery
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Tracking failed"
+    };
+  }
+}
+function mapDPDStatus(dpdStatus) {
+  const statusMap = {
+    CREATED: "created",
+    "LABEL GENERATED": "label_generated",
+    COLLECTED: "collected",
+    "IN TRANSIT": "in_transit",
+    "OUT FOR DELIVERY": "out_for_delivery",
+    DELIVERED: "delivered",
+    FAILED: "failed",
+    CANCELLED: "cancelled"
+  };
+  return statusMap[dpdStatus.toUpperCase()] || "created";
+}
+function calculateParcels(totalWeight) {
+  const MAX_PARCEL_WEIGHT = 30;
+  if (totalWeight <= MAX_PARCEL_WEIGHT) {
+    return 1;
+  }
+  return Math.ceil(totalWeight / MAX_PARCEL_WEIGHT);
+}
+function validateServiceCode(code) {
+  return code === "12" || code === "07";
+}
+function generateConsignmentRef(orderId) {
+  const timestamp = Date.now().toString(36).toUpperCase();
+  const random = Math.random().toString(36).substring(2, 6).toUpperCase();
+  return `FJ-${orderId}-${timestamp}${random}`;
+}
+
+// src/lib/dpd-service.ts
+async function createCompleteShipment(orderId, params, config2, dbAdapter, storageAdapter) {
+  try {
+    const shipmentResult = await createShipment(
+      config2.credentials,
+      { orderId, ...params },
+      config2.business
+    );
+    if (!shipmentResult.success || !shipmentResult.consignmentNumber || !shipmentResult.shipmentId || !shipmentResult.parcelNumber) {
+      return shipmentResult;
+    }
+    const labelResult = await generateAndUploadLabel(
+      shipmentResult.shipmentId,
+      shipmentResult.consignmentNumber,
+      "thermal",
+      config2.credentials,
+      storageAdapter
+    );
+    if (!labelResult.success || !labelResult.labelUrl) {
+      return {
+        ...shipmentResult,
+        error: `Shipment created but label generation failed: ${labelResult.error}`
+      };
+    }
+    const dpdCost = calculateDPDCost(params.totalWeight, params.service, config2);
+    const customerCharge = calculateDeliveryFee(0, params.service, config2);
+    const now = /* @__PURE__ */ new Date();
+    const shippingData = {
+      provider: "dpd",
+      service: params.service,
+      shipmentId: shipmentResult.shipmentId,
+      consignmentNumber: shipmentResult.consignmentNumber,
+      parcelNumber: shipmentResult.parcelNumber,
+      trackingUrl: `https://www.dpdlocal.co.uk/service/tracking?parcel=${shipmentResult.parcelNumber}`,
+      labelUrl: labelResult.labelUrl,
+      status: "label_generated",
+      statusHistory: [
+        {
+          status: "created",
+          timestamp: now,
+          message: "Shipment created with DPD"
+        },
+        {
+          status: "label_generated",
+          timestamp: now,
+          message: "Shipping label generated"
+        }
+      ],
+      cost: {
+        basePrice: dpdCost,
+        weightCharge: params.totalWeight * 0.3,
+        totalCost: dpdCost,
+        customerCharge
+      },
+      weight: {
+        total: params.totalWeight,
+        unit: "kg"
+      },
+      parcels: params.numberOfParcels,
+      collectionDate: params.collectionDate || getNextCollectionDate(),
+      estimatedDelivery: getEstimatedDeliveryDate(
+        params.service,
+        params.collectionDate
+      ),
+      createdAt: now,
+      updatedAt: now
+    };
+    try {
+      await dbAdapter.updateOrder(orderId, {
+        shipping: shippingData
+      });
+    } catch (updateError) {
+      console.error(
+        `\u274C CRITICAL: Failed to update order ${orderId} with shipping data!`
+      );
+      console.error(`   Error:`, updateError);
+      throw new Error(
+        `Shipment created but failed to update order: ${updateError instanceof Error ? updateError.message : "Unknown error"}`
+      );
+    }
+    return {
+      success: true,
+      consignmentNumber: shipmentResult.consignmentNumber,
+      trackingUrl: shipmentResult.trackingUrl,
+      labelUrl: labelResult.labelUrl
+    };
+  } catch (error) {
+    console.error(`
+\u{1F4A5} Complete shipment creation failed:`, error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      errorCode: "COMPLETE_SHIPMENT_FAILED"
+    };
+  }
+}
+async function generateAndUploadLabel(shipmentId, consignmentNumber, format = "thermal", credentials, storageAdapter) {
+  try {
+    const labelResult = await generateLabel(credentials, {
+      shipmentId,
+      format
+    });
+    if (!labelResult.success || !labelResult.labelData) {
+      return labelResult;
+    }
+    const timestamp = Date.now();
+    const extension = format === "thermal" ? "txt" : "html";
+    const fileName = `${consignmentNumber}-${timestamp}.${extension}`;
+    const labelUrl = await storageAdapter.uploadLabel(
+      labelResult.labelData,
+      fileName
+    );
+    return {
+      success: true,
+      labelUrl,
+      labelData: labelResult.labelData
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function validateDeliveryAddress(params, credentials) {
+  return await validateAddress(credentials, params);
+}
+async function saveAddress(userId, address, credentials, dbAdapter) {
+  const validation = await validateAddress(credentials, {
+    postcode: address.postcode,
+    town: address.town
+  });
+  const now = /* @__PURE__ */ new Date();
+  const addressData = {
+    ...address,
+    userId,
+    validated: validation.valid,
+    validatedAt: validation.valid ? now : void 0,
+    createdAt: now,
+    updatedAt: now
+  };
+  return await dbAdapter.createSavedAddress(addressData);
+}
+async function getSavedAddresses(userId, dbAdapter) {
+  return await dbAdapter.getSavedAddresses(userId);
+}
+async function getSavedAddress(addressId, dbAdapter) {
+  return await dbAdapter.getSavedAddress(addressId);
+}
+async function updateSavedAddress(addressId, data, dbAdapter) {
+  return await dbAdapter.updateSavedAddress(addressId, data);
+}
+async function deleteSavedAddress(addressId, dbAdapter) {
+  return await dbAdapter.deleteSavedAddress(addressId);
+}
+async function getLabelUrl(consignmentNumber, storageAdapter) {
+  try {
+    const fileName = `${consignmentNumber}`;
+    return await storageAdapter.getLabel(fileName);
+  } catch (error) {
+    console.error("Error getting label URL:", error);
+    return null;
+  }
+}
+async function regenerateLabel(shipmentId, consignmentNumber, format = "thermal", credentials, storageAdapter) {
+  return await generateAndUploadLabel(
+    shipmentId,
+    consignmentNumber,
+    format,
+    credentials,
+    storageAdapter
+  );
+}
+async function testDPDConnection(credentials) {
+  return await testConnection(credentials);
+}
+async function getAuthStatus(credentials) {
+  try {
+    const geoSession = await getGeoSession(credentials);
+    return {
+      authenticated: !!geoSession,
+      expiresAt: null
+    };
+  } catch (_error) {
+    return {
+      authenticated: false
+    };
+  }
+}
+var dpd_service_default = {
+  createCompleteShipment,
+  generateAndUploadLabel,
+  validateDeliveryAddress,
+  saveAddress,
+  getSavedAddresses,
+  getSavedAddress,
+  updateSavedAddress,
+  deleteSavedAddress,
+  getLabelUrl,
+  regenerateLabel,
+  testDPDConnection,
+  getAuthStatus
+};
+
+// src/utils/encryption.ts
+import crypto from "crypto";
+var ALGORITHM = "aes-256-gcm";
+var KEY_LENGTH = 32;
+var IV_LENGTH = 16;
+var SALT_LENGTH = 64;
+var TAG_LENGTH = 16;
+var TAG_POSITION = SALT_LENGTH + IV_LENGTH;
+var ENCRYPTED_POSITION = TAG_POSITION + TAG_LENGTH;
+function getEncryptionKey() {
+  const envKey = process.env.DPD_ENCRYPTION_KEY;
+  if (envKey) {
+    return Buffer.from(envKey, "hex");
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.warn(
+      "\u26A0\uFE0F  Using default encryption key. Set DPD_ENCRYPTION_KEY in production!"
+    );
+    return crypto.scryptSync("dpd-dev-key", "salt", KEY_LENGTH);
+  }
+  throw new Error(
+    "DPD_ENCRYPTION_KEY environment variable is required in production"
+  );
+}
+function generateEncryptionKey() {
+  const key = crypto.randomBytes(KEY_LENGTH);
+  return key.toString("hex");
+}
+function encrypt(text) {
+  try {
+    const salt = crypto.randomBytes(SALT_LENGTH);
+    const iv = crypto.randomBytes(IV_LENGTH);
+    const key = crypto.scryptSync(getEncryptionKey(), salt, KEY_LENGTH);
+    const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+    const encrypted = Buffer.concat([
+      cipher.update(text, "utf8"),
+      cipher.final()
+    ]);
+    const tag = cipher.getAuthTag();
+    const result = Buffer.concat([salt, iv, tag, encrypted]);
+    return result.toString("hex");
+  } catch (error) {
+    console.error("Encryption error:", error);
+    throw new Error("Failed to encrypt data");
+  }
+}
+function decrypt(encryptedHex) {
+  try {
+    const data = Buffer.from(encryptedHex, "hex");
+    const salt = data.subarray(0, SALT_LENGTH);
+    const iv = data.subarray(SALT_LENGTH, TAG_POSITION);
+    const tag = data.subarray(TAG_POSITION, ENCRYPTED_POSITION);
+    const encrypted = data.subarray(ENCRYPTED_POSITION);
+    const key = crypto.scryptSync(getEncryptionKey(), salt, KEY_LENGTH);
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(tag);
+    const decrypted = Buffer.concat([
+      decipher.update(encrypted),
+      decipher.final()
+    ]);
+    return decrypted.toString("utf8");
+  } catch (error) {
+    console.error("Decryption error:", error);
+    throw new Error("Failed to decrypt data");
+  }
+}
+function encryptCredentials(credentials) {
+  return {
+    accountNumber: credentials.accountNumber,
+    username: credentials.username,
+    passwordHash: encrypt(credentials.password)
+  };
+}
+function decryptCredentials(encryptedCredentials) {
+  return {
+    accountNumber: encryptedCredentials.accountNumber,
+    username: encryptedCredentials.username,
+    password: decrypt(encryptedCredentials.passwordHash)
+  };
+}
+function hash(data) {
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+function verifyHash(data, hashToVerify) {
+  const computed = hash(data);
+  return crypto.timingSafeEqual(
+    Buffer.from(computed),
+    Buffer.from(hashToVerify)
+  );
+}
+
+// src/utils/logger.ts
+var defaultConfig = {
+  enabled: true,
+  logToConsole: process.env.NODE_ENV !== "production",
+  logToDatabase: true
+};
+var config = { ...defaultConfig };
+function configureLogger(newConfig) {
+  config = { ...config, ...newConfig };
+}
+function setLoggerAdapter(adapter) {
+  config.adapter = adapter;
+}
+async function logOperation(params) {
+  if (!config.enabled) {
+    return;
+  }
+  const logData = {
+    orderId: params.orderId,
+    consignmentNumber: params.consignmentNumber,
+    operation: params.operation,
+    request: {
+      endpoint: sanitizeEndpoint(params.request.endpoint),
+      method: params.request.method,
+      headers: sanitizeHeaders(params.request.headers),
+      body: sanitizeBody(params.request.body)
+    },
+    response: {
+      status: params.response.status,
+      headers: sanitizeHeaders(params.response.headers),
+      body: sanitizeBody(params.response.body)
+    },
+    duration: params.duration,
+    success: params.success,
+    error: params.error,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (config.logToConsole) {
+    logToConsole(logData);
+  }
+  if (config.logToDatabase && config.adapter) {
+    try {
+      await config.adapter.createDPDLog(logData);
+    } catch (error) {
+      console.error("Failed to log to database:", error);
+    }
+  }
+}
+function startTimer() {
+  const start = Date.now();
+  return () => Date.now() - start;
+}
+async function loggedOperation(params, operation) {
+  const timer = startTimer();
+  try {
+    const result = await operation();
+    await logOperation({
+      orderId: params.orderId,
+      consignmentNumber: params.consignmentNumber,
+      operation: params.operation,
+      request: {
+        endpoint: params.endpoint,
+        method: params.method,
+        body: params.requestBody
+      },
+      response: {
+        status: result.status,
+        headers: result.headers,
+        body: result.data
+      },
+      duration: timer(),
+      success: true
+    });
+    return result.data;
+  } catch (error) {
+    const errorInfo = {
+      code: error instanceof Error ? error.name : "UNKNOWN_ERROR",
+      message: error instanceof Error ? error.message : "Unknown error",
+      stack: error instanceof Error ? error.stack : void 0
+    };
+    await logOperation({
+      orderId: params.orderId,
+      consignmentNumber: params.consignmentNumber,
+      operation: params.operation,
+      request: {
+        endpoint: params.endpoint,
+        method: params.method,
+        body: params.requestBody
+      },
+      response: {
+        status: 500,
+        body: errorInfo
+      },
+      duration: timer(),
+      success: false,
+      error: errorInfo
+    });
+    throw error;
+  }
+}
+function sanitizeEndpoint(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    url.searchParams.delete("password");
+    url.searchParams.delete("token");
+    url.searchParams.delete("key");
+    return url.toString();
+  } catch {
+    return endpoint;
+  }
+}
+function sanitizeHeaders(headers) {
+  if (!headers) {
+    return void 0;
+  }
+  const sanitized = { ...headers };
+  delete sanitized.Authorization;
+  delete sanitized.authorization;
+  delete sanitized.GeoSession;
+  delete sanitized["Set-Cookie"];
+  delete sanitized["set-cookie"];
+  return sanitized;
+}
+function sanitizeBody(body) {
+  if (!body) {
+    return void 0;
+  }
+  let sanitized = JSON.parse(JSON.stringify(body));
+  if (typeof sanitized === "object") {
+    delete sanitized.password;
+    delete sanitized.passwordHash;
+    delete sanitized.token;
+    delete sanitized.geoSession;
+  }
+  let stringified = JSON.stringify(sanitized);
+  const MAX_SIZE = 1e4;
+  if (stringified.length > MAX_SIZE) {
+    stringified = stringified.substring(0, MAX_SIZE) + "... [truncated]";
+    sanitized = stringified;
+  }
+  return sanitized;
+}
+function logToConsole(logData) {
+  const color = logData.success ? "\x1B[32m" : "\x1B[31m";
+  const reset = "\x1B[0m";
+  const bold = "\x1B[1m";
+  console.log("\n" + "=".repeat(80));
+  console.log(
+    `${bold}DPD ${logData.operation.toUpperCase()}${reset} - ${logData.success ? `${color}SUCCESS${reset}` : `${color}FAILED${reset}`}`
+  );
+  console.log("=".repeat(80));
+  console.log(`Order ID: ${logData.orderId}`);
+  if (logData.consignmentNumber) {
+    console.log(`Consignment: ${logData.consignmentNumber}`);
+  }
+  console.log(`Request: ${logData.request.method} ${logData.request.endpoint}`);
+  console.log(`Duration: ${logData.duration}ms`);
+  console.log(`Status: ${logData.response.status}`);
+  if (!logData.success && logData.error) {
+    console.log(`${color}Error: ${logData.error.message}${reset}`);
+  }
+  console.log("=".repeat(80) + "\n");
+}
+export {
+  dpd_service_default as DPDService,
+  DPD_API,
+  SERVICE_DESCRIPTIONS,
+  SERVICE_NAMES,
+  authenticate,
+  authenticatedRequest,
+  calculateDPDCost,
+  calculateDeliveryFee,
+  calculateParcels,
+  clearGeoSession,
+  configureLogger,
+  createCompleteShipment,
+  createDPDConfig,
+  createShipment,
+  decrypt,
+  decryptCredentials,
+  deleteSavedAddress,
+  encrypt,
+  encryptCredentials,
+  generateAndUploadLabel,
+  generateConsignmentRef,
+  generateEncryptionKey,
+  generateLabel,
+  getAuthStatus,
+  getEstimatedDeliveryDate,
+  getGeoSession,
+  getLabelUrl,
+  getNextCollectionDate,
+  getSavedAddress,
+  getSavedAddresses,
+  getServiceDescription,
+  getServiceName,
+  getTokenExpiry,
+  getTrackingUrl,
+  hasValidToken,
+  hash,
+  isValidServiceCode,
+  logOperation,
+  loggedOperation,
+  meetsMinimumOrderValue,
+  qualifiesForFreeDelivery,
+  regenerateLabel,
+  saveAddress,
+  setLoggerAdapter,
+  startTimer,
+  testConnection,
+  testDPDConnection,
+  trackShipment,
+  updateSavedAddress,
+  validateAddress,
+  validateDeliveryAddress,
+  validateServiceCode,
+  verifyHash
+};
+/**
+ * DPD Local SDK
+ *
+ * TypeScript SDK for integrating DPD Local shipping services
+ * Database-agnostic and framework-independent
+ *
+ * @package @your-org/dpd-local-sdk
+ * @version 1.0.0
+ * @author Your Name
+ * @license MIT
+ */