@pague-dev/sdk-node 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# @pague-dev/sdk-node
+
+SDK oficial do [pague.dev](https://pague.dev) para Node.js e browsers.
+
+## Instalacao
+
+```bash
+npm install @pague-dev/sdk-node
+```
+
+## Uso
+
+```typescript
+import { Pdev } from '@pague-dev/sdk-node';
+
+// Opção 1: Passar a API key diretamente
+const pdev = new Pdev('pd_live_sua_api_key');
+
+// Opção 2: Usar variável de ambiente PDEV_API_KEY
+const pdev = new Pdev();
+```
+
+## Recursos
+
+- **PIX** - Cobranças instantâneas
+- **Charges** - Links de pagamento
+- **Customers** - Gestão de clientes
+- **Projects** - Organização por projetos
+- **Transactions** - Consulta de transações
+- **Webhooks** - Notificações em tempo real
+
+## Documentacao
+
+Exemplos e guias de integração: **[docs.pague.dev](https://docs.pague.dev)**
+
+## Licenca
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,265 @@
+
+//#region src/common/utils/build-pagination-query.ts
+function buildPaginationQuery(options) {
+	const searchParams = new URLSearchParams();
+	for (const [key, value] of Object.entries(options)) if (value !== void 0 && value !== null) searchParams.set(key, String(value));
+	return searchParams.toString();
+}
+
+//#endregion
+//#region src/common/base-resource.ts
+/**
+* Base class for API resources that follow CRUD patterns.
+* Provides common create, list, and get operations.
+*/
+var BaseResource = class {
+	constructor(pdev) {
+		this.pdev = pdev;
+	}
+	/**
+	* Create a new entity
+	*/
+	async create(options) {
+		return this.pdev.post(this.endpoint, options);
+	}
+	/**
+	* List entities with pagination
+	*/
+	async list(options = {}) {
+		const queryString = buildPaginationQuery(options);
+		const path = queryString ? `${this.endpoint}?${queryString}` : this.endpoint;
+		return this.pdev.get(path);
+	}
+	/**
+	* Get a single entity by ID
+	*/
+	async get(id) {
+		return this.pdev.get(`${this.endpoint}/${id}`);
+	}
+};
+/**
+* Base class for resources that only support create operations
+*/
+var CreateOnlyResource = class {
+	constructor(pdev) {
+		this.pdev = pdev;
+	}
+	async create(options) {
+		return this.pdev.post(this.endpoint, options);
+	}
+};
+/**
+* Base class for resources that only support get operations
+*/
+var GetOnlyResource = class {
+	constructor(pdev) {
+		this.pdev = pdev;
+	}
+	async get(id) {
+		return this.pdev.get(`${this.endpoint}/${id}`);
+	}
+};
+
+//#endregion
+//#region src/charges/charges.ts
+var Charges = class extends BaseResource {
+	endpoint = "/charges";
+};
+
+//#endregion
+//#region src/config.ts
+const config = { baseUrl: "https://api.pague.dev/v1" };
+
+//#endregion
+//#region src/customers/customers.ts
+var Customers = class extends BaseResource {
+	endpoint = "/customers";
+};
+
+//#endregion
+//#region src/pix/pix.ts
+var Pix = class extends CreateOnlyResource {
+	endpoint = "/pix";
+};
+
+//#endregion
+//#region src/projects/projects.ts
+var Projects = class extends BaseResource {
+	endpoint = "/projects";
+};
+
+//#endregion
+//#region src/transactions/transactions.ts
+var Transactions = class extends GetOnlyResource {
+	endpoint = "/transactions";
+};
+
+//#endregion
+//#region src/pdev.ts
+var Pdev = class {
+	key;
+	baseUrl;
+	headers;
+	pix;
+	customers;
+	projects;
+	charges;
+	transactions;
+	constructor(key) {
+		if (!key) {
+			if (typeof process !== "undefined" && process.env) this.key = process.env.PDEV_API_KEY || "";
+			else this.key = "";
+			if (!this.key) throw new Error("Missing API key. Pass it to the constructor `new Pdev(\"pd_live_xxx\")` or set the PDEV_API_KEY environment variable.");
+		} else this.key = key;
+		this.baseUrl = config.baseUrl;
+		this.headers = new Headers({
+			"X-API-Key": this.key,
+			"Content-Type": "application/json"
+		});
+		this.pix = new Pix(this);
+		this.customers = new Customers(this);
+		this.projects = new Projects(this);
+		this.charges = new Charges(this);
+		this.transactions = new Transactions(this);
+	}
+	async post(path, body, options = {}) {
+		const url = this.buildUrl(path, options.query);
+		return this.fetchRequest(url, {
+			method: "POST",
+			headers: this.headers,
+			body: body ? JSON.stringify(body) : void 0
+		});
+	}
+	async get(path, options = {}) {
+		const url = this.buildUrl(path, options.query);
+		return this.fetchRequest(url, {
+			method: "GET",
+			headers: this.headers
+		});
+	}
+	buildUrl(path, query) {
+		let url = `${this.baseUrl}${path}`;
+		if (query) {
+			const searchParams = new URLSearchParams();
+			for (const [key, value] of Object.entries(query)) if (value !== void 0 && value !== null) searchParams.set(key, String(value));
+			const queryString = searchParams.toString();
+			if (queryString) url += `?${queryString}`;
+		}
+		return url;
+	}
+	async fetchRequest(url, options) {
+		try {
+			const response = await fetch(url, options);
+			if (!response.ok) try {
+				const rawError = await response.text();
+				return {
+					data: null,
+					error: JSON.parse(rawError)
+				};
+			} catch {
+				return {
+					data: null,
+					error: {
+						statusCode: response.status,
+						error: "UnknownError",
+						message: "An unexpected error occurred"
+					}
+				};
+			}
+			return {
+				data: await response.json(),
+				error: null
+			};
+		} catch {
+			return {
+				data: null,
+				error: {
+					statusCode: null,
+					error: "NetworkError",
+					message: "Unable to fetch data. The request could not be resolved."
+				}
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/webhooks/verify.ts
+/**
+* Type guard to check if an event is a valid WebhookEvent
+*/
+function isValidWebhookEvent(event) {
+	if (typeof event !== "object" || event === null) return false;
+	const obj = event;
+	if (typeof obj.event !== "string") return false;
+	if (typeof obj.eventId !== "string") return false;
+	if (typeof obj.timestamp !== "string") return false;
+	if (typeof obj.data !== "object" || obj.data === null) return false;
+	return [
+		"payment_completed",
+		"payment_failed",
+		"refund_completed"
+	].includes(obj.event);
+}
+/**
+* Parses a webhook payload and returns a type-safe WebhookEvent.
+* Returns null if the payload is invalid.
+*
+* @param payload - The raw request body as a string
+* @returns Parsed WebhookEvent or null if invalid
+*
+* @example
+* ```typescript
+* import { parseWebhook } from 'pague-dev';
+*
+* app.post('/webhook', (req, res) => {
+*   // 1. Verify signature first (implement using your framework)
+*   // const isValid = verifySignature(req.body, req.headers['x-webhook-signature'], secret);
+*
+*   // 2. Parse the webhook payload
+*   const event = parseWebhook(req.body);
+*
+*   if (!event) {
+*     return res.status(400).send('Invalid webhook payload');
+*   }
+*
+*   // 3. Handle the event with full type safety
+*   switch (event.event) {
+*     case 'payment_completed':
+*       // event.data is PaymentCompletedData
+*       console.log('Payment completed:', event.data.transactionId);
+*       console.log('Amount:', event.data.amount);
+*       console.log('Net amount:', event.data.netAmount);
+*       break;
+*
+*     case 'payment_failed':
+*       // event.data is PaymentFailedData
+*       console.log('Payment failed:', event.data.transactionId);
+*       console.log('Reason:', event.data.failureReason);
+*       break;
+*
+*     case 'refund_completed':
+*       // event.data is RefundCompletedData
+*       console.log('Refund completed:', event.data.refundTransactionId);
+*       console.log('Original transaction:', event.data.originalTransactionId);
+*       break;
+*   }
+*
+*   res.status(200).send('OK');
+* });
+* ```
+*/
+function parseWebhook(payload) {
+	let parsed;
+	try {
+		parsed = JSON.parse(payload);
+	} catch {
+		return null;
+	}
+	if (!isValidWebhookEvent(parsed)) return null;
+	return parsed;
+}
+
+//#endregion
+exports.Pdev = Pdev;
+exports.parseWebhook = parseWebhook;