@oway/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,381 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Oway: () => Oway,
+  OwayEnvironments: () => OwayEnvironments,
+  OwayError: () => OwayError,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var OwayError = class extends Error {
+  constructor(message, code, statusCode, requestId) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    this.name = "OwayError";
+  }
+  /**
+   * Determines if this error represents a transient failure that should be retried
+   */
+  isRetryable() {
+    if (!this.statusCode) return false;
+    if (this.statusCode === 429) return true;
+    if (this.statusCode === 503) return true;
+    if (this.statusCode === 500) return true;
+    if (this.statusCode === 501) return false;
+    if (this.statusCode === 502) return true;
+    if (this.statusCode === 504) return true;
+    if (this.statusCode >= 500) return true;
+    return false;
+  }
+};
+var HttpClient = class {
+  constructor(config) {
+    this.accessToken = null;
+    this.tokenExpiry = 0;
+    this.tokenRefreshPromise = null;
+    if (!config.clientId || !config.clientSecret) {
+      throw new OwayError("clientId and clientSecret are required. Contact Oway Sales Engineering to obtain M2M credentials.");
+    }
+    this.config = {
+      baseUrl: config.baseUrl || process.env.OWAY_BASE_URL || "https://rest-api.sandbox.oway.io",
+      tokenUrl: config.tokenUrl || (config.baseUrl || process.env.OWAY_BASE_URL || "https://rest-api.sandbox.oway.io") + "/v1/auth/token",
+      maxRetries: config.maxRetries ?? 3,
+      timeout: config.timeout ?? 3e4,
+      debug: config.debug ?? false,
+      clientId: config.clientId,
+      clientSecret: config.clientSecret,
+      apiKey: config.apiKey,
+      // Optional default company API key
+      logger: config.logger
+    };
+    this.log("debug", "Oway SDK initialized", {
+      baseUrl: this.config.baseUrl,
+      authMode: "M2M",
+      hasDefaultApiKey: !!this.config.apiKey
+    });
+  }
+  /**
+   * Internal logging with sanitization
+   */
+  log(level, message, meta) {
+    if (!this.config.debug && level === "debug") return;
+    const sanitized = meta ? this.sanitizeForLogging(meta) : void 0;
+    if (this.config.logger) {
+      this.config.logger[level](message, sanitized);
+    } else if (this.config.debug && level !== "debug") {
+      console[level === "error" ? "error" : "log"](`[Oway ${level}]`, message, sanitized);
+    }
+  }
+  /**
+   * Sanitize objects for logging - remove sensitive fields
+   */
+  sanitizeForLogging(obj) {
+    if (!obj || typeof obj !== "object") return obj;
+    const sensitive = ["apiKey", "token", "authorization", "password", "secret"];
+    const sanitized = Array.isArray(obj) ? [] : {};
+    for (const [key, value] of Object.entries(obj)) {
+      const lowerKey = key.toLowerCase();
+      if (sensitive.some((s) => lowerKey.includes(s))) {
+        sanitized[key] = "[REDACTED]";
+      } else if (value && typeof value === "object") {
+        sanitized[key] = this.sanitizeForLogging(value);
+      } else {
+        sanitized[key] = value;
+      }
+    }
+    return sanitized;
+  }
+  /**
+   * Get or refresh the access token using the API key
+   * Handles concurrent requests by queuing them behind a single refresh
+   */
+  async getAccessToken() {
+    if (this.tokenRefreshPromise) {
+      this.log("debug", "Waiting for token refresh in progress");
+      return this.tokenRefreshPromise;
+    }
+    if (this.accessToken && Date.now() < this.tokenExpiry - 5 * 60 * 1e3) {
+      return this.accessToken;
+    }
+    this.log("debug", "Refreshing access token");
+    this.tokenRefreshPromise = this.refreshToken();
+    try {
+      this.accessToken = await this.tokenRefreshPromise;
+      this.log("info", "Access token refreshed", {
+        expiresAt: new Date(this.tokenExpiry).toISOString()
+      });
+      return this.accessToken;
+    } finally {
+      this.tokenRefreshPromise = null;
+    }
+  }
+  /**
+   * Perform the actual token refresh using M2M credentials
+   */
+  async refreshToken() {
+    try {
+      this.log("debug", "Refreshing M2M access token");
+      const response = await fetch(this.config.tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          clientId: this.config.clientId,
+          clientSecret: this.config.clientSecret
+        })
+      });
+      if (!response.ok) {
+        throw new OwayError(
+          "Failed to obtain access token",
+          "AUTH_FAILED",
+          response.status
+        );
+      }
+      const data = await response.json();
+      this.tokenExpiry = Date.now() + data.expires_in * 1e3;
+      return data.access_token;
+    } catch (error) {
+      this.log("error", "Token refresh failed", {
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+      if (error instanceof OwayError) throw error;
+      throw new OwayError(
+        `Authentication failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "AUTH_ERROR"
+      );
+    }
+  }
+  /**
+   * Generate a unique request ID
+   */
+  generateRequestId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+      const r = Math.random() * 16 | 0;
+      const v = c === "x" ? r : r & 3 | 8;
+      return v.toString(16);
+    });
+  }
+  /**
+   * Make an authenticated request to the Oway API
+   */
+  async request(method, path, options = {}) {
+    const token = await this.getAccessToken();
+    const url = new URL(path, this.config.baseUrl);
+    const requestId = options.requestId || this.generateRequestId();
+    if (options.query) {
+      Object.entries(options.query).forEach(([key, value]) => {
+        url.searchParams.append(key, String(value));
+      });
+    }
+    const apiKey = options.companyApiKey || this.config.companyApiKey || this.config.apiKey;
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token}`,
+      "x-request-id": requestId,
+      ...options.headers
+    };
+    if (apiKey) {
+      headers["x-oway-api-key"] = apiKey;
+    }
+    this.log("debug", `${method} ${path}`, {
+      requestId,
+      hasBody: !!options.body,
+      query: options.query
+    });
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        const response = await fetch(url.toString(), {
+          method,
+          headers,
+          body: options.body ? JSON.stringify(options.body) : void 0,
+          signal: controller.signal
+        });
+        clearTimeout(timeoutId);
+        const serverRequestId = response.headers.get("x-request-id") || requestId;
+        if (!response.ok) {
+          let errorData;
+          try {
+            errorData = await response.json();
+          } catch {
+            errorData = { message: response.statusText };
+          }
+          const error = new OwayError(
+            errorData.message || `Request failed with status ${response.status}`,
+            errorData.code || "API_ERROR",
+            response.status,
+            serverRequestId
+          );
+          this.log("warn", "Request failed", {
+            method,
+            path,
+            status: response.status,
+            requestId: serverRequestId,
+            attempt: attempt + 1,
+            isRetryable: error.isRetryable()
+          });
+          throw error;
+        }
+        this.log("debug", "Request successful", {
+          method,
+          path,
+          status: response.status,
+          requestId: serverRequestId
+        });
+        if (response.status === 204) {
+          return {};
+        }
+        return await response.json();
+      } catch (error) {
+        lastError = error;
+        if (error instanceof OwayError && !error.isRetryable()) {
+          this.log("error", "Non-retryable error", {
+            requestId,
+            code: error.code,
+            statusCode: error.statusCode
+          });
+          throw error;
+        }
+        if (attempt === this.config.maxRetries) {
+          this.log("error", "Max retries exceeded", {
+            requestId,
+            attempts: attempt + 1
+          });
+          break;
+        }
+        const delay = Math.pow(2, attempt) * 1e3;
+        this.log("warn", "Retrying request", {
+          requestId,
+          attempt: attempt + 1,
+          maxRetries: this.config.maxRetries,
+          delayMs: delay
+        });
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    this.log("error", "Request failed", {
+      requestId,
+      error: lastError instanceof Error ? lastError.message : "Unknown error"
+    });
+    throw lastError || new OwayError("Request failed after retries", "MAX_RETRIES_EXCEEDED", void 0, requestId);
+  }
+  async get(path, query, companyApiKey) {
+    return this.request("GET", path, { query, companyApiKey });
+  }
+  async post(path, body, companyApiKey) {
+    return this.request("POST", path, { body, companyApiKey });
+  }
+  async put(path, body, companyApiKey) {
+    return this.request("PUT", path, { body, companyApiKey });
+  }
+  async delete(path, companyApiKey) {
+    return this.request("DELETE", path, { companyApiKey });
+  }
+};
+
+// src/resources/quotes.ts
+var Quotes = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Request a shipping quote
+   * @param params Quote parameters
+   * @param companyApiKey Optional: Specify company API key for multi-tenant integrations
+   */
+  async create(params, companyApiKey) {
+    return this.client.post("/v1/shipper/quote", params, companyApiKey);
+  }
+  /**
+   * Retrieve a quote by ID
+   * @param quoteId Quote ID
+   * @param companyApiKey Optional: Specify company API key for multi-tenant integrations
+   */
+  async retrieve(quoteId, companyApiKey) {
+    return this.client.get(`/v1/shipper/quote/${quoteId}`, void 0, companyApiKey);
+  }
+};
+
+// src/resources/shipments.ts
+var Shipments = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(params, companyApiKey) {
+    return this.client.post("/v1/shipper/shipment", params, companyApiKey);
+  }
+  async retrieve(orderNumber, companyApiKey) {
+    return this.client.get(`/v1/shipper/shipment/${orderNumber}`, void 0, companyApiKey);
+  }
+  async confirm(orderNumber, companyApiKey) {
+    return this.client.put(`/v1/shipper/shipment/${orderNumber}/confirm`, void 0, companyApiKey);
+  }
+  async cancel(orderNumber, companyApiKey) {
+    return this.client.put(`/v1/shipper/shipment/${orderNumber}/cancel`, void 0, companyApiKey);
+  }
+  async tracking(orderNumber, companyApiKey) {
+    return this.client.get(`/v1/shipper/shipment/${orderNumber}/tracking`, void 0, companyApiKey);
+  }
+  async document(orderNumber, documentType, companyApiKey) {
+    return this.client.get(`/v1/shipper/shipment/${orderNumber}/document/${documentType}`, void 0, companyApiKey);
+  }
+  async invoice(orderNumber, companyApiKey) {
+    return this.client.get(`/v1/shipper/shipment/${orderNumber}/invoice`, void 0, companyApiKey);
+  }
+};
+
+// src/environments.ts
+var OwayEnvironments = {
+  /**
+   * Sandbox environment for development and testing
+   * Safe to use - no real shipments created
+   */
+  SANDBOX: "https://rest-api.sandbox.oway.io",
+  /**
+   * Production environment for live traffic
+   * Real shipments will be created and billed
+   */
+  PRODUCTION: "https://rest-api.oway.io"
+};
+
+// src/index.ts
+var Oway = class {
+  constructor(config) {
+    this.client = new HttpClient(config);
+    this.quotes = new Quotes(this.client);
+    this.shipments = new Shipments(this.client);
+  }
+};
+var index_default = Oway;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Oway,
+  OwayEnvironments,
+  OwayError
+});