@oway/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,352 @@
+// 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;
+export {
+  Oway,
+  OwayEnvironments,
+  OwayError,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@oway/sdk",
+  "version": "0.1.0",
+  "description": "Official Oway JavaScript/TypeScript SDK",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "generate": "openapi-typescript ../../openapi/spec.json -o src/generated/schema.ts",
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src --ext .ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "oway",
+    "sdk",
+    "typescript",
+    "javascript",
+    "shipping",
+    "logistics",
+    "freight"
+  ],
+  "author": "Oway",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Oway-Inc/oway-sdk.git",
+    "directory": "packages/typescript"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "@vitest/coverage-v8": "^1.6.1",
+    "openapi-typescript": "^7.0.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}