@veho/turvo-integration-sdk 0.1.0-beta.0

package/lib/esm/api/turvoPublicApi.js

@@ -0,0 +1,99 @@
+import { TurvoApiMethod, } from '../types/common';
+/**
+ * TurvoPublicApi provides access to documented Turvo API endpoints.
+ * All shipment management operations (create, update, cancel, query) go through this class.
+ */
+export class TurvoPublicApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * GET /v1/shipments/{id}
+     * Returns shipment details, stops, status
+     */
+    async getShipment(params) {
+        const { shipmentId } = params;
+        const httpClient = await this.client.getAuthenticatedClient();
+        return httpClient.sendRequest(`/shipments/${shipmentId}`, TurvoApiMethod.GET, {});
+    }
+    /**
+     * POST /v1/shipments
+     * Upload properly formatted shipment to Turvo
+     */
+    async uploadShipment(params) {
+        const { shipment } = params;
+        // Note: vehoLoadId is kept in the params for logging purposes by consumers
+        const httpClient = await this.client.getAuthenticatedClient();
+        return httpClient.sendRequest('/shipments', TurvoApiMethod.POST, {
+            body: shipment,
+        });
+    }
+    /**
+     * PUT /v1/tags/attach/shipment/{id}
+     * Associate a list of tags with a shipment by ID
+     */
+    async associateTagsToShipment(params) {
+        const { turvoShipmentId, tags } = params;
+        const httpClient = await this.client.getAuthenticatedClient();
+        return httpClient.sendRequest(`/tags/attach/shipment/${turvoShipmentId}`, TurvoApiMethod.PUT, {
+            body: {
+                tagNames: tags,
+            },
+        });
+    }
+    /**
+     * PUT /v1/shipments/status/{id}
+     * Set shipment status to Cancelled in Turvo
+     */
+    async cancelShipment(params) {
+        const { turvoShipmentId } = params;
+        const httpClient = await this.client.getAuthenticatedClient();
+        const body = {
+            id: turvoShipmentId,
+            status: {
+                code: { key: '2113', value: 'Canceled' },
+            },
+        };
+        return httpClient.sendRequest(`/shipments/status/${turvoShipmentId}`, TurvoApiMethod.PUT, {
+            body,
+        });
+    }
+    /**
+     * PUT /v1/shipments/status/{id}
+     * Update shipment status at a specific stop
+     */
+    async updateShipmentStatus(params) {
+        const { turvoShipmentId, turvoStopId, turvoStatusCode, statusDate, statusTimezone } = params;
+        const httpClient = await this.client.getAuthenticatedClient();
+        const body = {
+            id: turvoShipmentId,
+            status: {
+                globalShipLocationId: turvoStopId,
+                code: turvoStatusCode.code,
+                timezone: statusTimezone,
+                statusDate: {
+                    date: statusDate,
+                    timezone: statusTimezone,
+                },
+            },
+        };
+        return httpClient.sendRequest(`/shipments/status/${turvoShipmentId}`, TurvoApiMethod.PUT, { body });
+    }
+    /**
+     * GET /v1/shipments/list
+     * Query shipments from Turvo with pagination support
+     */
+    async filterShipments(params) {
+        const { turvoLocationId, pickupDateStart, start = 0 } = params;
+        const httpClient = await this.client.getAuthenticatedClient();
+        return httpClient.sendRequest('/shipments/list', TurvoApiMethod.GET, {
+            query: {
+                'locationId[eq]': turvoLocationId.toString(),
+                'pickupDate[gte]': pickupDateStart,
+                start: start.toString(),
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"turvoPublicApi.js","sourceRoot":"","sources":["../../../src/api/turvoPublicApi.ts"],"names":[],"mappings":"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","sourcesContent":["import { TurvoClient } from '../client/turvoClient'\nimport {\n  TurvoApiMethod,\n  TurvoApiResult,\n  TurvoFilterShipmentsResultItem,\n  TurvoLookup,\n  TurvoPagedResult,\n} from '../types/common'\nimport {\n  TurvoAssociateTagsApiResult,\n  TurvoCancelShipmentApiResult,\n  TurvoCreateShipmentApiResult,\n  TurvoShipment,\n  TurvoShipmentStatus,\n  TurvoUpdateShipmentStatusApiResult,\n} from '../types/shipment'\n\n/**\n * Parameters for uploading a shipment to Turvo\n */\nexport interface UploadShipmentParams {\n  /** The formatted shipment to upload */\n  shipment: TurvoShipment\n  /** The Load ID, solely for logging purposes */\n  vehoLoadId: string\n}\n\n/**\n * Parameters for associating tags to a shipment\n */\nexport interface AssociateTagsParams {\n  /** The shipment ID to associate tags with */\n  turvoShipmentId: number\n  /** List of tag names to assign */\n  tags: string[]\n}\n\n/**\n * Parameters for cancelling a shipment\n */\nexport interface CancelShipmentParams {\n  /** The Turvo system Shipment ID to cancel */\n  turvoShipmentId: number\n}\n\n/**\n * Parameters for updating shipment status\n */\nexport interface UpdateShipmentStatusParams {\n  /** The Turvo shipment ID */\n  turvoShipmentId: number\n  /** The Turvo stop ID */\n  turvoStopId: number\n  /** The status code to set */\n  turvoStatusCode: TurvoShipmentStatus\n  /** The status date in ISO format */\n  statusDate: string\n  /** The timezone for the status date */\n  statusTimezone: string\n}\n\n/**\n * Parameters for retrieving a shipment\n */\nexport interface GetShipmentParams {\n  /** The shipment ID to retrieve */\n  shipmentId: number\n}\n\n/**\n * Parameters for filtering shipments\n */\nexport interface FilterShipmentsParams {\n  /** Turvo location ID to filter by */\n  turvoLocationId: number\n  /** Pickup date start filter (ISO format) */\n  pickupDateStart: string\n  /** Optional pagination start offset */\n  start?: number\n}\n\n/**\n * TurvoPublicApi provides access to documented Turvo API endpoints.\n * All shipment management operations (create, update, cancel, query) go through this class.\n */\nexport class TurvoPublicApi {\n  constructor(private client: TurvoClient) {}\n\n  /**\n   * GET /v1/shipments/{id}\n   * Returns shipment details, stops, status\n   */\n  async getShipment(params: GetShipmentParams): Promise<TurvoApiResult<TurvoShipment>> {\n    const { shipmentId } = params\n    const httpClient = await this.client.getAuthenticatedClient()\n\n    return httpClient.sendRequest<TurvoShipment>(`/shipments/${shipmentId}`, TurvoApiMethod.GET, {})\n  }\n\n  /**\n   * POST /v1/shipments\n   * Upload properly formatted shipment to Turvo\n   */\n  async uploadShipment(params: UploadShipmentParams): Promise<TurvoApiResult<TurvoCreateShipmentApiResult>> {\n    const { shipment } = params\n    // Note: vehoLoadId is kept in the params for logging purposes by consumers\n    const httpClient = await this.client.getAuthenticatedClient()\n\n    return httpClient.sendRequest<TurvoCreateShipmentApiResult>('/shipments', TurvoApiMethod.POST, {\n      body: shipment,\n    })\n  }\n\n  /**\n   * PUT /v1/tags/attach/shipment/{id}\n   * Associate a list of tags with a shipment by ID\n   */\n  async associateTagsToShipment(params: AssociateTagsParams): Promise<TurvoApiResult<TurvoAssociateTagsApiResult>> {\n    const { turvoShipmentId, tags } = params\n    const httpClient = await this.client.getAuthenticatedClient()\n\n    return httpClient.sendRequest<TurvoAssociateTagsApiResult>(\n      `/tags/attach/shipment/${turvoShipmentId}`,\n      TurvoApiMethod.PUT,\n      {\n        body: {\n          tagNames: tags,\n        },\n      }\n    )\n  }\n\n  /**\n   * PUT /v1/shipments/status/{id}\n   * Set shipment status to Cancelled in Turvo\n   */\n  async cancelShipment(params: CancelShipmentParams): Promise<TurvoApiResult<TurvoCancelShipmentApiResult>> {\n    const { turvoShipmentId } = params\n    const httpClient = await this.client.getAuthenticatedClient()\n\n    const body = {\n      id: turvoShipmentId,\n      status: {\n        code: { key: '2113', value: 'Canceled' } satisfies TurvoLookup,\n      },\n    }\n\n    return httpClient.sendRequest<TurvoCancelShipmentApiResult>(\n      `/shipments/status/${turvoShipmentId}`,\n      TurvoApiMethod.PUT,\n      {\n        body,\n      }\n    )\n  }\n\n  /**\n   * PUT /v1/shipments/status/{id}\n   * Update shipment status at a specific stop\n   */\n  async updateShipmentStatus(\n    params: UpdateShipmentStatusParams\n  ): Promise<TurvoApiResult<TurvoUpdateShipmentStatusApiResult>> {\n    const { turvoShipmentId, turvoStopId, turvoStatusCode, statusDate, statusTimezone } = params\n    const httpClient = await this.client.getAuthenticatedClient()\n\n    const body = {\n      id: turvoShipmentId,\n      status: {\n        globalShipLocationId: turvoStopId,\n        code: turvoStatusCode.code,\n        timezone: statusTimezone,\n        statusDate: {\n          date: statusDate,\n          timezone: statusTimezone,\n        },\n      },\n    }\n\n    return httpClient.sendRequest<TurvoUpdateShipmentStatusApiResult>(\n      `/shipments/status/${turvoShipmentId}`,\n      TurvoApiMethod.PUT,\n      { body }\n    )\n  }\n\n  /**\n   * GET /v1/shipments/list\n   * Query shipments from Turvo with pagination support\n   */\n  async filterShipments(\n    params: FilterShipmentsParams\n  ): Promise<TurvoApiResult<TurvoPagedResult<'shipments', TurvoFilterShipmentsResultItem>>> {\n    const { turvoLocationId, pickupDateStart, start = 0 } = params\n    const httpClient = await this.client.getAuthenticatedClient()\n\n    return httpClient.sendRequest<TurvoPagedResult<'shipments', TurvoFilterShipmentsResultItem>>(\n      '/shipments/list',\n      TurvoApiMethod.GET,\n      {\n        query: {\n          'locationId[eq]': turvoLocationId.toString(),\n          'pickupDate[gte]': pickupDateStart,\n          start: start.toString(),\n        },\n      }\n    )\n  }\n}\n"]}

package/lib/esm/client/turvoClient.d.ts

@@ -0,0 +1,49 @@
+import { TurvoApiMethod, TurvoApiResult } from '../types/common';
+import { TurvoCredentials } from '../types/config';
+/**
+ * Clear the cached access token (useful for testing or when token expires)
+ */
+export declare const clearCachedAccessToken: () => void;
+/**
+ * HTTP client interface for making authenticated Turvo API requests
+ */
+export interface AuthenticatedHttpClient {
+    /**
+     * Send a request to the Turvo API
+     * @param apiRoute - API route path (e.g., '/shipments')
+     * @param method - HTTP method
+     * @param params - Request parameters (body, headers, query)
+     * @returns Typed API result
+     */
+    sendRequest<T>(apiRoute: string, method: TurvoApiMethod, params: {
+        body?: object;
+        headers?: Record<string, string>;
+        query?: Record<string, string>;
+    }): Promise<TurvoApiResult<T>>;
+}
+/**
+ * Main client for interacting with Turvo APIs.
+ * Handles authentication, token management, and HTTP requests.
+ *
+ * @example
+ * ```typescript
+ * const client = new TurvoClient()
+ * const httpClient = await client.getAuthenticatedClient()
+ * const result = await httpClient.sendRequest('/shipments/123', TurvoApiMethod.GET, {})
+ * ```
+ */
+export declare class TurvoClient {
+    private secretPath;
+    private credentials?;
+    private httpClient?;
+    constructor(secretPath?: string);
+    /**
+     * Get authenticated HTTP client.
+     * Handles token refresh automatically.
+     */
+    getAuthenticatedClient(): Promise<AuthenticatedHttpClient>;
+    /**
+     * Get raw secrets (for internal API auth which uses different flow)
+     */
+    getCredentials(): Promise<TurvoCredentials>;
+}

package/lib/esm/client/turvoClient.js

@@ -0,0 +1,172 @@
+import { Client } from 'lambda-params-secrets';
+import fetch from 'node-fetch';
+import pRetry from 'p-retry';
+import pThrottle from 'p-throttle';
+import { DEFAULT_ALLOWED_RETRIES, DEFAULT_API_ROUTE_PREFIX, DEFAULT_RATE_LIMIT_RPS, TURVO_SECRET_PATH, } from '../constants';
+import { TurvoApiError, TurvoApiResponseStatus } from '../types/common';
+import { NoSecretError, TurvoAuthError } from '../types/errors';
+let secretClient = null;
+/**
+ * Get or create the secrets client instance
+ */
+const getSecretClientInstance = () => {
+    if (!secretClient) {
+        secretClient = new Client();
+    }
+    return secretClient;
+};
+/**
+ * Fetch Turvo API credentials from AWS Secrets Manager
+ */
+const getTurvoSecrets = async (secretsPath = TURVO_SECRET_PATH) => {
+    const fetchedSecret = await getSecretClientInstance().stringSecret(secretsPath);
+    if (!fetchedSecret) {
+        throw new NoSecretError(secretsPath);
+    }
+    return JSON.parse(fetchedSecret);
+};
+/**
+ * Cached access token to avoid repeated OAuth requests
+ */
+let cachedAccessToken = null;
+let tokenExpiry = null;
+/**
+ * Fetch an access token from Turvo using OAuth2 password grant
+ */
+const getTurvoAccessToken = async (credentials, apiRoutePrefix = DEFAULT_API_ROUTE_PREFIX, allowedRetries = DEFAULT_ALLOWED_RETRIES) => {
+    // Check if we have a valid cached token
+    if (cachedAccessToken && tokenExpiry && tokenExpiry > new Date()) {
+        return cachedAccessToken;
+    }
+    const fullUrl = `${credentials.urlBase + apiRoutePrefix}/oauth/token`;
+    return pRetry(async () => {
+        const url = new URL(fullUrl);
+        url.searchParams.set('client_id', 'publicapi');
+        url.searchParams.set('client_secret', 'secret');
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': credentials.apiKey,
+            },
+            body: JSON.stringify({
+                grant_type: 'password',
+                scope: 'read+trust+write',
+                username: credentials.username,
+                password: credentials.password,
+                type: 'business',
+            }),
+        });
+        if (!response.ok) {
+            throw new TurvoAuthError(`Failed to authenticate: ${response.status} ${response.statusText}`);
+        }
+        const data = (await response.json());
+        const { access_token, expires_in } = data;
+        if (!access_token) {
+            throw new TurvoAuthError('No access token returned from Turvo');
+        }
+        cachedAccessToken = access_token;
+        // Set token expiry (expires_in is in seconds, default to 1 hour if not provided)
+        const expiresInMs = (expires_in || 3600) * 1000;
+        tokenExpiry = new Date(Date.now() + expiresInMs - 60000); // Refresh 1 minute early
+        return access_token;
+    }, { retries: allowedRetries });
+};
+/**
+ * Clear the cached access token (useful for testing or when token expires)
+ */
+export const clearCachedAccessToken = () => {
+    cachedAccessToken = null;
+    tokenExpiry = null;
+};
+/**
+ * Main client for interacting with Turvo APIs.
+ * Handles authentication, token management, and HTTP requests.
+ *
+ * @example
+ * ```typescript
+ * const client = new TurvoClient()
+ * const httpClient = await client.getAuthenticatedClient()
+ * const result = await httpClient.sendRequest('/shipments/123', TurvoApiMethod.GET, {})
+ * ```
+ */
+export class TurvoClient {
+    secretPath;
+    credentials;
+    httpClient;
+    constructor(secretPath = TURVO_SECRET_PATH) {
+        this.secretPath = secretPath;
+    }
+    /**
+     * Get authenticated HTTP client.
+     * Handles token refresh automatically.
+     */
+    async getAuthenticatedClient() {
+        if (this.httpClient) {
+            return this.httpClient;
+        }
+        // Fetch credentials if not already loaded
+        if (!this.credentials) {
+            this.credentials = await getTurvoSecrets(this.secretPath);
+        }
+        // Create HTTP client with rate limiting and retries
+        const apiRoutePrefix = DEFAULT_API_ROUTE_PREFIX;
+        const allowedRetries = DEFAULT_ALLOWED_RETRIES;
+        const rateLimitRequestsPerSecond = DEFAULT_RATE_LIMIT_RPS;
+        // Create throttled version of the send function
+        const throttle = pThrottle({
+            limit: rateLimitRequestsPerSecond,
+            interval: 1000,
+        });
+        /**
+         * Internal function to send API request (with retry logic)
+         */
+        const sendToTurvoAPI = async (apiRoute, method, params) => {
+            const accessToken = await getTurvoAccessToken(this.credentials, apiRoutePrefix, allowedRetries);
+            const { body, headers, query } = params;
+            let fullRoute = `${this.credentials.urlBase + apiRoutePrefix + apiRoute}`;
+            if (query && Object.keys(query).length > 0) {
+                fullRoute = `${fullRoute}?${new URLSearchParams(query)}`;
+            }
+            return pRetry(async () => {
+                return fetch(fullRoute, {
+                    method,
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                        'Content-Type': 'application/json',
+                        'x-api-key': this.credentials.apiKey,
+                        ...headers,
+                    },
+                    ...(body && { body: JSON.stringify(body) }),
+                }).then(async (res) => {
+                    const result = await res.json();
+                    // Handle rate limiting (429)
+                    if (res.status === 429) {
+                        throw new TurvoApiError(res.status.toString(), result.message || 'Rate limited');
+                    }
+                    // Check for API-level errors
+                    if (result.Status !== TurvoApiResponseStatus.SUCCESS) {
+                        throw new TurvoApiError(result.details?.errorCode || 'UNKNOWN', result.details?.errorMessage || 'API error');
+                    }
+                    return result;
+                });
+            }, { retries: allowedRetries });
+        };
+        // Throttle the send function
+        const throttledSend = throttle(sendToTurvoAPI);
+        this.httpClient = {
+            sendRequest: throttledSend,
+        };
+        return this.httpClient;
+    }
+    /**
+     * Get raw secrets (for internal API auth which uses different flow)
+     */
+    async getCredentials() {
+        if (!this.credentials) {
+            this.credentials = await getTurvoSecrets(this.secretPath);
+        }
+        return this.credentials;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"turvoClient.js","sourceRoot":"","sources":["../../../src/client/turvoClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAC9C,OAAO,KAAK,MAAM,YAAY,CAAA;AAC9B,OAAO,MAAM,MAAM,SAAS,CAAA;AAC5B,OAAO,SAAS,MAAM,YAAY,CAAA;AAElC,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,sBAAsB,EACtB,iBAAiB,GAClB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,aAAa,EAAkB,sBAAsB,EAAkB,MAAM,iBAAiB,CAAA;AAEvG,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAE/D,IAAI,YAAY,GAAkB,IAAI,CAAA;AAEtC;;GAEG;AACH,MAAM,uBAAuB,GAAG,GAAW,EAAE;IAC3C,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,YAAY,GAAG,IAAI,MAAM,EAAE,CAAA;IAC7B,CAAC;IACD,OAAO,YAAY,CAAA;AACrB,CAAC,CAAA;AAED;;GAEG;AACH,MAAM,eAAe,GAAG,KAAK,EAAE,cAAsB,iBAAiB,EAA6B,EAAE;IACnG,MAAM,aAAa,GAAG,MAAM,uBAAuB,EAAE,CAAC,YAAY,CAAC,WAAW,CAAC,CAAA;IAE/E,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,MAAM,IAAI,aAAa,CAAC,WAAW,CAAC,CAAA;IACtC,CAAC;IAED,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,CAAqB,CAAA;AACtD,CAAC,CAAA;AAED;;GAEG;AACH,IAAI,iBAAiB,GAAkB,IAAI,CAAA;AAC3C,IAAI,WAAW,GAAgB,IAAI,CAAA;AAEnC;;GAEG;AACH,MAAM,mBAAmB,GAAG,KAAK,EAC/B,WAA6B,EAC7B,iBAAyB,wBAAwB,EACjD,iBAAyB,uBAAuB,EAC/B,EAAE;IACnB,wCAAwC;IACxC,IAAI,iBAAiB,IAAI,WAAW,IAAI,WAAW,GAAG,IAAI,IAAI,EAAE,EAAE,CAAC;QACjE,OAAO,iBAAiB,CAAA;IAC1B,CAAC;IAED,MAAM,OAAO,GAAG,GAAG,WAAW,CAAC,OAAO,GAAG,cAAc,cAAc,CAAA;IAErE,OAAO,MAAM,CACX,KAAK,IAAI,EAAE;QACT,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,CAAA;QAC5B,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;QAC9C,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAA;QAE/C,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;YAChC,MAAM,EAAE,MAAM;YACd,OAAO,EAAE;gBACP,cAAc,EAAE,kBAAkB;gBAClC,WAAW,EAAE,WAAW,CAAC,MAAM;aAChC;YACD,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;gBACnB,UAAU,EAAE,UAAU;gBACtB,KAAK,EAAE,kBAAkB;gBACzB,QAAQ,EAAE,WAAW,CAAC,QAAQ;gBAC9B,QAAQ,EAAE,WAAW,CAAC,QAAQ;gBAC9B,IAAI,EAAE,UAAU;aACjB,CAAC;SACH,CAAC,CAAA;QAEF,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;YACjB,MAAM,IAAI,cAAc,CAAC,2BAA2B,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAA;QAC/F,CAAC;QAED,MAAM,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAkD,CAAA;QACrF,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,IAAI,CAAA;QAEzC,IAAI,CAAC,YAAY,EAAE,CAAC;YAClB,MAAM,IAAI,cAAc,CAAC,qCAAqC,CAAC,CAAA;QACjE,CAAC;QAED,iBAAiB,GAAG,YAAY,CAAA;QAEhC,iFAAiF;QACjF,MAAM,WAAW,GAAG,CAAC,UAAU,IAAI,IAAI,CAAC,GAAG,IAAI,CAAA;QAC/C,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,WAAW,GAAG,KAAK,CAAC,CAAA,CAAC,yBAAyB;QAElF,OAAO,YAAY,CAAA;IACrB,CAAC,EACD,EAAE,OAAO,EAAE,cAAc,EAAE,CAC5B,CAAA;AACH,CAAC,CAAA;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAS,EAAE;IAC/C,iBAAiB,GAAG,IAAI,CAAA;IACxB,WAAW,GAAG,IAAI,CAAA;AACpB,CAAC,CAAA;AAoBD;;;;;;;;;;GAUG;AACH,MAAM,OAAO,WAAW;IAIF;IAHZ,WAAW,CAAmB;IAC9B,UAAU,CAA0B;IAE5C,YAAoB,aAAqB,iBAAiB;QAAtC,eAAU,GAAV,UAAU,CAA4B;IAAG,CAAC;IAE9D;;;OAGG;IACH,KAAK,CAAC,sBAAsB;QAC1B,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC,UAAU,CAAA;QACxB,CAAC;QAED,0CAA0C;QAC1C,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,WAAW,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QAC3D,CAAC;QAED,oDAAoD;QACpD,MAAM,cAAc,GAAG,wBAAwB,CAAA;QAC/C,MAAM,cAAc,GAAG,uBAAuB,CAAA;QAC9C,MAAM,0BAA0B,GAAG,sBAAsB,CAAA;QAEzD,gDAAgD;QAChD,MAAM,QAAQ,GAAG,SAAS,CAAC;YACzB,KAAK,EAAE,0BAA0B;YACjC,QAAQ,EAAE,IAAI;SACf,CAAC,CAAA;QAEF;;WAEG;QACH,MAAM,cAAc,GAAG,KAAK,EAC1B,QAAgB,EAChB,MAAsB,EACtB,MAA2F,EAC/D,EAAE;YAC9B,MAAM,WAAW,GAAG,MAAM,mBAAmB,CAAC,IAAI,CAAC,WAAY,EAAE,cAAc,EAAE,cAAc,CAAC,CAAA;YAChG,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,MAAM,CAAA;YACvC,IAAI,SAAS,GAAG,GAAG,IAAI,CAAC,WAAY,CAAC,OAAO,GAAG,cAAc,GAAG,QAAQ,EAAE,CAAA;YAE1E,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC3C,SAAS,GAAG,GAAG,SAAS,IAAI,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAA;YAC1D,CAAC;YAED,OAAO,MAAM,CACX,KAAK,IAAI,EAAE;gBACT,OAAO,KAAK,CAAC,SAAS,EAAE;oBACtB,MAAM;oBACN,OAAO,EAAE;wBACP,aAAa,EAAE,UAAU,WAAW,EAAE;wBACtC,cAAc,EAAE,kBAAkB;wBAClC,WAAW,EAAE,IAAI,CAAC,WAAY,CAAC,MAAM;wBACrC,GAAG,OAAO;qBACX;oBACD,GAAG,CAAC,IAAI,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;iBAC5C,CAAC,CAAC,IAAI,CAAC,KAAK,EAAC,GAAG,EAAC,EAAE;oBAClB,MAAM,MAAM,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAA;oBAE/B,6BAA6B;oBAC7B,IAAI,GAAG,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;wBACvB,MAAM,IAAI,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,EAAE,EAAE,MAAM,CAAC,OAAO,IAAI,cAAc,CAAC,CAAA;oBAClF,CAAC;oBAED,6BAA6B;oBAC7B,IAAI,MAAM,CAAC,MAAM,KAAK,sBAAsB,CAAC,OAAO,EAAE,CAAC;wBACrD,MAAM,IAAI,aAAa,CACrB,MAAM,CAAC,OAAO,EAAE,SAAS,IAAI,SAAS,EACtC,MAAM,CAAC,OAAO,EAAE,YAAY,IAAI,WAAW,CAC5C,CAAA;oBACH,CAAC;oBAED,OAAO,MAAM,CAAA;gBACf,CAAC,CAAC,CAAA;YACJ,CAAC,EACD,EAAE,OAAO,EAAE,cAAc,EAAE,CAC5B,CAAA;QACH,CAAC,CAAA;QAED,6BAA6B;QAC7B,MAAM,aAAa,GAAG,QAAQ,CAAC,cAAc,CAAC,CAAA;QAE9C,IAAI,CAAC,UAAU,GAAG;YAChB,WAAW,EAAE,aAAa;SAC3B,CAAA;QAED,OAAO,IAAI,CAAC,UAAU,CAAA;IACxB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,cAAc;QAClB,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,IAAI,CAAC,WAAW,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QAC3D,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CAAA;IACzB,CAAC;CACF","sourcesContent":["import { Client } from 'lambda-params-secrets'\nimport fetch from 'node-fetch'\nimport pRetry from 'p-retry'\nimport pThrottle from 'p-throttle'\n\nimport {\n  DEFAULT_ALLOWED_RETRIES,\n  DEFAULT_API_ROUTE_PREFIX,\n  DEFAULT_RATE_LIMIT_RPS,\n  TURVO_SECRET_PATH,\n} from '../constants'\nimport { TurvoApiError, TurvoApiMethod, TurvoApiResponseStatus, TurvoApiResult } from '../types/common'\nimport { TurvoCredentials } from '../types/config'\nimport { NoSecretError, TurvoAuthError } from '../types/errors'\n\nlet secretClient: Client | null = null\n\n/**\n * Get or create the secrets client instance\n */\nconst getSecretClientInstance = (): Client => {\n  if (!secretClient) {\n    secretClient = new Client()\n  }\n  return secretClient\n}\n\n/**\n * Fetch Turvo API credentials from AWS Secrets Manager\n */\nconst getTurvoSecrets = async (secretsPath: string = TURVO_SECRET_PATH): Promise<TurvoCredentials> => {\n  const fetchedSecret = await getSecretClientInstance().stringSecret(secretsPath)\n\n  if (!fetchedSecret) {\n    throw new NoSecretError(secretsPath)\n  }\n\n  return JSON.parse(fetchedSecret) as TurvoCredentials\n}\n\n/**\n * Cached access token to avoid repeated OAuth requests\n */\nlet cachedAccessToken: string | null = null\nlet tokenExpiry: Date | null = null\n\n/**\n * Fetch an access token from Turvo using OAuth2 password grant\n */\nconst getTurvoAccessToken = async (\n  credentials: TurvoCredentials,\n  apiRoutePrefix: string = DEFAULT_API_ROUTE_PREFIX,\n  allowedRetries: number = DEFAULT_ALLOWED_RETRIES\n): Promise<string> => {\n  // Check if we have a valid cached token\n  if (cachedAccessToken && tokenExpiry && tokenExpiry > new Date()) {\n    return cachedAccessToken\n  }\n\n  const fullUrl = `${credentials.urlBase + apiRoutePrefix}/oauth/token`\n\n  return pRetry(\n    async () => {\n      const url = new URL(fullUrl)\n      url.searchParams.set('client_id', 'publicapi')\n      url.searchParams.set('client_secret', 'secret')\n\n      const response = await fetch(url, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n          'x-api-key': credentials.apiKey,\n        },\n        body: JSON.stringify({\n          grant_type: 'password',\n          scope: 'read+trust+write',\n          username: credentials.username,\n          password: credentials.password,\n          type: 'business',\n        }),\n      })\n\n      if (!response.ok) {\n        throw new TurvoAuthError(`Failed to authenticate: ${response.status} ${response.statusText}`)\n      }\n\n      const data = (await response.json()) as { access_token: string; expires_in?: number }\n      const { access_token, expires_in } = data\n\n      if (!access_token) {\n        throw new TurvoAuthError('No access token returned from Turvo')\n      }\n\n      cachedAccessToken = access_token\n\n      // Set token expiry (expires_in is in seconds, default to 1 hour if not provided)\n      const expiresInMs = (expires_in || 3600) * 1000\n      tokenExpiry = new Date(Date.now() + expiresInMs - 60000) // Refresh 1 minute early\n\n      return access_token\n    },\n    { retries: allowedRetries }\n  )\n}\n\n/**\n * Clear the cached access token (useful for testing or when token expires)\n */\nexport const clearCachedAccessToken = (): void => {\n  cachedAccessToken = null\n  tokenExpiry = null\n}\n\n/**\n * HTTP client interface for making authenticated Turvo API requests\n */\nexport interface AuthenticatedHttpClient {\n  /**\n   * Send a request to the Turvo API\n   * @param apiRoute - API route path (e.g., '/shipments')\n   * @param method - HTTP method\n   * @param params - Request parameters (body, headers, query)\n   * @returns Typed API result\n   */\n  sendRequest<T>(\n    apiRoute: string,\n    method: TurvoApiMethod,\n    params: { body?: object; headers?: Record<string, string>; query?: Record<string, string> }\n  ): Promise<TurvoApiResult<T>>\n}\n\n/**\n * Main client for interacting with Turvo APIs.\n * Handles authentication, token management, and HTTP requests.\n *\n * @example\n * ```typescript\n * const client = new TurvoClient()\n * const httpClient = await client.getAuthenticatedClient()\n * const result = await httpClient.sendRequest('/shipments/123', TurvoApiMethod.GET, {})\n * ```\n */\nexport class TurvoClient {\n  private credentials?: TurvoCredentials\n  private httpClient?: AuthenticatedHttpClient\n\n  constructor(private secretPath: string = TURVO_SECRET_PATH) {}\n\n  /**\n   * Get authenticated HTTP client.\n   * Handles token refresh automatically.\n   */\n  async getAuthenticatedClient(): Promise<AuthenticatedHttpClient> {\n    if (this.httpClient) {\n      return this.httpClient\n    }\n\n    // Fetch credentials if not already loaded\n    if (!this.credentials) {\n      this.credentials = await getTurvoSecrets(this.secretPath)\n    }\n\n    // Create HTTP client with rate limiting and retries\n    const apiRoutePrefix = DEFAULT_API_ROUTE_PREFIX\n    const allowedRetries = DEFAULT_ALLOWED_RETRIES\n    const rateLimitRequestsPerSecond = DEFAULT_RATE_LIMIT_RPS\n\n    // Create throttled version of the send function\n    const throttle = pThrottle({\n      limit: rateLimitRequestsPerSecond,\n      interval: 1000,\n    })\n\n    /**\n     * Internal function to send API request (with retry logic)\n     */\n    const sendToTurvoAPI = async <T>(\n      apiRoute: string,\n      method: TurvoApiMethod,\n      params: { body?: object; headers?: Record<string, string>; query?: Record<string, string> }\n    ): Promise<TurvoApiResult<T>> => {\n      const accessToken = await getTurvoAccessToken(this.credentials!, apiRoutePrefix, allowedRetries)\n      const { body, headers, query } = params\n      let fullRoute = `${this.credentials!.urlBase + apiRoutePrefix + apiRoute}`\n\n      if (query && Object.keys(query).length > 0) {\n        fullRoute = `${fullRoute}?${new URLSearchParams(query)}`\n      }\n\n      return pRetry(\n        async () => {\n          return fetch(fullRoute, {\n            method,\n            headers: {\n              Authorization: `Bearer ${accessToken}`,\n              'Content-Type': 'application/json',\n              'x-api-key': this.credentials!.apiKey,\n              ...headers,\n            },\n            ...(body && { body: JSON.stringify(body) }),\n          }).then(async res => {\n            const result = await res.json()\n\n            // Handle rate limiting (429)\n            if (res.status === 429) {\n              throw new TurvoApiError(res.status.toString(), result.message || 'Rate limited')\n            }\n\n            // Check for API-level errors\n            if (result.Status !== TurvoApiResponseStatus.SUCCESS) {\n              throw new TurvoApiError(\n                result.details?.errorCode || 'UNKNOWN',\n                result.details?.errorMessage || 'API error'\n              )\n            }\n\n            return result\n          })\n        },\n        { retries: allowedRetries }\n      )\n    }\n\n    // Throttle the send function\n    const throttledSend = throttle(sendToTurvoAPI)\n\n    this.httpClient = {\n      sendRequest: throttledSend,\n    }\n\n    return this.httpClient\n  }\n\n  /**\n   * Get raw secrets (for internal API auth which uses different flow)\n   */\n  async getCredentials(): Promise<TurvoCredentials> {\n    if (!this.credentials) {\n      this.credentials = await getTurvoSecrets(this.secretPath)\n    }\n    return this.credentials\n  }\n}\n"]}

package/lib/esm/constants.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Default secret path for Turvo credentials in AWS Secrets Manager.
+ * Export this so consumers can grant IAM permissions.
+ *
+ * @example
+ * ```typescript
+ * import { TURVO_SECRET_PATH } from '@veho/turvo-sdk'
+ *
+ * // In CDK stack
+ * myLambda.addToRolePolicy(new iam.PolicyStatement({
+ *   actions: ['secretsmanager:GetSecretValue'],
+ *   resources: [`arn:aws:secretsmanager:*:*:secret:${TURVO_SECRET_PATH}*`],
+ * }))
+ * ```
+ */
+export declare const TURVO_SECRET_PATH = "/turvo/api";
+/**
+ * Default API route prefix for Turvo endpoints.
+ * Currently, Turvo uses a common prefix of "/v1" for all documented API routes.
+ */
+export declare const DEFAULT_API_ROUTE_PREFIX = "/v1";
+/**
+ * Default number of retry attempts for failed requests.
+ */
+export declare const DEFAULT_ALLOWED_RETRIES = 2;
+/**
+ * Default rate limit (requests per second) for Turvo API calls.
+ */
+export declare const DEFAULT_RATE_LIMIT_RPS = 1;

package/lib/esm/constants.js

@@ -0,0 +1,30 @@
+/**
+ * Default secret path for Turvo credentials in AWS Secrets Manager.
+ * Export this so consumers can grant IAM permissions.
+ *
+ * @example
+ * ```typescript
+ * import { TURVO_SECRET_PATH } from '@veho/turvo-sdk'
+ *
+ * // In CDK stack
+ * myLambda.addToRolePolicy(new iam.PolicyStatement({
+ *   actions: ['secretsmanager:GetSecretValue'],
+ *   resources: [`arn:aws:secretsmanager:*:*:secret:${TURVO_SECRET_PATH}*`],
+ * }))
+ * ```
+ */
+export const TURVO_SECRET_PATH = '/turvo/api';
+/**
+ * Default API route prefix for Turvo endpoints.
+ * Currently, Turvo uses a common prefix of "/v1" for all documented API routes.
+ */
+export const DEFAULT_API_ROUTE_PREFIX = '/v1';
+/**
+ * Default number of retry attempts for failed requests.
+ */
+export const DEFAULT_ALLOWED_RETRIES = 2;
+/**
+ * Default rate limit (requests per second) for Turvo API calls.
+ */
+export const DEFAULT_RATE_LIMIT_RPS = 1;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLFlBQVksQ0FBQTtBQUU3Qzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSx3QkFBd0IsR0FBRyxLQUFLLENBQUE7QUFFN0M7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSx1QkFBdUIsR0FBRyxDQUFDLENBQUE7QUFFeEM7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxDQUFDLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIERlZmF1bHQgc2VjcmV0IHBhdGggZm9yIFR1cnZvIGNyZWRlbnRpYWxzIGluIEFXUyBTZWNyZXRzIE1hbmFnZXIuXG4gKiBFeHBvcnQgdGhpcyBzbyBjb25zdW1lcnMgY2FuIGdyYW50IElBTSBwZXJtaXNzaW9ucy5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHlwZXNjcmlwdFxuICogaW1wb3J0IHsgVFVSVk9fU0VDUkVUX1BBVEggfSBmcm9tICdAdmVoby90dXJ2by1zZGsnXG4gKlxuICogLy8gSW4gQ0RLIHN0YWNrXG4gKiBteUxhbWJkYS5hZGRUb1JvbGVQb2xpY3kobmV3IGlhbS5Qb2xpY3lTdGF0ZW1lbnQoe1xuICogICBhY3Rpb25zOiBbJ3NlY3JldHNtYW5hZ2VyOkdldFNlY3JldFZhbHVlJ10sXG4gKiAgIHJlc291cmNlczogW2Bhcm46YXdzOnNlY3JldHNtYW5hZ2VyOio6KjpzZWNyZXQ6JHtUVVJWT19TRUNSRVRfUEFUSH0qYF0sXG4gKiB9KSlcbiAqIGBgYFxuICovXG5leHBvcnQgY29uc3QgVFVSVk9fU0VDUkVUX1BBVEggPSAnL3R1cnZvL2FwaSdcblxuLyoqXG4gKiBEZWZhdWx0IEFQSSByb3V0ZSBwcmVmaXggZm9yIFR1cnZvIGVuZHBvaW50cy5cbiAqIEN1cnJlbnRseSwgVHVydm8gdXNlcyBhIGNvbW1vbiBwcmVmaXggb2YgXCIvdjFcIiBmb3IgYWxsIGRvY3VtZW50ZWQgQVBJIHJvdXRlcy5cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfQVBJX1JPVVRFX1BSRUZJWCA9ICcvdjEnXG5cbi8qKlxuICogRGVmYXVsdCBudW1iZXIgb2YgcmV0cnkgYXR0ZW1wdHMgZm9yIGZhaWxlZCByZXF1ZXN0cy5cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfQUxMT1dFRF9SRVRSSUVTID0gMlxuXG4vKipcbiAqIERlZmF1bHQgcmF0ZSBsaW1pdCAocmVxdWVzdHMgcGVyIHNlY29uZCkgZm9yIFR1cnZvIEFQSSBjYWxscy5cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfUkFURV9MSU1JVF9SUFMgPSAxXG4iXX0=

package/lib/esm/index.d.ts

@@ -0,0 +1,6 @@
+export { getShipmentTracking } from './shipmentTracking';
+export { TurvoInternalApi } from './api/turvoInternalApi';
+export { TurvoPublicApi } from './api/turvoPublicApi';
+export { clearCachedAccessToken, TurvoClient } from './client/turvoClient';
+export * from './types';
+export { DEFAULT_ALLOWED_RETRIES, DEFAULT_API_ROUTE_PREFIX, DEFAULT_RATE_LIMIT_RPS, TURVO_SECRET_PATH, } from './constants';

package/lib/esm/index.js

@@ -0,0 +1,11 @@
+// Main tracking function
+export { getShipmentTracking } from './shipmentTracking';
+// Client classes (for advanced usage)
+export { TurvoInternalApi } from './api/turvoInternalApi';
+export { TurvoPublicApi } from './api/turvoPublicApi';
+export { clearCachedAccessToken, TurvoClient } from './client/turvoClient';
+// All types
+export * from './types';
+// Constants
+export { DEFAULT_ALLOWED_RETRIES, DEFAULT_API_ROUTE_PREFIX, DEFAULT_RATE_LIMIT_RPS, TURVO_SECRET_PATH, } from './constants';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEseUJBQXlCO0FBQ3pCLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFBO0FBRXhELHNDQUFzQztBQUN0QyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQTtBQUN6RCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sc0JBQXNCLENBQUE7QUFDckQsT0FBTyxFQUFFLHNCQUFzQixFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFBO0FBRTFFLFlBQVk7QUFDWixjQUFjLFNBQVMsQ0FBQTtBQUV2QixZQUFZO0FBQ1osT0FBTyxFQUNMLHVCQUF1QixFQUN2Qix3QkFBd0IsRUFDeEIsc0JBQXNCLEVBQ3RCLGlCQUFpQixHQUNsQixNQUFNLGFBQWEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8vIE1haW4gdHJhY2tpbmcgZnVuY3Rpb25cbmV4cG9ydCB7IGdldFNoaXBtZW50VHJhY2tpbmcgfSBmcm9tICcuL3NoaXBtZW50VHJhY2tpbmcnXG5cbi8vIENsaWVudCBjbGFzc2VzIChmb3IgYWR2YW5jZWQgdXNhZ2UpXG5leHBvcnQgeyBUdXJ2b0ludGVybmFsQXBpIH0gZnJvbSAnLi9hcGkvdHVydm9JbnRlcm5hbEFwaSdcbmV4cG9ydCB7IFR1cnZvUHVibGljQXBpIH0gZnJvbSAnLi9hcGkvdHVydm9QdWJsaWNBcGknXG5leHBvcnQgeyBjbGVhckNhY2hlZEFjY2Vzc1Rva2VuLCBUdXJ2b0NsaWVudCB9IGZyb20gJy4vY2xpZW50L3R1cnZvQ2xpZW50J1xuXG4vLyBBbGwgdHlwZXNcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnXG5cbi8vIENvbnN0YW50c1xuZXhwb3J0IHtcbiAgREVGQVVMVF9BTExPV0VEX1JFVFJJRVMsXG4gIERFRkFVTFRfQVBJX1JPVVRFX1BSRUZJWCxcbiAgREVGQVVMVF9SQVRFX0xJTUlUX1JQUyxcbiAgVFVSVk9fU0VDUkVUX1BBVEgsXG59IGZyb20gJy4vY29uc3RhbnRzJ1xuIl19

package/lib/esm/shipmentTracking/index.d.ts

@@ -0,0 +1,22 @@
+import { GetTrackingOptions, ShipmentTracking } from '../types/tracking';
+/**
+ * Main function to fetch shipment tracking data from Turvo.
+ * Combines public API (shipment details) with internal API (GPS tracking).
+ *
+ * @param shipmentId - The Turvo shipment ID to track
+ * @param options - Optional configuration for tracking request
+ * @returns Complete shipment tracking information
+ *
+ * @example
+ * ```typescript
+ * import { getShipmentTracking } from '@veho/turvo-sdk'
+ *
+ * const tracking = await getShipmentTracking('12345', {
+ *   includeGps: true,
+ *   secretPath: '/turvo/api'
+ * })
+ *
+ * console.log(tracking.status, tracking.etaUtc, tracking.isLate)
+ * ```
+ */
+export declare function getShipmentTracking(shipmentId: string, options?: GetTrackingOptions): Promise<ShipmentTracking>;

package/lib/esm/shipmentTracking/index.js

@@ -0,0 +1,36 @@
+import { TurvoInternalApi } from '../api/turvoInternalApi';
+import { TurvoPublicApi } from '../api/turvoPublicApi';
+import { TurvoClient } from '../client/turvoClient';
+import { TrackingService } from './trackingService';
+/**
+ * Main function to fetch shipment tracking data from Turvo.
+ * Combines public API (shipment details) with internal API (GPS tracking).
+ *
+ * @param shipmentId - The Turvo shipment ID to track
+ * @param options - Optional configuration for tracking request
+ * @returns Complete shipment tracking information
+ *
+ * @example
+ * ```typescript
+ * import { getShipmentTracking } from '@veho/turvo-sdk'
+ *
+ * const tracking = await getShipmentTracking('12345', {
+ *   includeGps: true,
+ *   secretPath: '/turvo/api'
+ * })
+ *
+ * console.log(tracking.status, tracking.etaUtc, tracking.isLate)
+ * ```
+ */
+export async function getShipmentTracking(shipmentId, options = {}) {
+    // Create client with optional custom secret path
+    const client = new TurvoClient(options.secretPath);
+    // Create API instances
+    const publicApi = new TurvoPublicApi(client);
+    const internalApi = new TurvoInternalApi(client);
+    // Create tracking service
+    const trackingService = new TrackingService(publicApi, internalApi);
+    // Fetch and return tracking data
+    return trackingService.getTracking(shipmentId, options);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2hpcG1lbnRUcmFja2luZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQTtBQUMxRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sdUJBQXVCLENBQUE7QUFDdEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHVCQUF1QixDQUFBO0FBRW5ELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQTtBQUVuRDs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW1CRztBQUNILE1BQU0sQ0FBQyxLQUFLLFVBQVUsbUJBQW1CLENBQ3ZDLFVBQWtCLEVBQ2xCLFVBQThCLEVBQUU7SUFFaEMsaURBQWlEO0lBQ2pELE1BQU0sTUFBTSxHQUFHLElBQUksV0FBVyxDQUFDLE9BQU8sQ0FBQyxVQUFVLENBQUMsQ0FBQTtJQUVsRCx1QkFBdUI7SUFDdkIsTUFBTSxTQUFTLEdBQUcsSUFBSSxjQUFjLENBQUMsTUFBTSxDQUFDLENBQUE7SUFDNUMsTUFBTSxXQUFXLEdBQUcsSUFBSSxnQkFBZ0IsQ0FBQyxNQUFNLENBQUMsQ0FBQTtJQUVoRCwwQkFBMEI7SUFDMUIsTUFBTSxlQUFlLEdBQUcsSUFBSSxlQUFlLENBQUMsU0FBUyxFQUFFLFdBQVcsQ0FBQyxDQUFBO0lBRW5FLGlDQUFpQztJQUNqQyxPQUFPLGVBQWUsQ0FBQyxXQUFXLENBQUMsVUFBVSxFQUFFLE9BQU8sQ0FBQyxDQUFBO0FBQ3pELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUdXJ2b0ludGVybmFsQXBpIH0gZnJvbSAnLi4vYXBpL3R1cnZvSW50ZXJuYWxBcGknXG5pbXBvcnQgeyBUdXJ2b1B1YmxpY0FwaSB9IGZyb20gJy4uL2FwaS90dXJ2b1B1YmxpY0FwaSdcbmltcG9ydCB7IFR1cnZvQ2xpZW50IH0gZnJvbSAnLi4vY2xpZW50L3R1cnZvQ2xpZW50J1xuaW1wb3J0IHsgR2V0VHJhY2tpbmdPcHRpb25zLCBTaGlwbWVudFRyYWNraW5nIH0gZnJvbSAnLi4vdHlwZXMvdHJhY2tpbmcnXG5pbXBvcnQgeyBUcmFja2luZ1NlcnZpY2UgfSBmcm9tICcuL3RyYWNraW5nU2VydmljZSdcblxuLyoqXG4gKiBNYWluIGZ1bmN0aW9uIHRvIGZldGNoIHNoaXBtZW50IHRyYWNraW5nIGRhdGEgZnJvbSBUdXJ2by5cbiAqIENvbWJpbmVzIHB1YmxpYyBBUEkgKHNoaXBtZW50IGRldGFpbHMpIHdpdGggaW50ZXJuYWwgQVBJIChHUFMgdHJhY2tpbmcpLlxuICpcbiAqIEBwYXJhbSBzaGlwbWVudElkIC0gVGhlIFR1cnZvIHNoaXBtZW50IElEIHRvIHRyYWNrXG4gKiBAcGFyYW0gb3B0aW9ucyAtIE9wdGlvbmFsIGNvbmZpZ3VyYXRpb24gZm9yIHRyYWNraW5nIHJlcXVlc3RcbiAqIEByZXR1cm5zIENvbXBsZXRlIHNoaXBtZW50IHRyYWNraW5nIGluZm9ybWF0aW9uXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIGltcG9ydCB7IGdldFNoaXBtZW50VHJhY2tpbmcgfSBmcm9tICdAdmVoby90dXJ2by1zZGsnXG4gKlxuICogY29uc3QgdHJhY2tpbmcgPSBhd2FpdCBnZXRTaGlwbWVudFRyYWNraW5nKCcxMjM0NScsIHtcbiAqICAgaW5jbHVkZUdwczogdHJ1ZSxcbiAqICAgc2VjcmV0UGF0aDogJy90dXJ2by9hcGknXG4gKiB9KVxuICpcbiAqIGNvbnNvbGUubG9nKHRyYWNraW5nLnN0YXR1cywgdHJhY2tpbmcuZXRhVXRjLCB0cmFja2luZy5pc0xhdGUpXG4gKiBgYGBcbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGdldFNoaXBtZW50VHJhY2tpbmcoXG4gIHNoaXBtZW50SWQ6IHN0cmluZyxcbiAgb3B0aW9uczogR2V0VHJhY2tpbmdPcHRpb25zID0ge31cbik6IFByb21pc2U8U2hpcG1lbnRUcmFja2luZz4ge1xuICAvLyBDcmVhdGUgY2xpZW50IHdpdGggb3B0aW9uYWwgY3VzdG9tIHNlY3JldCBwYXRoXG4gIGNvbnN0IGNsaWVudCA9IG5ldyBUdXJ2b0NsaWVudChvcHRpb25zLnNlY3JldFBhdGgpXG5cbiAgLy8gQ3JlYXRlIEFQSSBpbnN0YW5jZXNcbiAgY29uc3QgcHVibGljQXBpID0gbmV3IFR1cnZvUHVibGljQXBpKGNsaWVudClcbiAgY29uc3QgaW50ZXJuYWxBcGkgPSBuZXcgVHVydm9JbnRlcm5hbEFwaShjbGllbnQpXG5cbiAgLy8gQ3JlYXRlIHRyYWNraW5nIHNlcnZpY2VcbiAgY29uc3QgdHJhY2tpbmdTZXJ2aWNlID0gbmV3IFRyYWNraW5nU2VydmljZShwdWJsaWNBcGksIGludGVybmFsQXBpKVxuXG4gIC8vIEZldGNoIGFuZCByZXR1cm4gdHJhY2tpbmcgZGF0YVxuICByZXR1cm4gdHJhY2tpbmdTZXJ2aWNlLmdldFRyYWNraW5nKHNoaXBtZW50SWQsIG9wdGlvbnMpXG59XG4iXX0=

package/lib/esm/shipmentTracking/trackingService.d.ts

@@ -0,0 +1,25 @@
+import { TurvoInternalApi } from '../api/turvoInternalApi';
+import { TurvoPublicApi } from '../api/turvoPublicApi';
+import { GetTrackingOptions, ShipmentTracking } from '../types/tracking';
+/**
+ * TrackingService orchestrates calls to public and internal APIs
+ * to provide a unified shipment tracking interface.
+ */
+export declare class TrackingService {
+    private publicApi;
+    private internalApi;
+    constructor(publicApi: TurvoPublicApi, internalApi: TurvoInternalApi);
+    /**
+     * Main entry point - combines all API data to produce ShipmentTracking
+     *
+     * @param shipmentId - The shipment ID to track
+     * @param options - Tracking options
+     * @returns Complete shipment tracking information
+     */
+    getTracking(shipmentId: string, options?: GetTrackingOptions): Promise<ShipmentTracking>;
+    /**
+     * Transform raw Turvo API responses into clean ShipmentTracking type
+     *
+     */
+    private transformToTrackingDetails;
+}

package/lib/esm/shipmentTracking/trackingService.js

@@ -0,0 +1,81 @@
+import { TurvoNotFoundError } from '../types/errors';
+/**
+ * TrackingService orchestrates calls to public and internal APIs
+ * to provide a unified shipment tracking interface.
+ */
+export class TrackingService {
+    publicApi;
+    internalApi;
+    constructor(publicApi, internalApi) {
+        this.publicApi = publicApi;
+        this.internalApi = internalApi;
+    }
+    /**
+     * Main entry point - combines all API data to produce ShipmentTracking
+     *
+     * @param shipmentId - The shipment ID to track
+     * @param options - Tracking options
+     * @returns Complete shipment tracking information
+     */
+    async getTracking(shipmentId, options = {}) {
+        // 1. Fetch public API data (required)
+        const shipmentResult = await this.publicApi.getShipment({ shipmentId: parseInt(shipmentId) });
+        if (!shipmentResult.details) {
+            throw new TurvoNotFoundError(shipmentId);
+        }
+        const shipment = shipmentResult.details;
+        // 2. Fetch internal API data (optional, may fail)
+        let locationUpdates = null;
+        let internalApiFailed = false;
+        if (options.includeGps !== false) {
+            try {
+                locationUpdates = await this.internalApi.getLocationUpdates(shipmentId);
+            }
+            catch (error) {
+                // Log but don't fail - internal API is optional
+                internalApiFailed = true;
+            }
+        }
+        // 3. Transform to clean response
+        return this.transformToTrackingDetails(shipment, locationUpdates, internalApiFailed);
+    }
+    /**
+     * Transform raw Turvo API responses into clean ShipmentTracking type
+     *
+     */
+    transformToTrackingDetails(shipment, locationUpdates, internalApiFailed) {
+        const shipmentData = shipment;
+        return {
+            // Identifiers
+            shipmentId: shipmentData.id?.toString() || '',
+            loadReferenceNumber: shipmentData.customId || '',
+            // Status
+            status: shipmentData.status?.code?.value || 'Unknown',
+            lateBy: shipment.status.runningLate?.lateDurationString ?? null,
+            isLate: !!shipment.status.runningLate,
+            // Current location (if tracking available)
+            currentLocation: shipment.status.location ?? null,
+            hasGpsTracking: locationUpdates !== null && !internalApiFailed,
+            // Progress
+            completedStops: 0, // TODO: Count from shipmentData.globalRoute
+            totalStops: shipmentData.globalRoute?.length || 0, // TODO: parse from shipmentData.globalRoute
+            // Stops (ordered)
+            stops: [], // TODO: implment global route parsing
+            // ETA & Distance
+            etaUtc: shipment.status.attributes?.etaValUtc ?? null,
+            etaTimezone: shipment.status.attributes?.next_eta_cal_val_timezone ?? null,
+            milesRemaining: shipment.status.location?.nextMiles ?? null,
+            totalMiles: null, // TODO: Derive from global route -- find current stop, and figure out total distance leading to it
+            // GPS Pings (only populated if includeGps: true and hasGpsTracking)
+            locationUpdates: locationUpdates || null, // TODO: implment with scraper
+            pingCount: locationUpdates?.length || null, // TODO: implement with scraper
+            lastPingAt: locationUpdates?.[(locationUpdates?.length || 0) - 1]?.timestamp ||
+                null, // TODO: implement with scraper
+            // Shipment Attributes
+            laneType: shipment.flexAttributes?.find(attribute => attribute.name === 'Lane Type')?.value ?? null,
+            managementType: shipment.flexAttributes?.find(attribute => attribute.name === 'Management Type')?.value ?? null,
+            carrier: shipmentData.carrierOrder?.[0]?.carrier?.name || null,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"trackingService.js","sourceRoot":"","sources":["../../../src/shipmentTracking/trackingService.ts"],"names":[],"mappings":"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","sourcesContent":["import { TurvoInternalApi } from '../api/turvoInternalApi'\nimport { TurvoPublicApi } from '../api/turvoPublicApi'\nimport { TurvoShipment } from '../types'\nimport { TurvoNotFoundError } from '../types/errors'\nimport { GetTrackingOptions, LocationUpdate, ShipmentTracking } from '../types/tracking'\n\n/**\n * TrackingService orchestrates calls to public and internal APIs\n * to provide a unified shipment tracking interface.\n */\nexport class TrackingService {\n  constructor(\n    private publicApi: TurvoPublicApi,\n    private internalApi: TurvoInternalApi\n  ) {}\n\n  /**\n   * Main entry point - combines all API data to produce ShipmentTracking\n   *\n   * @param shipmentId - The shipment ID to track\n   * @param options - Tracking options\n   * @returns Complete shipment tracking information\n   */\n  async getTracking(shipmentId: string, options: GetTrackingOptions = {}): Promise<ShipmentTracking> {\n    // 1. Fetch public API data (required)\n    const shipmentResult = await this.publicApi.getShipment({ shipmentId: parseInt(shipmentId) })\n\n    if (!shipmentResult.details) {\n      throw new TurvoNotFoundError(shipmentId)\n    }\n\n    const shipment = shipmentResult.details\n\n    // 2. Fetch internal API data (optional, may fail)\n    let locationUpdates: LocationUpdate[] | null = null\n    let internalApiFailed = false\n\n    if (options.includeGps !== false) {\n      try {\n        locationUpdates = await this.internalApi.getLocationUpdates(shipmentId)\n      } catch (error) {\n        // Log but don't fail - internal API is optional\n        internalApiFailed = true\n      }\n    }\n\n    // 3. Transform to clean response\n    return this.transformToTrackingDetails(shipment, locationUpdates, internalApiFailed)\n  }\n\n  /**\n   * Transform raw Turvo API responses into clean ShipmentTracking type\n   *\n   */\n  private transformToTrackingDetails(\n    shipment: TurvoShipment,\n    locationUpdates: LocationUpdate[] | null,\n    internalApiFailed: boolean\n  ): ShipmentTracking {\n    const shipmentData = shipment as TurvoShipment\n    return {\n      // Identifiers\n      shipmentId: (shipmentData.id as number)?.toString() || '',\n      loadReferenceNumber: (shipmentData.customId as string) || '',\n\n      // Status\n      status: (shipmentData.status?.code?.value as string) || 'Unknown',\n      lateBy: shipment.status.runningLate?.lateDurationString ?? null,\n      isLate: !!shipment.status.runningLate,\n\n      // Current location (if tracking available)\n      currentLocation: shipment.status.location ?? null,\n      hasGpsTracking: locationUpdates !== null && !internalApiFailed,\n\n      // Progress\n      completedStops: 0, // TODO: Count from shipmentData.globalRoute\n      totalStops: (shipmentData.globalRoute as unknown[])?.length || 0, // TODO: parse from shipmentData.globalRoute\n\n      // Stops (ordered)\n      stops: [], // TODO: implment global route parsing\n\n      // ETA & Distance\n      etaUtc: shipment.status.attributes?.etaValUtc ?? null,\n      etaTimezone: shipment.status.attributes?.next_eta_cal_val_timezone ?? null,\n      milesRemaining: shipment.status.location?.nextMiles ?? null,\n      totalMiles: null, // TODO: Derive from global route -- find current stop, and figure out total distance leading to it\n\n      // GPS Pings (only populated if includeGps: true and hasGpsTracking)\n      locationUpdates: (locationUpdates as LocationUpdate[]) || null, // TODO: implment with scraper\n      pingCount: (locationUpdates as LocationUpdate[])?.length || null, // TODO: implement with scraper\n      lastPingAt:\n        (locationUpdates as LocationUpdate[])?.[((locationUpdates as LocationUpdate[])?.length || 0) - 1]?.timestamp ||\n        null, // TODO: implement with scraper\n\n      // Shipment Attributes\n      laneType: shipment.flexAttributes?.find(attribute => attribute.name === 'Lane Type')?.value ?? null,\n      managementType: shipment.flexAttributes?.find(attribute => attribute.name === 'Management Type')?.value ?? null,\n      carrier:\n        ((\n          ((shipmentData.carrierOrder as unknown[])?.[0] as Record<string, unknown>)?.carrier as Record<string, unknown>\n        )?.name as string) || null,\n    }\n  }\n}\n"]}