GET requests not working

[brianzinn]

You are stripping off query parameters how you are passing the path to create a request. pathname is not correct way.

The fact you don't support typings and don't work at all for searching. I'm just going to write my own implementation using fetch. It will actually be faster for me than trying to get this package working.

[brianzinn]

It looks like this SDK is not supported. Here is a drop in replacement that does work:

export type Tracking = {
  id: string;
  tracking_number: string;
  courier_code: string;
  order_number: string;
  order_date: string;
  created_at: string;
  update_at: string;
  delivery_status: string;
  archived: string;
  updating: boolean;
  destination_country: string;
  destination_state: string;
  destination_city: string;
  origin_country: string;
  origin_state: string;
  origin_city: string;
  tracking_postal_code: string;
  tracking_ship_date: string;
  tracking_destination_country: string;
  tracking_origin_country: string;
  tracking_key: string;
  tracking_courier_account: string;
  customer_name: string;
  customer_email: string;
  customer_sms: string;
  recipient_postcode: string;
  order_id: string;
  title: string;
  logistics_channel: string;
  note: string;
  label: string;
  signed_by: string;
  service_code: string;
  weight: string;
  weight_kg: string;
  product_type: string;
  pieces: string;
  dimension: string;
  previously: string;
  destination_track_number: string;
  exchange_number: string;
  scheduled_delivery_date: string;
  scheduled_address: string;
  substatus: string;
  status_info: string;
  latest_event: string;
  latest_checkpoint_time: string;
  transit_time: number;
  origin_info: {
    courier_code: string;
    courier_phone: string;
    weblink: string;
    reference_number: string;
    milestone_date: {
      inforeceived_date: string;
      pickup_date: string;
      outfordelivery_date: string;
      delivery_date: string;
      returning_date: string;
      returned_date: string;
    };
    'pickup_date (Legacy)': string;
    'departed_airport_date (Legacy)': string;
    'arrived_abroad_date (Legacy)': string;
    'customs_received_date (Legacy)': string;
    'arrived_destination_date (Legacy)': string;
    trackinfo: Record<string, string>[];
  };
  destination_info: {
    courier_code: string;
    courier_phone: string;
    weblink: string;
    reference_number: string;
    milestone_date: {
      inforeceived_date: string;
      pickup_date: string;
      outfordelivery_date: string;
      delivery_date: string;
      returning_date: string;
      returned_date: string;
    };
    'pickup_date (Legacy)': string;
    'departed_airport_date (Legacy)': string;
    'arrived_abroad_date (Legacy)': string;
    'customs_received_date (Legacy)': string;
    'arrived_destination_date (Legacy)': string;
    trackinfo: Record<string, string>[];
  };
};

export type Update = {
  id: string;
  tracking_number: string;
  courier_code: string;
  courier_code_new: string;
  order_number: string;
  order_date: string;
  order_id: string;
  destination_country: string;
  origin_country: string;
  tracking_postal_code: string;
  tracking_ship_date: string;
  tracking_courier_account: string;
  tracking_destination_country: string;
  tracking_origin_country: string;
  tracking_key: string;
  customer_name: string;
  customer_email: string;
  customer_sms: string;
  recipient_postcode: string;
  title: string;
  logistics_channel: string;
  note: string;
  label: string;
  archived_status: string;
};

export type Courier = {
  courier_name: string;
  courier_code: string;
  courier_country_iso2: string;
  courier_url: string;
  courier_phone: string;
  courier_type: string;
  tracking_required_fields: string[];
  optional_fields: string[];
  default_language: string;
  support_language: string[];
  courier_logo: string;
};

export type CreateTrackingParams = {
  tracking_number: string;
  courier_code: string;
  order_number?: string;
  customer_name?: string;
  title?: string;
  language?: string;
  note?: string;
};

export type GetTrackingResultsParams = {
  tracking_numbers: string;
  courier_code: string;
  /**
   * ie: '2023-08-23T06:00:00+00:00'
   */
  created_date_min: string;
  /**
   * ie: '2023-09-05T07:20:42+00:00'
   */
  created_date_max: string;
};

type KnownBadResponseCodes =
  | 400
  | 4101
  | 4102
  | 4103
  | 4110
  | 4111
  | 4112
  | 4113
  | 4120
  | 4121
  | 4122
  | 4130
  | 4131
  | 4160
  | 4161
  | 4162
  | 4163
  | 4165
  | 4166
  | 4190
  | 401
  | 403
  | 404
  | 429
  | 511
  | 512
  | 513;

/**
 * https://www.trackingmore.com/docs/trackingmore/k9nyp168bl46h-api-request-and-response
 *
 * NOTE: TypeScript doesn't do narrowing on a discriminated union on nested fields (ie: code), so the TrackingMore API design isn't amenable "code" narrowing.
 *       Caller needs to check if data is `null`, which could lead to weird guard clauses, but seems to match their documentation.
 */
export type TrackingMoreResponse<T> =
  | {
      meta: {
        code: KnownBadResponseCodes;
        message: string;
      };
      data: null;
    }
  | {
      meta: {
        code: 200;
        message: string;
      };
      data: T;
    };

