shipflow 0.1.0

package/dist/carriers/aymakan/index.js

@@ -0,0 +1,625 @@
+import {
+  APIError,
+  BaseCarrierAdapter,
+  HttpClient,
+  UnsupportedOperationError,
+  ValidationError,
+  WebhookVerificationError,
+  validateCreateShipmentInput,
+  validatePickupRequest
+} from "../../index-x8sk1kw9.js";
+
+// src/carriers/aymakan/services.ts
+var AymakanService = {
+  ECOMMERCE: "ONP",
+  DOCUMENTS: "DOC",
+  SAME_DAY: "SDD",
+  REVERSE_PICKUP: "RVP",
+  EXCHANGE: "EXH",
+  LOCKERS: "LOC",
+  HEAVY: "BLK",
+  PALLET: "PLT",
+  IMPORT_EXPRESS: "IPX",
+  EXPORT_EXPRESS: "EPX"
+};
+var AymakanStatusCodes = {
+  "AY-0001": "created",
+  "AY-0002": "picked_up",
+  "AY-0003": "at_warehouse",
+  "AY-0004": "out_for_delivery",
+  "AY-0005": "delivered",
+  "AY-0006": "exception",
+  "AY-0026": "at_warehouse",
+  "AY-0027": "in_transit",
+  "AY-0028": "in_transit",
+  "AY-0032": "pending",
+  "AY-0007": "returned",
+  "AY-0008": "cancelled",
+  "AY-0009": "returned"
+};
+
+// src/carriers/aymakan/mappers.ts
+function mapAymakanStatus(statusCode) {
+  const mapped = AymakanStatusCodes[statusCode];
+  return mapped;
+}
+function mapNationalAddress(addr) {
+  if (!addr)
+    return;
+  return {
+    short_code: addr.shortCode,
+    building_number: addr.buildingNumber,
+    street_name: addr.streetName,
+    district: addr.district,
+    additional_number: addr.additionalNumber
+  };
+}
+function sanitizePhone(phone) {
+  return phone.replace(/\D/g, "");
+}
+var VALID_AYMAKAN_SERVICE_TYPES = new Set(Object.values(AymakanService));
+function resolveServiceType(serviceType) {
+  if (!serviceType)
+    return;
+  if (VALID_AYMAKAN_SERVICE_TYPES.has(serviceType))
+    return serviceType;
+  return;
+}
+function mapCreateShipmentRequest(input) {
+  const firstParcel = input.parcels[0];
+  const totalPieces = input.parcels.reduce((sum, p) => sum + p.pieces, 0);
+  const totalWeight = input.parcels.reduce((sum, p) => sum + (p.weight.unit === "lb" ? p.weight.value * 0.453592 : p.weight.value), 0);
+  const totalItems = input.parcels.reduce((sum, p) => sum + (p.itemsCount ?? p.pieces), 0);
+  return {
+    requested_by: input.options?.requestedBy ?? input.shipper.name,
+    declared_value: input.declaredValue?.amount ?? input.cod?.amount ?? 0,
+    declared_value_currency: input.declaredValue?.currency ?? input.cod?.currency ?? "SAR",
+    reference: input.reference,
+    customer_tracking: input.options?.customerTracking,
+    service_type: resolveServiceType(input.serviceType),
+    is_cod: input.cod?.enabled ? 1 : 0,
+    cod_amount: input.cod?.enabled ? input.cod.amount : undefined,
+    fulfilment_customer_name: input.options?.fulfilmentCustomerName,
+    currency: input.cod?.currency ?? "SAR",
+    delivery_name: input.consignee.name,
+    delivery_email: input.consignee.email,
+    delivery_city: input.consignee.city,
+    delivery_address: input.consignee.line1,
+    delivery_neighbourhood: input.consignee.neighbourhood ?? input.consignee.state,
+    delivery_postcode: input.consignee.postalCode,
+    delivery_country: input.consignee.countryCode,
+    delivery_phone: sanitizePhone(input.consignee.phone),
+    delivery_description: input.consignee.description,
+    delivery_national_address: mapNationalAddress(input.consignee.nationalAddress),
+    collection_name: input.shipper.company ?? input.shipper.name,
+    collection_email: input.shipper.email,
+    collection_city: input.shipper.city,
+    collection_address: input.shipper.line1,
+    collection_neighbourhood: input.shipper.neighbourhood ?? input.shipper.state,
+    collection_postcode: input.shipper.postalCode,
+    collection_country: input.shipper.countryCode,
+    collection_phone: sanitizePhone(input.shipper.phone),
+    collection_description: input.shipper.description,
+    collection_national_address: mapNationalAddress(input.shipper.nationalAddress),
+    weight: totalWeight,
+    length: firstParcel?.dimensions?.length,
+    width: firstParcel?.dimensions?.width,
+    height: firstParcel?.dimensions?.height,
+    pieces: totalPieces,
+    items_count: totalItems,
+    is_insured: input.options?.isInsured ? 1 : 0,
+    international_metadata: input.options?.internationalMetadata ? {
+      document_id: input.options.internationalMetadata.documentId,
+      tax_identification_number: input.options.internationalMetadata.taxId,
+      invoice_number: input.options.internationalMetadata.invoiceNumber,
+      invoice_date: input.options.internationalMetadata.invoiceDate
+    } : undefined
+  };
+}
+function mapPickupRequest(input) {
+  return {
+    reference: input.trackingNumbers?.[0],
+    pickup_date: input.date,
+    time_slot: input.timeSlot,
+    city: input.city,
+    contact_name: input.contactName,
+    contact_phone: input.contactPhone,
+    address: input.address,
+    shipments: input.shipmentCount
+  };
+}
+function mapCustomerAddressRequest(addr) {
+  return {
+    title: addr.title,
+    name: addr.name,
+    email: addr.email,
+    city: addr.city,
+    address: addr.address,
+    neighbourhood: addr.neighbourhood,
+    postcode: addr.postalCode ?? "",
+    phone: addr.phone,
+    description: addr.description ?? ""
+  };
+}
+function mapShipmentResponse(data) {
+  const codAmount = data.cod_amount != null ? typeof data.cod_amount === "string" ? parseFloat(data.cod_amount) : data.cod_amount : undefined;
+  return {
+    carrier: "aymakan",
+    trackingNumber: data.tracking_number,
+    customerTracking: data.customer_tracking ?? undefined,
+    reference: data.reference ?? undefined,
+    status: mapAymakanStatus(data.status) ?? "created",
+    statusLabel: data.status_label,
+    labelUrl: data.label || undefined,
+    pdfLabelUrl: data.pdf_label || undefined,
+    codAmount: codAmount && !Number.isNaN(codAmount) ? codAmount : undefined,
+    declaredValue: data.declared_value,
+    currency: data.currency,
+    createdAt: new Date(data.created_at),
+    raw: data
+  };
+}
+function mapTrackingEvent(event) {
+  return {
+    timestamp: new Date(event.created_at),
+    statusCode: event.status_code,
+    status: mapAymakanStatus(event.status_code) ?? "unknown",
+    description: event.description,
+    descriptionArabic: event.description_ar ?? undefined
+  };
+}
+function mapTrackingResult(data) {
+  return {
+    trackingNumber: data.tracking_number,
+    carrier: "aymakan",
+    reference: data.reference ?? undefined,
+    status: mapAymakanStatus(data.status) ?? "unknown",
+    statusLabel: data.status_label,
+    events: data.tracking_info.map(mapTrackingEvent),
+    deliveryDate: data.delivery_date ? new Date(data.delivery_date) : undefined,
+    pickupDate: data.pickup_date ? new Date(data.pickup_date) : undefined,
+    receivedAt: data.received_at ? new Date(data.received_at) : undefined,
+    codAmount: data.cod_amount ? Number.isNaN(parseFloat(data.cod_amount)) ? undefined : parseFloat(data.cod_amount) : undefined,
+    weight: Number.isNaN(parseFloat(data.weight)) ? undefined : parseFloat(data.weight),
+    pieces: data.pieces,
+    raw: data
+  };
+}
+function mapCity(city) {
+  return {
+    nameEn: city.city_en,
+    nameAr: city.city_ar
+  };
+}
+function mapPickupResponse(data) {
+  return {
+    id: data.id,
+    carrier: "aymakan",
+    status: ["pending", "processing", "completed", "cancelled"].includes(data.status) ? data.status : "pending",
+    date: data.pickup_date,
+    timeSlot: data.time_slot,
+    city: data.city,
+    contactName: data.contact_name,
+    contactPhone: data.contact_phone,
+    address: data.address,
+    shipmentCount: data.shipments,
+    warehouseId: data.warehouse_id,
+    warehouseName: data.warehouse_name,
+    createdAt: new Date(data.created_at),
+    raw: data
+  };
+}
+function timingSafeEqual(a, b) {
+  const encoder = new TextEncoder;
+  const bufA = encoder.encode(a);
+  const bufB = encoder.encode(b);
+  if (bufA.byteLength !== bufB.byteLength)
+    return false;
+  let mismatch = 0;
+  for (let i = 0;i < bufA.byteLength; i++) {
+    mismatch |= bufA[i] ^ bufB[i];
+  }
+  return mismatch === 0;
+}
+function parseAymakanWebhook(payload, options) {
+  const { headers = {}, queryParams = {}, config } = options ?? {};
+  if (!payload || typeof payload !== "object" || !("tracking_number" in payload) || !("status" in payload)) {
+    throw new ValidationError("Invalid webhook payload: missing required fields", {
+      raw: payload
+    });
+  }
+  const data = payload;
+  if (config?.authHeader && config?.authValue) {
+    const lowerKey = config.authHeader.toLowerCase();
+    const headerValue = Object.entries(headers).find(([k]) => k.toLowerCase() === lowerKey)?.[1];
+    if (!headerValue || !timingSafeEqual(headerValue, config.authValue)) {
+      throw new WebhookVerificationError("Invalid webhook auth header", {
+        carrier: "aymakan"
+      });
+    }
+  }
+  if (config?.authQueryParam && config?.authQueryValue) {
+    const paramValue = queryParams[config.authQueryParam];
+    if (!paramValue || !timingSafeEqual(paramValue, config.authQueryValue)) {
+      throw new WebhookVerificationError("Invalid webhook auth query param", {
+        carrier: "aymakan"
+      });
+    }
+  }
+  const eventType = data.event ?? "status_update";
+  const timestamp = new Date(data.date_time);
+  if (Number.isNaN(timestamp.getTime())) {
+    throw new ValidationError("Invalid webhook payload: invalid date_time value", { raw: data.date_time });
+  }
+  return {
+    carrier: "aymakan",
+    eventType,
+    trackingNumber: data.tracking_number,
+    reference: data.reference ?? undefined,
+    status: eventType === "weight_update" ? "unknown" : mapAymakanStatus(data.status) ?? "unknown",
+    statusCode: data.status,
+    statusLabel: data.status_label,
+    reasonCode: data.reason_code ?? undefined,
+    reasonLabel: data.reason_en ?? undefined,
+    timestamp,
+    raw: data
+  };
+}
+
+// src/carriers/aymakan/adapter.ts
+var AYMAKAN_SANDBOX_URL = "https://dev-api.aymakan.com.sa/v2";
+var AYMAKAN_PRODUCTION_URL = "https://api.aymakan.net/v2";
+
+class AymakanAdapter extends BaseCarrierAdapter {
+  name = "aymakan";
+  supportedCountries = ["SA", "AE", "BH", "KW", "OM", "QA"];
+  http;
+  citiesCache = null;
+  citiesCacheTime = 0;
+  static CITIES_CACHE_TTL = 60 * 60 * 1000;
+  constructor(config) {
+    super(config);
+    this.http = new HttpClient({
+      baseUrl: this.getBaseUrl(),
+      carrier: "aymakan",
+      headers: {
+        Authorization: config.credentials.apiKey
+      }
+    });
+  }
+  getBaseUrl() {
+    return this.config.mode === "production" ? AYMAKAN_PRODUCTION_URL : AYMAKAN_SANDBOX_URL;
+  }
+  async ensureCitiesLoaded() {
+    if (this.citiesCache && Date.now() - this.citiesCacheTime < AymakanAdapter.CITIES_CACHE_TTL) {
+      return;
+    }
+    try {
+      this.citiesCache = await this.getCities();
+      this.citiesCacheTime = Date.now();
+    } catch {
+      if (!this.citiesCache)
+        this.citiesCache = [];
+    }
+  }
+  static normalizeArabic(text) {
+    return text.trim().replace(/[\u064B-\u065F\u0670]/g, "").replace(/[أإآ]/g, "ا").replace(/ة/g, "ه");
+  }
+  resolveCity(inputCity) {
+    if (!this.citiesCache || this.citiesCache.length === 0)
+      return inputCity;
+    const trimmed = inputCity.trim();
+    if (!trimmed)
+      return inputCity;
+    const lower = trimmed.toLowerCase();
+    const exactEn = this.citiesCache.find((c) => c.nameEn.toLowerCase() === lower);
+    if (exactEn)
+      return exactEn.nameEn;
+    const exactAr = this.citiesCache.find((c) => c.nameAr === trimmed);
+    if (exactAr)
+      return exactAr.nameEn;
+    const normalizedInput = AymakanAdapter.normalizeArabic(trimmed);
+    const normalizedAr = this.citiesCache.find((c) => c.nameAr && AymakanAdapter.normalizeArabic(c.nameAr) === normalizedInput);
+    if (normalizedAr)
+      return normalizedAr.nameEn;
+    const withoutAl = normalizedInput.startsWith("ال") ? normalizedInput.slice(2) : `ال${normalizedInput}`;
+    const alMatch = this.citiesCache.find((c) => c.nameAr && AymakanAdapter.normalizeArabic(c.nameAr) === withoutAl);
+    if (alMatch)
+      return alMatch.nameEn;
+    const containsEn = this.citiesCache.find((c) => c.nameEn.toLowerCase().includes(lower) || lower.includes(c.nameEn.toLowerCase()));
+    if (containsEn)
+      return containsEn.nameEn;
+    return trimmed;
+  }
+  resolveCitiesInInput(input) {
+    return {
+      ...input,
+      shipper: {
+        ...input.shipper,
+        city: this.resolveCity(input.shipper.city)
+      },
+      consignee: {
+        ...input.consignee,
+        city: this.resolveCity(input.consignee.city)
+      }
+    };
+  }
+  async executeCreateShipment(input) {
+    await this.ensureCitiesLoaded();
+    const resolved = this.resolveCitiesInInput(input);
+    const request = mapCreateShipmentRequest(resolved);
+    const response = await this.http.post("/shipping/create", request);
+    if (!response.success) {
+      throw new APIError("Failed to create shipment", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return mapShipmentResponse(response.shipping);
+  }
+  async createBulkShipments(inputs) {
+    inputs.forEach(validateCreateShipmentInput);
+    await this.ensureCitiesLoaded();
+    const requests = inputs.map((i) => this.resolveCitiesInInput(i)).map(mapCreateShipmentRequest);
+    const response = await this.http.post("/shipping/create_bulk", { data: requests });
+    if (!response.success) {
+      throw new APIError("Failed to create bulk shipments", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return response.data.shipments.map(mapShipmentResponse);
+  }
+  async cancelShipment(trackingNumber) {
+    const response = await this.http.post("/shipping/cancel", {
+      tracking: trackingNumber
+    });
+    return response.success;
+  }
+  async cancelByReference(reference) {
+    const response = await this.http.post(`/shipping/cancel/reference/${encodeURIComponent(reference)}`);
+    return response.success;
+  }
+  async updateDeliveryAddress(trackingNumber, address) {
+    await this.ensureCitiesLoaded();
+    const resolvedCity = this.resolveCity(address.city);
+    const response = await this.http.post(`/shipping/update_delivery_address/${encodeURIComponent(trackingNumber)}`, {
+      delivery_name: address.name,
+      delivery_email: address.email,
+      delivery_city: resolvedCity,
+      delivery_address: address.line1,
+      delivery_neighbourhood: address.neighbourhood,
+      delivery_postcode: address.postalCode,
+      delivery_country: address.countryCode,
+      delivery_phone: address.phone
+    });
+    return response.success;
+  }
+  async track(trackingNumber) {
+    const results = await this.trackMultiple([trackingNumber]);
+    const result = results[0];
+    if (!result) {
+      throw new APIError("Shipment not found", { carrier: "aymakan" });
+    }
+    return result;
+  }
+  async trackMultiple(trackingNumbers) {
+    const ids = trackingNumbers.map(encodeURIComponent).join(",");
+    const response = await this.http.get(`/shipping/track/${ids}`);
+    if (!response.success) {
+      throw new APIError("Failed to track shipments", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return response.data.shipments.map(mapTrackingResult);
+  }
+  async trackByReference(reference) {
+    const response = await this.http.get(`/shipments/by_reference/${encodeURIComponent(reference)}`);
+    if (!response.success || !response.data.shipments[0]) {
+      throw new APIError("Shipment not found", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return mapTrackingResult(response.data.shipments[0]);
+  }
+  async getLabel(trackingNumber, format) {
+    const response = await this.http.get(`/shipping/awb/tracking/${encodeURIComponent(trackingNumber)}`);
+    if (!response.success) {
+      throw new APIError("Failed to get label", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    if (format === "PNG") {
+      return response.data.label || response.data.awb_url || response.data.pdf_label;
+    }
+    return response.data.pdf_label || response.data.awb_url || response.data.label;
+  }
+  async getBulkLabels(trackingNumbers) {
+    const response = await this.http.post("/shipping/bulk_awb_labels", {
+      tracking_numbers: trackingNumbers
+    });
+    if (!response.success) {
+      throw new APIError("Failed to get bulk labels", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return response.data.label_url;
+  }
+  async getPickupCities() {
+    const response = await this.http.get("/pickup_request/cities");
+    if (!response.success) {
+      throw new APIError("Failed to get pickup cities", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return response.data.cities.map(mapCity);
+  }
+  async getTimeSlots(_city, date) {
+    const response = await this.http.get(`/time_slots/${date}`);
+    if (!response.success || response.error || !response.data?.slots) {
+      const msg = response.message ?? "No slots available";
+      throw new APIError(msg, { carrier: "aymakan", raw: response });
+    }
+    return Object.entries(response.data.slots).map(([id, label]) => ({
+      id,
+      label
+    }));
+  }
+  async createPickup(input) {
+    validatePickupRequest(input);
+    await this.ensureCitiesLoaded();
+    const resolvedInput = { ...input, city: this.resolveCity(input.city) };
+    const request = mapPickupRequest(resolvedInput);
+    const response = await this.http.post("/pickup_request/create", request);
+    if (!response.success) {
+      throw new APIError("Failed to create pickup", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return mapPickupResponse(response.data);
+  }
+  async cancelPickup(pickupId) {
+    const response = await this.http.post(`/pickup_request/cancel/${encodeURIComponent(String(pickupId))}`);
+    return response.success;
+  }
+  async getPickupRequests() {
+    const response = await this.http.get("/pickup_requests");
+    if (!response.success) {
+      throw new APIError("Failed to get pickup requests", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return response.data.pickup_requests.map(mapPickupResponse);
+  }
+  async getCities() {
+    const response = await this.http.get("/cities");
+    if (!response.success) {
+      throw new APIError("Failed to get cities", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return response.data.cities.map(mapCity);
+  }
+  async getDropoffLocations() {
+    const response = await this.http.get("/dropoff_locations");
+    if (!response.success) {
+      throw new APIError("Failed to get dropoff locations", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return response.data.locations.map((loc) => ({
+      id: String(loc.id),
+      name: loc.name,
+      nameAr: loc.name_ar,
+      address: loc.address,
+      city: loc.city
+    }));
+  }
+  async createCustomerAddress(address) {
+    const request = mapCustomerAddressRequest(address);
+    const response = await this.http.post("/address/create", request);
+    if (!response.success) {
+      throw new APIError("Failed to create address", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    const addr = response.data.address;
+    return {
+      id: addr.id,
+      title: addr.title,
+      name: addr.name,
+      email: addr.email,
+      phone: addr.phone,
+      city: addr.city,
+      address: addr.address,
+      neighbourhood: addr.neighbourhood,
+      postalCode: addr.postcode,
+      countryCode: addr.country,
+      description: addr.description
+    };
+  }
+  async getCustomerAddresses() {
+    const response = await this.http.get("/addresses");
+    if (!response.success) {
+      throw new APIError("Failed to get customer addresses", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    return response.data.addresses.map((addr) => ({
+      id: addr.id,
+      title: addr.title,
+      name: addr.name,
+      email: addr.email,
+      phone: addr.phone,
+      city: addr.city,
+      address: addr.address,
+      neighbourhood: addr.neighbourhood,
+      postalCode: addr.postcode,
+      countryCode: addr.country,
+      description: addr.description
+    }));
+  }
+  async updateCustomerAddress(id, address) {
+    const response = await this.http.put(`/address/update/${id}`, {
+      title: address.title,
+      name: address.name,
+      email: address.email,
+      city: address.city,
+      address: address.address,
+      neighbourhood: address.neighbourhood,
+      postcode: address.postalCode,
+      phone: address.phone,
+      description: address.description
+    });
+    if (!response.success) {
+      throw new APIError("Failed to update address", {
+        carrier: "aymakan",
+        raw: response
+      });
+    }
+    const addr = response.data.address;
+    return {
+      id: addr.id,
+      title: addr.title,
+      name: addr.name,
+      email: addr.email,
+      phone: addr.phone,
+      city: addr.city,
+      address: addr.address,
+      neighbourhood: addr.neighbourhood,
+      postalCode: addr.postcode,
+      countryCode: addr.country,
+      description: addr.description
+    };
+  }
+  async deleteCustomerAddress(id) {
+    const response = await this.http.delete(`/address/delete/${id}`);
+    return response.success;
+  }
+  parseWebhook(payload, options) {
+    return parseAymakanWebhook(payload, options);
+  }
+  getRates() {
+    throw new UnsupportedOperationError("aymakan", "getRates");
+  }
+}
+export {
+  parseAymakanWebhook,
+  mapAymakanStatus,
+  AymakanStatusCodes,
+  AymakanService,
+  AymakanAdapter
+};
+
+//# debugId=ECFB3CDDA31BC0F864756E2164756E21