checkout-intents 0.3.0 → 0.5.0

package/src/internal/qs/utils.ts

@@ -0,0 +1,265 @@
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+import { isArray } from '../utils/values';
+
+export let has = (obj: object, key: PropertyKey): boolean => (
+  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
+  has(obj, key)
+);
+
+const hex_table = /* @__PURE__ */ (() => {
+  const array = [];
+  for (let i = 0; i < 256; ++i) {
+    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+  }
+
+  return array;
+})();
+
+function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
+  while (queue.length > 1) {
+    const item = queue.pop();
+    if (!item) continue;
+
+    const obj = item.obj[item.prop];
+
+    if (isArray(obj)) {
+      const compacted: unknown[] = [];
+
+      for (let j = 0; j < obj.length; ++j) {
+        if (typeof obj[j] !== 'undefined') {
+          compacted.push(obj[j]);
+        }
+      }
+
+      // @ts-ignore
+      item.obj[item.prop] = compacted;
+    }
+  }
+}
+
+function array_to_object(source: any[], options: { plainObjects: boolean }) {
+  const obj = options && options.plainObjects ? Object.create(null) : {};
+  for (let i = 0; i < source.length; ++i) {
+    if (typeof source[i] !== 'undefined') {
+      obj[i] = source[i];
+    }
+  }
+
+  return obj;
+}
+
+export function merge(
+  target: any,
+  source: any,
+  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+  if (!source) {
+    return target;
+  }
+
+  if (typeof source !== 'object') {
+    if (isArray(target)) {
+      target.push(source);
+    } else if (target && typeof target === 'object') {
+      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
+        target[source] = true;
+      }
+    } else {
+      return [target, source];
+    }
+
+    return target;
+  }
+
+  if (!target || typeof target !== 'object') {
+    return [target].concat(source);
+  }
+
+  let mergeTarget = target;
+  if (isArray(target) && !isArray(source)) {
+    // @ts-ignore
+    mergeTarget = array_to_object(target, options);
+  }
+
+  if (isArray(target) && isArray(source)) {
+    source.forEach(function (item, i) {
+      if (has(target, i)) {
+        const targetItem = target[i];
+        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+          target[i] = merge(targetItem, item, options);
+        } else {
+          target.push(item);
+        }
+      } else {
+        target[i] = item;
+      }
+    });
+    return target;
+  }
+
+  return Object.keys(source).reduce(function (acc, key) {
+    const value = source[key];
+
+    if (has(acc, key)) {
+      acc[key] = merge(acc[key], value, options);
+    } else {
+      acc[key] = value;
+    }
+    return acc;
+  }, mergeTarget);
+}
+
+export function assign_single_source(target: any, source: any) {
+  return Object.keys(source).reduce(function (acc, key) {
+    acc[key] = source[key];
+    return acc;
+  }, target);
+}
+
+export function decode(str: string, _: any, charset: string) {
+  const strWithoutPlus = str.replace(/\+/g, ' ');
+  if (charset === 'iso-8859-1') {
+    // unescape never throws, no try...catch needed:
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+  }
+  // utf-8
+  try {
+    return decodeURIComponent(strWithoutPlus);
+  } catch (e) {
+    return strWithoutPlus;
+  }
+}
+
+const limit = 1024;
+
+export const encode: (
+  str: any,
+  defaultEncoder: DefaultEncoder,
+  charset: string,
+  type: 'key' | 'value',
+  format: Format,
+) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
+  // This code was originally written by Brian White for the io.js core querystring library.
+  // It has been adapted here for stricter adherence to RFC 3986
+  if (str.length === 0) {
+    return str;
+  }
+
+  let string = str;
+  if (typeof str === 'symbol') {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== 'string') {
+    string = String(str);
+  }
+
+  if (charset === 'iso-8859-1') {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+    });
+  }
+
+  let out = '';
+  for (let j = 0; j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (
+        c === 0x2d || // -
+        c === 0x2e || // .
+        c === 0x5f || // _
+        c === 0x7e || // ~
+        (c >= 0x30 && c <= 0x39) || // 0-9
+        (c >= 0x41 && c <= 0x5a) || // a-z
+        (c >= 0x61 && c <= 0x7a) || // A-Z
+        (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+      ) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+
+      if (c < 0x80) {
+        arr[arr.length] = hex_table[c];
+        continue;
+      }
+
+      if (c < 0x800) {
+        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      if (c < 0xd800 || c >= 0xe000) {
+        arr[arr.length] =
+          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      i += 1;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+
+      arr[arr.length] =
+        hex_table[0xf0 | (c >> 18)]! +
+        hex_table[0x80 | ((c >> 12) & 0x3f)] +
+        hex_table[0x80 | ((c >> 6) & 0x3f)] +
+        hex_table[0x80 | (c & 0x3f)];
+    }
+
+    out += arr.join('');
+  }
+
+  return out;
+};
+
+export function compact(value: any) {
+  const queue = [{ obj: { o: value }, prop: 'o' }];
+  const refs = [];
+
+  for (let i = 0; i < queue.length; ++i) {
+    const item = queue[i];
+    // @ts-ignore
+    const obj = item.obj[item.prop];
+
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; ++j) {
+      const key = keys[j]!;
+      const val = obj[key];
+      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+        queue.push({ obj: obj, prop: key });
+        refs.push(val);
+      }
+    }
+  }
+
+  compact_queue(queue);
+
+  return value;
+}
+
+export function is_regexp(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+export function is_buffer(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+
+export function combine(a: any, b: any) {
+  return [].concat(a, b);
+}
+
+export function maybe_map<T>(val: T[], fn: (v: T) => T) {
+  if (isArray(val)) {
+    const mapped = [];
+    for (let i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]!));
+    }
+    return mapped;
+  }
+  return fn(val);
+}