export default class TrackingMore {
  readonly apiKey: string;
  readonly options: Partial<{
    logTraffic: boolean;
  }>;
  constructor(
    apiKey: string | undefined,
    options?: Partial<{
      logTraffic: boolean;
    }>
  ) {
    if (apiKey === undefined) {
      throw new Error('no api key provided');
    }
    this.apiKey = apiKey;
    this.options = options
      ? options
      : {
          logTraffic: false,
        };
  }

  private BASE_URL = 'api.trackingmore.com';
  private getHeaders = () => ({
    'Tracking-Api-Key': this.apiKey,
    'Content-Type': 'application/json',
    Accept: 'application/json',
    'User-Agent': 'node-sdk',
  });

  getResult = async <T>(res: Response): Promise<T> => {
    const hasJsonContentHeader = (res: Response) => {
      // TODO: consider making this case-insensitive
      const contentType = res.headers.has('content-type')
        ? res.headers.get('content-type')
        : null;
      return contentType && contentType.startsWith('application/json');
    };
    // if (res.ok) {
    const isJson = hasJsonContentHeader(res);
    if (!isJson) {
      console.warn(' > content-type not found for JSON - returning text');
    }

    const data = isJson ? ((await res.json()) as T) : ((await res.text()) as T);
    return data;
  };

  private httpGet = async <T>(
    path: string,
    query?: Record<string, string | number | boolean>
  ): Promise<TrackingMoreResponse<T>> => {
    const url = new URL(`https://${this.BASE_URL}${path}`);
    if (query) {
      for (const param of Object.keys(query)) {
        const val =
          typeof query[param] === 'string'
            ? query[param]
            : query[param].toString();
        url.searchParams.set(param, val);
      }
    }

    const opts = {
      method: 'GET',
      headers: this.getHeaders(),
    };

    if (this.options.logTraffic === true) {
      console.log(` > GET: ${url.href}`);
    }

    const res = await fetch(url.href, opts);
    return this.getResult(res);
  };

  private httpData = async <T>(
    path: string,
    data: object | undefined,
    method: 'POST' | 'PUT' | 'DELETE' = 'POST'
  ): Promise<TrackingMoreResponse<T>> => {
    const url = new URL(`https://${this.BASE_URL}${path}`);

    const opts = {
      method,
      headers: this.getHeaders(),
      body: data !== undefined ? JSON.stringify(data) : undefined,
    };

    if (this.options.logTraffic === true) {
      console.log(` > ${method}: ${url.href}`);
    }

    const res = await fetch(url.href, opts);
    return this.getResult(res);
  };

  couriersApi = {
    detect: async (params: { tracking_number: string }) =>
      this.httpData<Courier[]>('/v4/couriers/detect', params),
    getAllCouriers: async () => this.httpGet<Courier[]>('/v4/couriers/all'),
  };

  get couriers() {
    return this.couriersApi;
  }

  private trackingsApi = {
    createTracking: async (params: CreateTrackingParams) =>
      this.httpData<Tracking>('/v4/trackings/create', params),
    getTrackingResults: async (params: Partial<GetTrackingResultsParams>) =>
      this.httpGet<Tracking[]>('/v4/trackings/get', params),
    updateTrackingByID: (id: string, params: Partial<Update>) =>
      this.httpData<Partial<Tracking>>(
        `/v4/trackings/update/${id}`,
        params,
        'PUT'
      ),
  };

  get trackings() {
    return this.trackingsApi;
  }
}

I wrote it as a drop in replacement to make it backwards compatible. Here is usage for moving trackings identified to wrong carrier, for example:

// copy above code into this file
import TrackingMore from './trackingMoreApi';

// optionally add traffic logging (not part of original code)
const api = new TrackingMore(process.env.TRACKINGMORE_API_KEY, {
      logTraffic: true,
    });

// this does not work on current SDK provided by trackingmore.  you'll get 200 random trackings
const trackingResponse = await api.trackings.getTrackingResults({
        courier_code: 'doortodoor',
      });

if (trackingResponse.data === null) {
        throw new Error(
          ` > GetTrackingResults call failed [${couriersResponse.meta.code}] : ${couriersResponse.meta.message}`
        );
}

for (const tracking of trackingResponse.data) {
    const { id } = tracking;

    if (tracking.delivery_status === 'delivered') {
        // their API and web interface do not allow correcting these.  You'll get a weird error if you try to change the courier.
        console.log(
            ` > skipping delivered: ${tracking.tracking_number} (looking for a solution for this!)`
         );
         continue;
    }

    const updateResponse = await api.trackings.updateTrackingByID(id, {
      courier_code_new: 'fedex',
    });

    if (updateResponse.meta.code !== 200) {
      console.error(` > error: ${updateResponse.meta.message}`);
      continue;
    }
    console.log(
      ` > changed to '${newCourierCode}':`,
      JSON.stringify(updateResponse.meta),
      JSON.stringify(updateResponse.data)
    );
 }