@sinnu-dev/sdk 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,391 @@
+// src/client.ts
+import createOpenApiClient from "openapi-fetch";
+
+// src/errors.ts
+var SinnuError = class extends Error {
+  constructor(message, statusCode, body, response) {
+    super(message);
+    this.name = "SinnuError";
+    this.statusCode = statusCode;
+    this.body = body;
+    this.response = response;
+  }
+};
+var SinnuAuthError = class extends SinnuError {
+  constructor(message, statusCode = 401, body, response) {
+    super(message, statusCode, body, response);
+    this.name = "SinnuAuthError";
+  }
+};
+var SinnuNotFoundError = class extends SinnuError {
+  constructor(message, body, response) {
+    super(message, 404, body, response);
+    this.name = "SinnuNotFoundError";
+  }
+};
+var SinnuValidationError = class extends SinnuError {
+  constructor(message, statusCode, body, response) {
+    super(message, statusCode, body, response);
+    this.name = "SinnuValidationError";
+  }
+};
+var SinnuRateLimitError = class extends SinnuError {
+  constructor(message, body, response) {
+    super(message, 429, body, response);
+    this.name = "SinnuRateLimitError";
+  }
+};
+function toSinnuError(statusCode, body, response) {
+  const message = body?.message ?? `Requisi\xE7\xE3o falhou com status ${statusCode}`;
+  switch (statusCode) {
+    case 401:
+    case 403:
+      return new SinnuAuthError(message, statusCode, body, response);
+    case 404:
+      return new SinnuNotFoundError(message, body, response);
+    case 400:
+    case 422:
+      return new SinnuValidationError(message, statusCode, body, response);
+    case 429:
+      return new SinnuRateLimitError(message, body, response);
+    default:
+      return new SinnuError(message, statusCode, body, response);
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.sinnu.com.br";
+var API_KEY_PREFIXES = ["sk_live_"];
+function assertApiKey(apiKey) {
+  if (!apiKey || typeof apiKey !== "string") {
+    throw new Error(
+      "[@sinnu-dev/sdk] apiKey \xE9 obrigat\xF3ria. Gere uma chave secreta no painel sinnu (Integra\xE7\xF5es)."
+    );
+  }
+  if (!API_KEY_PREFIXES.some((p) => apiKey.startsWith(p))) {
+    console.warn(
+      "[@sinnu-dev/sdk] apiKey n\xE3o come\xE7a com 'sk_live_'. Use a chave secreta no backend, nunca uma chave no cliente."
+    );
+  }
+}
+function createTypedClient(options) {
+  assertApiKey(options.apiKey);
+  return createOpenApiClient({
+    baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
+    fetch: options.fetch,
+    headers: {
+      Authorization: `Bearer ${options.apiKey}`,
+      "Content-Type": "application/json",
+      ...options.headers
+    }
+  });
+}
+async function unwrap(p) {
+  const { data, error, response } = await p;
+  if (error || !response.ok) {
+    throw toSinnuError(
+      response.status,
+      error ?? void 0,
+      response
+    );
+  }
+  if (data === void 0 || data === null) {
+    throw toSinnuError(response.status, { message: "Resposta sem corpo" }, response);
+  }
+  return data;
+}
+var RawHttp = class {
+  constructor(baseUrl, apiKey, extraHeaders, fetchImpl) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.extraHeaders = extraHeaders;
+    this.fetchImpl = fetchImpl;
+  }
+  async request(path, options = {}) {
+    const url = new URL(path.replace(/^\//, ""), ensureTrailingSlash(this.baseUrl));
+    if (options.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    const response = await this.fetchImpl(url.toString(), {
+      method: options.method ?? "GET",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...this.extraHeaders
+      },
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+    const text = await response.text();
+    const parsed = text ? safeJsonParse(text) : void 0;
+    if (!response.ok) {
+      throw toSinnuError(response.status, parsed, response);
+    }
+    return parsed;
+  }
+};
+function ensureTrailingSlash(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/resources/checkout.ts
+var DEFAULT_CHECKOUT_BASE_URL = "https://pay.sinnu.com.br";
+var Checkout = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Monta a URL pública do checkout hosted para um `slug` (8 chars) gerado
+   * ao criar um link (`sinnu.links.create(...).url` já vem pronto; este
+   * helper é útil quando você só tem o slug).
+   *
+   * @example
+   * const url = sinnu.checkout.url("abcd1234", { reference: "pedido-123" });
+   * // => "https://pay.sinnu.com.br/abcd1234?ref=pedido-123"
+   */
+  url(slug, options = {}) {
+    if (!slug || typeof slug !== "string") {
+      throw new Error("[@sinnu-dev/sdk] slug do checkout \xE9 obrigat\xF3rio.");
+    }
+    const base = options.checkoutBaseUrl ?? this.options.checkoutBaseUrl ?? DEFAULT_CHECKOUT_BASE_URL;
+    const url = new URL(encodeURIComponent(slug), ensureTrailingSlash2(base));
+    const query = { ...this.options.query, ...options.query };
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    if (options.reference !== void 0) {
+      if (options.reference.length > 255) {
+        throw new Error("[@sinnu-dev/sdk] reference tem no m\xE1ximo 255 caracteres.");
+      }
+      url.searchParams.set("ref", options.reference);
+    }
+    return url.toString();
+  }
+};
+function ensureTrailingSlash2(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+
+// src/pagination.ts
+async function* paginate(fetchPage) {
+  let page = 1;
+  let seen = 0;
+  while (true) {
+    const result = await fetchPage(page);
+    for (const item of result.data) {
+      yield item;
+    }
+    seen += result.data.length;
+    const pageSize = result.pageSize || result.data.length;
+    if (result.data.length === 0 || seen >= result.total || pageSize === 0) {
+      return;
+    }
+    page += 1;
+  }
+}
+async function collectAll(fetchPage) {
+  const out = [];
+  for await (const item of paginate(fetchPage)) {
+    out.push(item);
+  }
+  return out;
+}
+
+// src/resources/links.ts
+var Links = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Cria um link de pagamento (valor em centavos). */
+  async create(body) {
+    return this.http.request("/api/payment-links", {
+      method: "POST",
+      body
+    });
+  }
+  /** Busca um link de pagamento pelo id. */
+  async get(id) {
+    return this.http.request(`/api/payment-links/${encodeURIComponent(id)}`);
+  }
+  /** Atualiza parcialmente um link de pagamento. */
+  async update(id, body) {
+    return this.http.request(`/api/payment-links/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body
+    });
+  }
+  /** Arquiva um link de pagamento. */
+  async archive(id) {
+    await this.http.request(`/api/payment-links/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+  }
+  /** Lista links de pagamento (paginado). */
+  async list(params = {}) {
+    return this.http.request("/api/payment-links", {
+      query: { page: params.page, pageSize: params.pageSize }
+    });
+  }
+  /** Lista transações de um link de pagamento (paginado). */
+  async transactions(id, params = {}) {
+    return this.http.request(
+      `/api/payment-links/${encodeURIComponent(id)}/transactions`,
+      { query: { page: params.page, pageSize: params.pageSize } }
+    );
+  }
+  /** Itera todos os links de pagamento, página a página. */
+  listAll(params = {}) {
+    return paginate((page) => this.list({ ...params, page }));
+  }
+};
+
+// src/resources/transactions.ts
+var Transactions = class {
+  constructor(http) {
+    this.http = http;
+  }
+  /** Lista transações (paginado, com filtro opcional por status). */
+  async list(params = {}) {
+    return this.http.request("/api/transactions/", {
+      query: {
+        status: params.status,
+        search: params.search,
+        customer: params.customer,
+        page: params.page,
+        pageSize: params.pageSize
+      }
+    });
+  }
+  /** Busca uma transação pelo id. */
+  async get(id) {
+    return this.http.request(`/api/transactions/${encodeURIComponent(id)}/`);
+  }
+  /** Estorna (refund) uma transação. */
+  async refund(id, body = {}) {
+    return this.http.request(
+      `/api/transactions/${encodeURIComponent(id)}/refund/`,
+      { method: "POST", body }
+    );
+  }
+  /** Itera todas as transações, página a página. */
+  listAll(params = {}) {
+    return paginate((page) => this.list({ ...params, page }));
+  }
+};
+
+// src/webhooks.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var SINNU_SIGNATURE_HEADER = "x-sinnu-signature";
+var SinnuWebhookSignatureError = class extends SinnuError {
+  constructor(message) {
+    super(message, 0);
+    this.name = "SinnuWebhookSignatureError";
+  }
+};
+function normalizeSignature(signature) {
+  if (signature === void 0) {
+    throw new SinnuWebhookSignatureError(
+      "[@sinnu-dev/sdk] header de assinatura ausente. Esperado 'X-Sinnu-Signature'."
+    );
+  }
+  const value = Array.isArray(signature) ? signature[0] : signature;
+  if (!value) {
+    throw new SinnuWebhookSignatureError("[@sinnu-dev/sdk] header de assinatura vazio.");
+  }
+  return value.startsWith("sha256=") ? value.slice("sha256=".length) : value;
+}
+function toBuffer(payload) {
+  return typeof payload === "string" ? Buffer.from(payload, "utf8") : payload;
+}
+function computeSignature(payload, secret) {
+  return createHmac("sha256", secret).update(toBuffer(payload)).digest("hex");
+}
+function verifySignature(options) {
+  const { payload, signature, secret } = options;
+  if (!secret) {
+    throw new SinnuWebhookSignatureError(
+      "[@sinnu-dev/sdk] webhook secret \xE9 obrigat\xF3rio para verificar a assinatura."
+    );
+  }
+  const provided = normalizeSignature(signature);
+  const expected = computeSignature(payload, secret);
+  const providedBuf = Buffer.from(provided, "hex");
+  const expectedBuf = Buffer.from(expected, "hex");
+  if (providedBuf.length !== expectedBuf.length) {
+    return false;
+  }
+  return timingSafeEqual(providedBuf, expectedBuf);
+}
+function constructEvent(options) {
+  if (!verifySignature(options)) {
+    throw new SinnuWebhookSignatureError(
+      "[@sinnu-dev/sdk] assinatura de webhook inv\xE1lida. Requisi\xE7\xE3o rejeitada."
+    );
+  }
+  const text = typeof options.payload === "string" ? options.payload : options.payload.toString("utf8");
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new SinnuWebhookSignatureError("[@sinnu-dev/sdk] corpo do webhook n\xE3o \xE9 um JSON v\xE1lido.");
+  }
+}
+var webhooks = {
+  signatureHeader: SINNU_SIGNATURE_HEADER,
+  computeSignature,
+  verifySignature,
+  constructEvent
+};
+
+// src/index.ts
+var Sinnu = class {
+  constructor(options) {
+    /** Verificação de webhooks (HMAC SHA-256): não faz requisições. */
+    this.webhooks = webhooks;
+    this.http = createTypedClient(options);
+    const raw = new RawHttp(
+      options.baseUrl ?? DEFAULT_BASE_URL,
+      options.apiKey,
+      options.headers ?? {},
+      options.fetch ?? fetch
+    );
+    this.links = new Links(raw);
+    this.transactions = new Transactions(raw);
+    this.checkout = new Checkout({ checkoutBaseUrl: options.checkoutBaseUrl });
+  }
+};
+var index_default = Sinnu;
+export {
+  Checkout,
+  DEFAULT_BASE_URL,
+  DEFAULT_CHECKOUT_BASE_URL,
+  SINNU_SIGNATURE_HEADER,
+  Sinnu,
+  SinnuAuthError,
+  SinnuError,
+  SinnuNotFoundError,
+  SinnuRateLimitError,
+  SinnuValidationError,
+  SinnuWebhookSignatureError,
+  collectAll,
+  computeSignature,
+  constructEvent,
+  createTypedClient,
+  index_default as default,
+  paginate,
+  unwrap,
+  verifySignature,
+  webhooks
+};

package/package.json

@@ -1,6 +1,64 @@
 {
-  "name": "@sinnu-dev/sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@sinnu-dev/sdk",
+	"version": "0.2.0",
+	"description": "SDK oficial da Sinnu para Node.js e TypeScript: cobre com Pix e cartão por links de pagamento, acompanhe transações e valide webhooks.",
+	"keywords": [
+		"sinnu",
+		"pix",
+		"cartao-de-credito",
+		"pagamentos",
+		"gateway-de-pagamento",
+		"link-de-pagamento",
+		"checkout",
+		"cobranca",
+		"webhooks",
+		"agencias",
+		"prestadores-de-servico",
+		"saas",
+		"brasil",
+		"typescript",
+		"nodejs"
+	],
+	"homepage": "https://docs.sinnu.com.br/sdk",
+	"license": "MIT",
+	"author": "Sinnu (https://sinnu.com.br)",
+	"type": "module",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"require": "./dist/index.cjs"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"sideEffects": false,
+	"engines": {
+		"node": ">=18"
+	},
+	"scripts": {
+		"generate": "node scripts/generate.mjs",
+		"build": "tsup",
+		"type-check": "tsc --noEmit",
+		"test": "node --test tests/*.test.mjs",
+		"check-release": "node scripts/check-release.mjs",
+		"prepublishOnly": "npm run generate && npm run build && npm run type-check && npm test"
+	},
+	"dependencies": {
+		"openapi-fetch": "^0.13.5",
+		"openapi-typescript-helpers": "^0.0.15"
+	},
+	"devDependencies": {
+		"@types/node": "^20.0.0",
+		"openapi-typescript": "^7.5.0",
+		"tsup": "^8.5.0",
+		"typescript": "^5.6.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	}
+}