@getmandato/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,403 @@
+// src/config.ts
+var DEFAULTS = {
+  baseUrl: "https://api.getmandato.dev",
+  timeout: 3e4,
+  maxRetries: 3
+};
+
+// src/errors.ts
+var MandatoError = class extends Error {
+  /** HTTP status code */
+  status;
+  /** Error type from the API response */
+  type;
+  /** Request ID for support reference */
+  requestId;
+  constructor(message, status, type, requestId) {
+    super(message);
+    this.name = "MandatoError";
+    this.status = status;
+    this.type = type;
+    this.requestId = requestId;
+  }
+};
+var ValidationError = class extends MandatoError {
+  details;
+  constructor(message, details = [], requestId) {
+    super(message, 400, "validation_error", requestId);
+    this.name = "ValidationError";
+    this.details = details;
+  }
+};
+var AuthenticationError = class extends MandatoError {
+  constructor(message = "Invalid API key", requestId) {
+    super(message, 401, "authentication_error", requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var ForbiddenError = class extends MandatoError {
+  constructor(message = "Forbidden", requestId) {
+    super(message, 403, "forbidden_error", requestId);
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends MandatoError {
+  constructor(message = "Resource not found", requestId) {
+    super(message, 404, "not_found_error", requestId);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends MandatoError {
+  constructor(message = "Idempotency conflict", requestId) {
+    super(message, 409, "conflict_error", requestId);
+    this.name = "ConflictError";
+  }
+};
+var RateLimitError = class extends MandatoError {
+  /** Requests per minute allowed */
+  limit;
+  /** Seconds until the rate limit resets */
+  retryAfter;
+  constructor(message, limit, retryAfter, requestId) {
+    super(message, 429, "rate_limit_error", requestId);
+    this.name = "RateLimitError";
+    this.limit = limit;
+    this.retryAfter = retryAfter;
+  }
+};
+var ServerError = class extends MandatoError {
+  constructor(message = "Internal server error", status = 500, requestId) {
+    super(message, status, "server_error", requestId);
+    this.name = "ServerError";
+  }
+};
+
+// src/http.ts
+var MandatoHttpClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = (config.baseUrl ?? DEFAULTS.baseUrl).replace(/\/+$/, "");
+    this.timeout = config.timeout ?? DEFAULTS.timeout;
+    this.maxRetries = config.maxRetries ?? DEFAULTS.maxRetries;
+  }
+  /** Make a GET request */
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    return this.request("GET", url);
+  }
+  /** Make a POST request */
+  async post(path, body, headers) {
+    const url = this.buildUrl(path);
+    return this.request("POST", url, body, headers);
+  }
+  /** Make a PATCH request */
+  async patch(path, body) {
+    const url = this.buildUrl(path);
+    return this.request("PATCH", url, body);
+  }
+  /** Make a DELETE request */
+  async delete(path) {
+    const url = this.buildUrl(path);
+    return this.request("DELETE", url);
+  }
+  /** Build full URL with optional query params */
+  buildUrl(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /** Execute an HTTP request with retries and error mapping */
+  async request(method, url, body, extraHeaders) {
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delay = Math.min(500 * 2 ** (attempt - 1), 1e4);
+        await sleep(delay);
+      }
+      try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const headers = {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+          ...extraHeaders
+        };
+        const init = {
+          method,
+          headers,
+          signal: controller.signal
+        };
+        if (body !== void 0 && method !== "GET") {
+          init.body = JSON.stringify(body);
+        }
+        const response = await fetch(url, init);
+        clearTimeout(timeoutId);
+        if (response.ok) {
+          return await response.json();
+        }
+        const errorBody = await this.parseErrorBody(response);
+        const requestId = errorBody?.error?.requestId;
+        if (response.status === 400) {
+          throw new ValidationError(
+            errorBody?.error?.message ?? "Validation error",
+            errorBody?.error?.details,
+            requestId
+          );
+        }
+        if (response.status === 401) {
+          throw new AuthenticationError(errorBody?.error?.message, requestId);
+        }
+        if (response.status === 403) {
+          throw new ForbiddenError(errorBody?.error?.message, requestId);
+        }
+        if (response.status === 404) {
+          throw new NotFoundError(errorBody?.error?.message, requestId);
+        }
+        if (response.status === 409) {
+          throw new ConflictError(errorBody?.error?.message, requestId);
+        }
+        if (response.status === 429) {
+          const limitHeader = response.headers.get("X-RateLimit-Limit");
+          const retryAfter = response.headers.get("Retry-After");
+          lastError = new RateLimitError(
+            errorBody?.error?.message ?? "Rate limit exceeded",
+            limitHeader ? Number(limitHeader) : void 0,
+            retryAfter ? Number(retryAfter) : void 0,
+            requestId
+          );
+          continue;
+        }
+        if (response.status >= 500) {
+          lastError = new ServerError(
+            errorBody?.error?.message ?? "Server error",
+            response.status,
+            requestId
+          );
+          continue;
+        }
+        throw new MandatoError(
+          errorBody?.error?.message ?? `HTTP ${response.status}`,
+          response.status,
+          errorBody?.error?.type ?? "unknown_error",
+          requestId
+        );
+      } catch (error) {
+        if (error instanceof MandatoError && !(error instanceof RateLimitError) && !(error instanceof ServerError)) {
+          throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+          lastError = new MandatoError("Request timeout", 0, "timeout_error");
+          continue;
+        }
+        if (error instanceof MandatoError) {
+          lastError = error;
+          continue;
+        }
+        lastError = error instanceof Error ? error : new Error(String(error));
+      }
+    }
+    throw lastError ?? new MandatoError("Request failed after retries", 0, "retry_exhausted");
+  }
+  /** Safely parse error response body */
+  async parseErrorBody(response) {
+    try {
+      return await response.json();
+    } catch {
+      return null;
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/resources/api-keys.ts
+var ApiKeys = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** List API keys (masked) */
+  async list() {
+    return this.http.get("/v1/api-keys");
+  }
+  /** Create a new API key (full key returned once) */
+  async create(data) {
+    return this.http.post("/v1/api-keys", data);
+  }
+  /** Revoke an API key */
+  async revoke(id) {
+    return this.http.delete(`/v1/api-keys/${id}`);
+  }
+};
+
+// src/resources/companies.ts
+var Companies = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Create a company */
+  async create(data) {
+    return this.http.post("/v1/companies", data);
+  }
+  /** List all companies */
+  async list() {
+    return this.http.get("/v1/companies");
+  }
+  /** Get a single company by ID */
+  async get(id) {
+    return this.http.get(`/v1/companies/${id}`);
+  }
+  /** Update a company */
+  async update(id, data) {
+    return this.http.patch(`/v1/companies/${id}`, data);
+  }
+  /** Delete a company */
+  async delete(id) {
+    return this.http.delete(`/v1/companies/${id}`);
+  }
+};
+
+// src/resources/connections.ts
+var Connections = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Initialize a government connection */
+  async create(data) {
+    return this.http.post("/v1/connections", data);
+  }
+  /** List all connections */
+  async list() {
+    return this.http.get("/v1/connections");
+  }
+  /** Get a single connection by ID */
+  async get(id) {
+    return this.http.get(`/v1/connections/${id}`);
+  }
+  /** Remove a connection */
+  async delete(id) {
+    return this.http.delete(`/v1/connections/${id}`);
+  }
+};
+
+// src/resources/invoices.ts
+var Invoices = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Create and submit an invoice */
+  async create(data, idempotencyKey) {
+    const headers = {};
+    if (idempotencyKey) {
+      headers["X-Idempotency-Key"] = idempotencyKey;
+    }
+    return this.http.post("/v1/invoices", data, headers);
+  }
+  /** List invoices with optional filters */
+  async list(params) {
+    return this.http.get(
+      "/v1/invoices",
+      params
+    );
+  }
+  /** Get a single invoice by ID */
+  async get(id) {
+    return this.http.get(`/v1/invoices/${id}`);
+  }
+  /** Dry-run validation without submission */
+  async validate(data) {
+    return this.http.post("/v1/invoices/validate", data);
+  }
+  /** Get invoice event timeline */
+  async getEvents(id) {
+    return this.http.get(`/v1/invoices/${id}/events`);
+  }
+};
+
+// src/resources/webhooks.ts
+var Webhooks = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Register a webhook URL */
+  async create(data) {
+    return this.http.post("/v1/webhooks", data);
+  }
+  /** Get current webhook configuration */
+  async get() {
+    return this.http.get("/v1/webhooks");
+  }
+  /** Remove webhook */
+  async delete() {
+    return this.http.delete("/v1/webhooks");
+  }
+};
+
+// src/client.ts
+var MandatoClient = class {
+  /** Invoice operations */
+  invoices;
+  /** Company operations */
+  companies;
+  /** Connection operations */
+  connections;
+  /** Webhook operations */
+  webhooks;
+  /** API key operations */
+  apiKeys;
+  http;
+  constructor(config) {
+    this.http = new MandatoHttpClient(config);
+    this.invoices = new Invoices(this.http);
+    this.companies = new Companies(this.http);
+    this.connections = new Connections(this.http);
+    this.webhooks = new Webhooks(this.http);
+    this.apiKeys = new ApiKeys(this.http);
+  }
+  /** Check API health */
+  async health() {
+    return this.http.get("/v1/health");
+  }
+};
+
+// src/webhooks.ts
+import { createHmac, timingSafeEqual } from "crypto";
+function verifyWebhookSignature(payload, signature, secret) {
+  const expected = createHmac("sha256", secret).update(payload).digest("hex");
+  const sigBuffer = Buffer.from(signature, "utf-8");
+  const expectedBuffer = Buffer.from(expected, "utf-8");
+  if (sigBuffer.length !== expectedBuffer.length) {
+    return false;
+  }
+  return timingSafeEqual(sigBuffer, expectedBuffer);
+}
+function constructWebhookEvent(payload, signature, secret) {
+  if (!verifyWebhookSignature(payload, signature, secret)) {
+    throw new Error("Invalid webhook signature");
+  }
+  return JSON.parse(payload);
+}
+export {
+  AuthenticationError,
+  ConflictError,
+  ForbiddenError,
+  MandatoClient,
+  MandatoError,
+  MandatoHttpClient,
+  NotFoundError,
+  RateLimitError,
+  ServerError,
+  ValidationError,
+  constructWebhookEvent,
+  verifyWebhookSignature
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@getmandato/sdk",
+  "version": "0.1.0",
+  "description": "Official Node.js SDK for the Mandato EU e-invoicing API",
+  "license": "MIT",
+  "author": "Andrei Cotaga",
+  "homepage": "https://getmandato.dev",
+  "bugs": "https://github.com/andreicotaga/mandato/issues",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/CLAUDE.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "mandato",
+    "e-invoicing",
+    "eu",
+    "anaf",
+    "romania",
+    "ubl",
+    "invoice",
+    "api",
+    "sdk"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/andreicotaga/mandato.git",
+    "directory": "packages/sdk"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm build"
+  }
+}