package/src/pagination.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/pagination instead */
+export * from './core/pagination';

package/src/resources/checkout-intents.ts

@@ -2,11 +2,14 @@
 
 import { APIResource } from '../core/resource';
 import * as CheckoutIntentsAPI from './checkout-intents';
+import { PollTimeoutError } from '../core/error';
 import { APIPromise } from '../core/api-promise';
+import { CursorPagination, type CursorPaginationParams, PagePromise } from '../core/pagination';
 import { RequestOptions } from '../internal/request-options';
 import { path } from '../internal/utils/path';
 import { sleep } from '../internal/utils/sleep';
 import { buildHeaders } from '../internal/headers';
+import { loggerFor } from '../internal/utils/log';
 
 /**
  * Options for polling operations.
@@ -33,11 +36,11 @@ export class CheckoutIntentsResource extends APIResource {
    *   buyer: {
    *     address1: '123 Main St',
    *     city: 'New York',
-   *     country: 'United States',
+   *     country: 'US',
    *     email: 'john.doe@example.com',
    *     firstName: 'John',
    *     lastName: 'Doe',
-   *     phone: '+1234567890',
+   *     phone: '1234567890',
    *     postalCode: '10001',
    *     province: 'NY',
    *   },
@@ -65,6 +68,30 @@ export class CheckoutIntentsResource extends APIResource {
     return this._client.get(path`/api/v1/checkout-intents/${id}`, options);
   }
 
+  /**
+   * Retrieve a paginated list of checkout intents
+   *
+   * Enables developers to query checkout intents associated with their account, with
+   * filters and cursor-based pagination.
+   *
+   * @example
+   * ```ts
+   * // Automatically fetches more pages as needed.
+   * for await (const checkoutIntent of client.checkoutIntents.list()) {
+   *   // ...
+   * }
+   * ```
+   */
+  list(
+    query: CheckoutIntentListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<CheckoutIntentsCursorPagination, CheckoutIntent> {
+    return this._client.getAPIList('/api/v1/checkout-intents', CursorPagination<CheckoutIntent>, {
+      query,
+      ...options,
+    });
+  }
+
   /**
    * Add payment details to a checkout intent
    *
@@ -131,9 +158,16 @@ export class CheckoutIntentsResource extends APIResource {
     condition: (intent: CheckoutIntent) => intent is T,
     options?: RequestOptions & PollOptions,
   ): Promise<T> {
-    const maxAttempts = options?.maxAttempts ?? 120; // Default: 120 attempts
+    let maxAttempts = options?.maxAttempts ?? 120; // Default: 120 attempts
     const pollIntervalMs = options?.pollIntervalMs ?? 5000; // Default: 5 seconds
-    let attempts = 0;
+
+    if (maxAttempts < 1) {
+      loggerFor(this._client).warn(
+        `[Checkout Intents SDK] Invalid maxAttempts value: ${maxAttempts}. maxAttempts must be >= 1. Defaulting to 1 to ensure at least one polling attempt.`,
+      );
+
+      maxAttempts = 1;
+    }
 
     const headers = buildHeaders([
       options?.headers,
@@ -143,12 +177,17 @@ export class CheckoutIntentsResource extends APIResource {
       },
     ]);
 
+    let intent: CheckoutIntentsAPI.CheckoutIntent;
+    let attempts = 0;
+
     while (attempts < maxAttempts) {
-      const { data: intent, response } = await this.retrieve(id, {
+      const { data, response } = await this.retrieve(id, {
         ...options,
         headers: { ...options?.headers, ...headers.values },
       }).withResponse();
 
+      intent = data;
+
       // Check if condition is met
       if (condition(intent)) {
         return intent;
@@ -158,11 +197,15 @@ export class CheckoutIntentsResource extends APIResource {
 
       // If we've reached max attempts, throw an error
       if (attempts >= maxAttempts) {
-        throw new Error(
-          `Polling timeout: condition not met after ${maxAttempts} attempts (${
+        throw new PollTimeoutError({
+          intentId: intent.id,
+          attempts,
+          maxAttempts,
+          pollIntervalMs,
+          message: `Polling timeout: condition not met after ${maxAttempts} attempts (${
             (maxAttempts * pollIntervalMs) / 1000
           }s)`,
-        );
+        });
       }
 
       // Check if server suggests a polling interval
@@ -179,7 +222,13 @@ export class CheckoutIntentsResource extends APIResource {
     }
 
     // This should never be reached due to the throw above, but TypeScript needs it
-    throw new Error(`Polling timeout: condition not met after ${maxAttempts} attempts`);
+    throw new PollTimeoutError({
+      intentId: intent!.id,
+      attempts,
+      maxAttempts,
+      pollIntervalMs,
+      message: `Polling timeout: condition not met after ${maxAttempts} attempts`,
+    });
   }
 
   /**
@@ -257,11 +306,11 @@ export class CheckoutIntentsResource extends APIResource {
    *   buyer: {
    *     address1: '123 Main St',
    *     city: 'New York',
-   *     country: 'United States',
+   *     country: 'US',
    *     email: 'john.doe@example.com',
    *     firstName: 'John',
    *     lastName: 'Doe',
-   *     phone: '+1234567890',
+   *     phone: '1234567890',
    *     postalCode: '10001',
    *     province: 'NY',
    *   },
@@ -319,6 +368,8 @@ export class CheckoutIntentsResource extends APIResource {
   }
 }
 
+export type CheckoutIntentsCursorPagination = CursorPagination<CheckoutIntent>;
+
 export interface BaseCheckoutIntent {
   id: string;
 
@@ -386,6 +437,8 @@ export namespace CheckoutIntent {
   export interface CompletedCheckoutIntent extends CheckoutIntentsAPI.BaseCheckoutIntent {
     offer: CheckoutIntentsAPI.Offer;
 
+    orderId: string | null;
+
     paymentMethod: CheckoutIntentsAPI.PaymentMethod;
 
     state: 'completed';
@@ -413,6 +466,7 @@ export namespace CheckoutIntent {
         | 'developer_not_found'
         | 'missing_shipping_method'
         | 'unsupported_currency'
+        | 'invalid_input'
         | 'unsupported_store_no_guest_checkout';
 
       message: string;
@@ -506,6 +560,12 @@ export interface CheckoutIntentCreateParams {
   variantSelections?: Array<VariantSelection>;
 }
 
+export interface CheckoutIntentListParams extends CursorPaginationParams {
+  id?: Array<string>;
+
+  state?: Array<'retrieving_offer' | 'awaiting_confirmation' | 'placing_order' | 'completed' | 'failed'>;
+}
+
 export interface CheckoutIntentAddPaymentParams {
   paymentMethod: PaymentMethod;
 }
@@ -524,7 +584,9 @@ export declare namespace CheckoutIntentsResource {
     type PaymentMethod as PaymentMethod,
     type PollOptions as PollOptions,
     type VariantSelection as VariantSelection,
+    type CheckoutIntentsCursorPagination as CheckoutIntentsCursorPagination,
     type CheckoutIntentCreateParams as CheckoutIntentCreateParams,
+    type CheckoutIntentListParams as CheckoutIntentListParams,
     type CheckoutIntentAddPaymentParams as CheckoutIntentAddPaymentParams,
     type CheckoutIntentConfirmParams as CheckoutIntentConfirmParams,
   };

package/src/resources/index.ts

@@ -11,6 +11,8 @@ export {
   type PaymentMethod,
   type VariantSelection,
   type CheckoutIntentCreateParams,
+  type CheckoutIntentListParams,
   type CheckoutIntentAddPaymentParams,
   type CheckoutIntentConfirmParams,
+  type CheckoutIntentsCursorPagination,
 } from './checkout-intents';

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.3.0'; // x-release-please-version
+export const VERSION = '0.5.0'; // x-release-please-version

package/version.d.mts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.3.0";
+export declare const VERSION = "0.5.0";
 //# sourceMappingURL=version.d.mts.map

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.3.0";
+export declare const VERSION = "0.5.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.3.0'; // x-release-please-version
+exports.VERSION = '0.5.0'; // x-release-please-version
 //# sourceMappingURL=version.js.map

package/version.mjs

@@ -1,2 +1,2 @@
-export const VERSION = '0.3.0'; // x-release-please-version
+export const VERSION = '0.5.0'; // x-release-please-version
 //# sourceMappingURL=version.mjs.map