universal-parcel-scraper 0.49.2-main.565 → 0.50.0-main.568

package/dist/carriers/bring-posten/parser.js

@@ -2,7 +2,7 @@ import { DateTime } from 'luxon';
 import { isValidS10TrackingNumber, normalizeTrackingNumber } from '../../core/detection/index.js';
 import { IndeterminateError, InvalidInputError, SchemaError } from '../../core/errors/index.js';
 import { calendarDay, explicitOffsetTime } from '../../core/time/index.js';
-import { clean } from '../../core/transport/index.js';
+import { clean, cleanScalar } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
 import { bringStatus, bringWording } from './status.js';
 /**
@@ -64,6 +64,18 @@ function estimatedDay(domain) {
     const day = /^(\d{4})-(\d{2})-(\d{2})(?:$|T)/.exec(eta.dateOfEstimatedDeliveryIso);
     return day ? calendarDay(Number(day[1]), Number(day[2]), Number(day[3])) : null;
 }
+/**
+ * Whether the parcel was collected at the pickup point the portal names: the
+ * delivery, and the movement before it that made the parcel ready for pickup,
+ * were scanned at that point's unit. Notices prove no movement.
+ */
+function collectedAt(rows, pickupUnit) {
+    const unit = cleanScalar(pickupUnit, 32);
+    const moves = rows.filter(row => bringStatus(String(row.status), text(row.lmCauseCode, 8)));
+    const index = moves.findIndex(row => row.status !== 'DELIVERED');
+    return Boolean(unit) && index > 0 && moves[index].status === 'READY_FOR_PICKUP'
+        && moves.slice(0, index + 1).every(row => cleanScalar(row.unitId, 32) === unit);
+}
 export function parseBring(payload, rawNumber) {
     const number = normalizeBringNumber(rawNumber);
     if (!isRecord(payload))
@@ -126,8 +138,9 @@ export function parseBring(payload, rawNumber) {
     const sender = text(consignment.senderName, 200) || text(parcel.senderName, 200);
     const pickupInfo = isRecord(parcel.domain.deliveryType) && isRecord(parcel.domain.deliveryType.pickupPointInfo)
         ? parcel.domain.deliveryType.pickupPointInfo : {};
-    const pickup = current?.stage === 'ready_for_pickup'
-        ? text(parcel.expectedPickupUnitName, 200) || text(pickupInfo.expectedPickupUnitName, 200) : '';
+    const atPickupPoint = current?.stage === 'ready_for_pickup'
+        || (current?.stage === 'delivered' && collectedAt(parcel.eventSet.filter(isRecord), parcel.expectedPickupUnitId));
+    const pickup = atPickupPoint ? text(parcel.expectedPickupUnitName, 200) || text(pickupInfo.expectedPickupUnitName, 200) : '';
     const country = isRecord(consignment.recipientAddress) ? consignment.recipientAddress.countryCode : undefined;
     const active = current && ['pending', 'in_transit', 'out_for_delivery'].includes(current.status) && current.stage !== 'ready_for_pickup';
     return { status: current?.status ?? 'unknown', ...(current ? { current_stage: current.stage } : {}),

package/dist/carriers/dpd/adapter.js

@@ -9,7 +9,7 @@ import { runSteps } from '../../core/runner/index.js';
 import { calendarDay, isoTime, explicitOffsetTime, zonedTime } from '../../core/time/index.js';
 import { TrawlClient, decodeText, fetchBounded, parseJsonBytes, userAgentOf } from '../../core/transport/index.js';
 import { isRecord } from '../../core/types.js';
-import { DpdAppService } from '../dpd-de/service.js';
+import { sharedDpdAppService } from '../dpd-de/service.js';
 import { API_LABELS, PROOF_OF_DELIVERY_SCAN, apiStage, apiStatus, scanStage, wordingStatus, } from './status.js';
 // Protocol provenance:
 // - The myDPD Android application talks to a guest JSON API: a Firebase
@@ -1025,7 +1025,8 @@ export const adapter = (environment) => {
         // A host can follow a rotated key without waiting for a release.
         firebaseApiKey: environment.env.DPD_FIREBASE_API_KEY?.trim() || undefined,
         // The German DPD app's service holds the group's Pickup shops, Swiss ones included.
-        shops: new DpdAppService({ fetcher: environment.fetcher, userAgent: environment.userAgent }),
+        // Its session is the process's, which DPD Germany shares.
+        shops: sharedDpdAppService(environment),
     });
     return {
         id: 'dpd',

package/dist/carriers/dpd-de/adapter.js

@@ -1,11 +1,13 @@
 import { CarrierError, carrierErrorKind } from '../../core/errors/index.js';
 import { DPDTracker } from '../dpd/adapter.js';
 import { DPD_DE_OTHER_COUNTRY, DpdDeAppClient } from './app.js';
+import { sharedDpdAppService } from './service.js';
 /** Left to the guest API when the app's session is still opening ahead of it. */
 const GUEST_RESERVE_MS = 20_000;
 /** Germany reads the German app's service, then the guest protocol with its own business-unit selector. */
 export const adapter = (environment) => {
-    const app = new DpdDeAppClient({ fetcher: environment.fetcher, userAgent: environment.userAgent });
+    // The process's session, which DPD Switzerland shares.
+    const app = new DpdDeAppClient({ service: sharedDpdAppService(environment) });
     const tracker = new DPDTracker({
         country: 'DE',
         fetcher: environment.fetcher,

package/dist/carriers/dpd-de/app.d.ts

@@ -1,7 +1,7 @@
 import type { CarrierResult } from '../../core/result/index.js';
 import type { ClassifiedStatus } from '../../core/status/index.js';
 import type { XmlNode } from '../../core/transport/xml.js';
-import { type DpdDePartner } from './service.js';
+import { DpdAppService, type DpdDePartner } from './service.js';
 /** Activity the service places outside Germany; the app tier would read the same parcel. */
 export declare const DPD_DE_OTHER_COUNTRY = "other_country";
 /** The app's progress rail: one coarse state for the whole parcel. */
@@ -14,10 +14,11 @@ export declare function parseDpdDeApp(data: XmlNode, scans: XmlNode, number: str
     result: CarrierResult;
     shop: string;
 };
-/** DPD Germany's tracking through the German app's service, which keeps one session per client. */
+/** DPD Germany's tracking through the German app's service, over the given one or a new one. */
 export declare class DpdDeAppClient {
     #private;
     constructor(options?: {
+        service?: DpdAppService;
         partner?: DpdDePartner;
         fetcher?: typeof fetch;
         userAgent?: string;

package/dist/carriers/dpd-de/app.js

@@ -188,11 +188,11 @@ export function parseDpdDeApp(data, scans, number) {
     };
     return { result, shop: pickup?.id ?? '' };
 }
-/** DPD Germany's tracking through the German app's service, which keeps one session per client. */
+/** DPD Germany's tracking through the German app's service, over the given one or a new one. */
 export class DpdDeAppClient {
     #service;
     constructor(options = {}) {
-        this.#service = new DpdAppService(options);
+        this.#service = options.service ?? new DpdAppService(options);
     }
     /**
      * `sessionWaitMs` bounds the wait for a session still opening; the whole `timeoutMs` by default.

package/dist/carriers/dpd-de/service.d.ts

@@ -1,3 +1,4 @@
+import type { AdapterEnvironment } from '../../core/adapter/index.js';
 import { type XmlNode } from '../../core/transport/xml.js';
 export declare const DPD_DE_APP_API = "https://api.paketnavigator.de/services/v1/Navigator3Service.asmx";
 /** The lookup stopped waiting for the session, which keeps opening for the next one. */
@@ -28,8 +29,9 @@ export interface DpdParcelShop {
 }
 /**
  * The service needs an anonymous device session, which it takes tens of seconds to open and then
- * accepts for hours: one is kept per instance. The opening runs on its own clock, so a lookup that
- * stops waiting leaves it to the next.
+ * accepts for hours. One is kept per instance, and `sharedDpdAppService` gives the process one
+ * instance per transport. The opening runs on its own clock, so a lookup that stops waiting
+ * leaves it to the next. A session past its renewal age serves while the next one opens.
  */
 export declare class DpdAppService {
     #private;
@@ -49,11 +51,30 @@ export declare class DpdAppService {
     }): Promise<DpdParcelShop | undefined>;
     /** Forgets a session the service refused, unless another lookup already replaced it. */
     expire(session: string): void;
+    /**
+     * Keeps a session open from now on, for a long-lived host: one opens at once if there is none,
+     * and the next before the current one lapses. Openings then run whether or not a lookup waits
+     * for them. The timer does not keep the process alive.
+     */
+    keep(): void;
     /**
      * One session for every lookup. The opening runs while a lookup that asked for it is still
      * running, even one that stopped waiting; each lookup waits until its signal or `waitMs` ends.
+     * A session past its renewal age answers at once while the next one opens.
      */
     session(signal: AbortSignal, waitMs: number): Promise<string>;
     call(operation: string, fields: Fields, signal: AbortSignal, timeoutMs: number): Promise<XmlNode>;
 }
+/**
+ * The process's service for a transport and user agent. DPD Germany and DPD Switzerland share it,
+ * and so do the adapters of every registry, so a session opens once for all of them.
+ */
+export declare function sharedDpdAppService(options?: Pick<AdapterEnvironment, 'fetcher' | 'userAgent'>): DpdAppService;
+/**
+ * Opens the session DPD Germany and DPD Switzerland read the German DPD app's service with, in the
+ * background, and keeps one open for the life of the process, so that no lookup waits the tens of
+ * seconds an opening takes. For a long-lived host, with the `fetcher` and `userAgent` its adapter
+ * environment has. The renewal timer does not keep the process alive.
+ */
+export declare function warmDpdSession(environment?: Pick<AdapterEnvironment, 'fetcher' | 'userAgent'>): void;
 export {};

package/dist/carriers/dpd-de/service.js

@@ -11,8 +11,15 @@ export const DPD_DE_SESSION_OPENING = 'session_opening';
 const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
 const SERVICE = 'https://cloud.dpd.com/';
 const MAX_BYTES = 2_000_000;
-/** Opening a session has taken up to 42 seconds. */
-const SESSION_OPEN_MS = 75_000;
+/** Opening a session has taken up to 75 seconds. */
+const SESSION_OPEN_MS = 120_000;
+/**
+ * The service accepts a session for at least four hours, an idle one too. From this age the next
+ * one opens beside it, and replaces it once open.
+ */
+const SESSION_RENEW_MS = 3 * 3_600_000;
+/** A kept session that failed to open is tried again after this long. */
+const SESSION_RETRY_MS = 15 * 60_000;
 // Shared partner credentials of the public app, distributed with the maintainer's approval.
 const PARTNER = { name: 'Android Paketnavigator3', token: 'A33363237662F5945576', password: '272 WetFd2mpXrgD' };
 export function invalid() { throw new SchemaError('DPD Germany', 'DPD Germany returned invalid tracking XML'); }
@@ -61,8 +68,9 @@ function shopOf(result, id) {
 }
 /**
  * The service needs an anonymous device session, which it takes tens of seconds to open and then
- * accepts for hours: one is kept per instance. The opening runs on its own clock, so a lookup that
- * stops waiting leaves it to the next.
+ * accepts for hours. One is kept per instance, and `sharedDpdAppService` gives the process one
+ * instance per transport. The opening runs on its own clock, so a lookup that stops waiting
+ * leaves it to the next. A session past its renewal age serves while the next one opens.
  */
 export class DpdAppService {
     #partner;
@@ -70,8 +78,10 @@ export class DpdAppService {
     #userAgent;
     #now;
     #device = randomBytes(8).toString('hex');
-    #session = '';
+    #session = null;
     #opening = null;
+    #kept = false;
+    #timer;
     constructor(options = {}) {
         this.#partner = options.partner ?? PARTNER;
         this.#fetcher = options.fetcher;
@@ -106,49 +116,85 @@ export class DpdAppService {
     }
     /** Forgets a session the service refused, unless another lookup already replaced it. */
     expire(session) {
-        if (this.#session === session)
-            this.#session = '';
+        if (this.#session?.token === session)
+            this.#session = null;
+    }
+    /**
+     * Keeps a session open from now on, for a long-lived host: one opens at once if there is none,
+     * and the next before the current one lapses. Openings then run whether or not a lookup waits
+     * for them. The timer does not keep the process alive.
+     */
+    keep() {
+        if (this.#kept)
+            return;
+        this.#kept = true;
+        this.#renew();
+    }
+    /** Opens the next session if the current one is due, or waits until it is. */
+    #renew() {
+        if (this.#opening)
+            return;
+        const age = this.#session ? this.#now() - this.#session.openedAt : Infinity;
+        if (age < SESSION_RENEW_MS)
+            this.#schedule(SESSION_RENEW_MS - age);
+        else
+            this.#opening = this.#open();
+    }
+    #schedule(ms) {
+        if (!this.#kept)
+            return;
+        clearTimeout(this.#timer);
+        this.#timer = setTimeout(() => this.#renew(), ms);
+        this.#timer.unref?.();
+    }
+    /** An opening, which a kept service finishes and otherwise ends when no lookup holds it. */
+    #open() {
+        const controller = new AbortController();
+        const holders = new Set();
+        const token = this.call('getSessionFullState', { SessionToken: '', DeviceData: {
+                HardwareID: this.#device, BootSystemID: 'Android_Phone', Version: '15', AppVersion: '4.2.0',
+            } }, controller.signal, SESSION_OPEN_MS).then(result => {
+            const value = scalar(one(result, 'SessionFullState'), 'SessionToken', 600);
+            if (!/^[A-Za-z0-9+/=]{16,512}$/.test(value))
+                invalid();
+            this.#session = { token: value, openedAt: this.#now() };
+            return value;
+        });
+        const release = () => {
+            for (const holder of holders)
+                if (holder.aborted)
+                    holders.delete(holder);
+            if (!holders.size && !this.#kept)
+                controller.abort(new Error('No lookup is waiting for the DPD Germany session'));
+        };
+        const opening = { token, holders, release };
+        void token.then(() => this.#schedule(SESSION_RENEW_MS), () => this.#schedule(SESSION_RETRY_MS)).finally(() => {
+            if (this.#opening === opening)
+                this.#opening = null;
+            for (const holder of holders)
+                holder.removeEventListener('abort', release);
+        });
+        return opening;
     }
     /**
      * One session for every lookup. The opening runs while a lookup that asked for it is still
      * running, even one that stopped waiting; each lookup waits until its signal or `waitMs` ends.
+     * A session past its renewal age answers at once while the next one opens.
      */
     async session(signal, waitMs) {
-        if (this.#session)
-            return this.#session;
+        const current = this.#session;
+        const due = !current || this.#now() - current.openedAt >= SESSION_RENEW_MS;
+        if (current && !due)
+            return current.token;
         signal.throwIfAborted();
-        if (!this.#opening) {
-            const controller = new AbortController();
-            const holders = new Set();
-            const token = this.call('getSessionFullState', { SessionToken: '', DeviceData: {
-                    HardwareID: this.#device, BootSystemID: 'Android_Phone', Version: '15', AppVersion: '4.2.0',
-                } }, controller.signal, SESSION_OPEN_MS).then(result => {
-                const value = scalar(one(result, 'SessionFullState'), 'SessionToken', 600);
-                if (!/^[A-Za-z0-9+/=]{16,512}$/.test(value))
-                    invalid();
-                return this.#session = value;
-            });
-            const release = () => {
-                for (const holder of holders)
-                    if (holder.aborted)
-                        holders.delete(holder);
-                if (!holders.size)
-                    controller.abort(new Error('No lookup is waiting for the DPD Germany session'));
-            };
-            const opening = { token, holders, release };
-            this.#opening = opening;
-            void token.catch(() => undefined).finally(() => {
-                if (this.#opening === opening)
-                    this.#opening = null;
-                for (const holder of holders)
-                    holder.removeEventListener('abort', release);
-            });
-        }
-        const { token, holders, release } = this.#opening;
+        const opening = this.#opening ??= this.#open();
+        const { token, holders, release } = opening;
         if (!holders.has(signal)) {
             holders.add(signal);
             signal.addEventListener('abort', release, { once: true });
         }
+        if (current)
+            return current.token;
         let leave;
         let timer;
         const left = new Promise((_resolve, reject) => {
@@ -198,3 +244,29 @@ export class DpdAppService {
         return result;
     }
 }
+const services = new WeakMap();
+const GLOBAL_FETCH = {};
+/**
+ * The process's service for a transport and user agent. DPD Germany and DPD Switzerland share it,
+ * and so do the adapters of every registry, so a session opens once for all of them.
+ */
+export function sharedDpdAppService(options = {}) {
+    const userAgent = userAgentOf(options.userAgent);
+    const key = options.fetcher ?? GLOBAL_FETCH;
+    let byAgent = services.get(key);
+    if (!byAgent)
+        services.set(key, byAgent = new Map());
+    let service = byAgent.get(userAgent);
+    if (!service)
+        byAgent.set(userAgent, service = new DpdAppService({ fetcher: options.fetcher, userAgent }));
+    return service;
+}
+/**
+ * Opens the session DPD Germany and DPD Switzerland read the German DPD app's service with, in the
+ * background, and keeps one open for the life of the process, so that no lookup waits the tens of
+ * seconds an opening takes. For a long-lived host, with the `fetcher` and `userAgent` its adapter
+ * environment has. The renewal timer does not keep the process alive.
+ */
+export function warmDpdSession(environment = {}) {
+    sharedDpdAppService(environment).keep();
+}

package/dist/carriers/postnord/parser.js

@@ -11,6 +11,36 @@ export function normalizePostnordNumber(raw) {
     }
     return number;
 }
+/**
+ * The scan that made the parcel available at its service point, while it waits
+ * there or once it is collected there: the delivery, scanned at that same point,
+ * came right after it. A parcel taken back out for delivery has a movement between.
+ */
+function atPickupPoint(stage, events) {
+    if (stage === 'ready_for_pickup')
+        return events.find((event) => event.stage === 'ready_for_pickup');
+    if (stage !== 'delivered')
+        return undefined;
+    const index = events.findIndex((event) => event.stage !== 'delivered');
+    const ready = events[index];
+    return index > 0 && ready?.stage === 'ready_for_pickup' && ready.location
+        && events.slice(0, index).every((event) => event.location === ready.location) ? ready : undefined;
+}
+/**
+ * The service point's name, then its street and "postcode town", from the point
+ * record the tracking widget shows under a parcel ready for pickup. Without that
+ * record the scan's name stands alone. The receiver's address is a separate record.
+ */
+function pickupPoint(raw, scanned) {
+    const point = isRecord(raw) ? raw : {};
+    const address = isRecord(point.address) ? point.address : {};
+    const name = clean(point.name, 160);
+    if (!name)
+        return scanned;
+    const street = clean(address.street, 120);
+    const town = clean(address.city, 80);
+    return street && town ? [name, street, [clean(address.postalCode, 16), town].filter(Boolean).join(' ')].join('\n') : name;
+}
 export function parsePostnord(payload, number) {
     const requested = normalizePostnordNumber(number);
     if (!isRecord(payload) || payload.shipmentId !== requested || payload.actualReturnedId !== requested
@@ -69,8 +99,8 @@ export function parsePostnord(payload, number) {
     // The portal names the sender, usually the shop; of the receiver's address only the country is read.
     const sender = isRecord(payload.sender) ? clean(payload.sender.name, 200) : '';
     const country = isRecord(payload.receiver) && isRecord(payload.receiver.address) ? payload.receiver.address.countryCode : undefined;
-    // The service point holding the parcel, as the scan that made it available names it.
-    const pickup = mapped?.stage === 'ready_for_pickup' ? events.find((event) => event.stage === 'ready_for_pickup')?.location : undefined;
+    const pickupScan = atPickupPoint(mapped?.stage, events);
+    const pickup = pickupScan ? pickupPoint(payload.servicePoint, pickupScan.location ?? '') : '';
     return { status: mapped?.status ?? 'unknown', ...(mapped ? { current_stage: mapped.stage } : {}),
         last_status_text: header || events[0].description, last_update: events[0].time,
         expected_delivery: null, ...(delivery?.time ? { delivered_at: delivery.time } : {}),

package/dist/node.d.ts

@@ -8,4 +8,5 @@ export { REGISTRY } from './generated/registry.js';
 export { UniversalTracker, UniversalTrackingError } from './providers/universal.js';
 export { TrackingCaptureError, SeventeenTrackLookupError, SeventeenTrackNoHistoryError, SeventeenTrackVerificationError } from './providers/universal.js';
 export { amazonShippingEligibility } from './carriers/amazon-shipping/eligibility.js';
+export { warmDpdSession } from './carriers/dpd-de/service.js';
 export { createTrackingServer, type TrackingServerOptions } from './server/index.js';

package/dist/node.js

@@ -8,4 +8,5 @@ export { REGISTRY } from './generated/registry.js';
 export { UniversalTracker, UniversalTrackingError } from './providers/universal.js';
 export { TrackingCaptureError, SeventeenTrackLookupError, SeventeenTrackNoHistoryError, SeventeenTrackVerificationError } from './providers/universal.js';
 export { amazonShippingEligibility } from './carriers/amazon-shipping/eligibility.js';
+export { warmDpdSession } from './carriers/dpd-de/service.js';
 export { createTrackingServer } from './server/index.js';

package/dist/server/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Universal Parcel Scraper",
-    "version": "0.49.2"
+    "version": "0.50.0"
   },
   "paths": {
     "/health": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "universal-parcel-scraper",
-  "version": "0.49.2-main.565",
+  "version": "0.50.0-main.568",
   "description": "Self-hosted parcel tracking: carrier detection, dedicated scrapers and optional universal providers.",
   "type": "module",
   "license": "Apache-2.0",