@lina-openx/react-native-lina-pay-sdk 1.0.0

package/src/utils/consent.utils.ts

@@ -0,0 +1,225 @@
+/**
+ * Consent utilities for payload validation
+ */
+
+import { LinaPayError } from './http.utils';
+import type { CreateConsentRequest } from '../types/consent.types';
+
+/**
+ * Validate CPF/CNPJ format (basic validation)
+ */
+function validateCpfCnpj(cpfCnpj: string, fieldName: string): void {
+  // Remove non-numeric characters
+  const cleaned = cpfCnpj.replace(/\D/g, '');
+
+  // CPF must have 11 digits, CNPJ must have 14 digits
+  if (cleaned.length !== 11 && cleaned.length !== 14) {
+    throw new LinaPayError(
+      `${fieldName} must be a valid CPF (11 digits) or CNPJ (14 digits)`
+    );
+  }
+}
+
+/**
+ * Validate URL format
+ */
+function validateUrl(url: string, fieldName: string): void {
+  if (!url || url.trim() === '') {
+    throw new LinaPayError(`${fieldName} is required and cannot be empty`);
+  }
+
+  try {
+    const urlObj = new URL(url);
+    if (!urlObj.protocol.startsWith('http')) {
+      throw new Error('Invalid protocol');
+    }
+  } catch {
+    throw new LinaPayError(
+      `${fieldName} must be a valid URL starting with http:// or https://`
+    );
+  }
+}
+
+/**
+ * Validate positive number
+ */
+function validatePositiveNumber(
+  value: number,
+  fieldName: string
+): void {
+  if (typeof value !== 'number' || isNaN(value)) {
+    throw new LinaPayError(`${fieldName} must be a valid number`);
+  }
+
+  if (value <= 0) {
+    throw new LinaPayError(`${fieldName} must be greater than zero`);
+  }
+}
+
+/**
+ * Validate date format (YYYY-MM-DD)
+ */
+function validateDateFormat(date: string, fieldName: string): void {
+  const dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+  if (!dateRegex.test(date)) {
+    throw new LinaPayError(
+      `${fieldName} must be in format YYYY-MM-DD (e.g., 2024-09-01)`
+    );
+  }
+
+  // Check if date is valid
+  const dateObj = new Date(date);
+  if (isNaN(dateObj.getTime())) {
+    throw new LinaPayError(`${fieldName} is not a valid date`);
+  }
+}
+
+/**
+ * Validate required string field
+ */
+function validateRequiredString(
+  value: string | undefined,
+  fieldName: string
+): void {
+  if (!value || value.trim() === '') {
+    throw new LinaPayError(`${fieldName} is required and cannot be empty`);
+  }
+}
+
+/**
+ * Validate consent payload before sending to API
+ * Throws LinaPayError if validation fails
+ */
+export function validateConsentPayload(
+  payload: CreateConsentRequest
+): void {
+  // Validate main required fields
+  validateRequiredString(payload.organisationId, 'organisationId');
+  validateRequiredString(
+    payload.authorisationServerId,
+    'authorisationServerId'
+  );
+
+  if (!payload.payment) {
+    throw new LinaPayError('payment is required');
+  }
+
+  // Validate payment required fields
+  validateUrl(payload.payment.redirectUri, 'payment.redirectUri');
+  validatePositiveNumber(payload.payment.value, 'payment.value');
+
+  if (!payload.payment.creditor) {
+    throw new LinaPayError('payment.creditor is required');
+  }
+
+  // Validate creditor required fields
+  const creditor = payload.payment.creditor;
+  validateRequiredString(creditor.name, 'payment.creditor.name');
+  validateRequiredString(creditor.personType, 'payment.creditor.personType');
+  validateCpfCnpj(creditor.cpfCnpj, 'payment.creditor.cpfCnpj');
+  validateRequiredString(
+    creditor.accountNumber,
+    'payment.creditor.accountNumber'
+  );
+  validateRequiredString(
+    creditor.accountIssuer,
+    'payment.creditor.accountIssuer'
+  );
+  validateRequiredString(
+    creditor.accountPixKey,
+    'payment.creditor.accountPixKey'
+  );
+  validateRequiredString(creditor.accountIspb, 'payment.creditor.accountIspb');
+  validateRequiredString(creditor.accountType, 'payment.creditor.accountType');
+
+  // Validate optional CPF/CNPJ in payment
+  if (payload.payment.cpfCnpj) {
+    validateCpfCnpj(payload.payment.cpfCnpj, 'payment.cpfCnpj');
+  }
+
+  // Validate schedule if present
+  if (payload.payment.schedule) {
+    validateSchedule(payload.payment.schedule);
+  }
+
+  // Validate redirectUri if present at root level
+  if (payload.redirectUri) {
+    validateUrl(payload.redirectUri, 'redirectUri');
+  }
+}
+
+/**
+ * Validate schedule structure
+ */
+function validateSchedule(schedule: any): void {
+  const scheduleTypes = ['single', 'daily', 'weekly', 'monthly', 'custom'];
+  const providedTypes = scheduleTypes.filter((type) => schedule[type]);
+
+  if (providedTypes.length === 0) {
+    throw new LinaPayError(
+      'At least one schedule type must be provided (single, daily, weekly, monthly, or custom)'
+    );
+  }
+
+  // Validate single schedule
+  if (schedule.single) {
+    validateDateFormat(schedule.single.date, 'schedule.single.date');
+  }
+
+  // Validate daily schedule
+  if (schedule.daily) {
+    validateDateFormat(schedule.daily.startDate, 'schedule.daily.startDate');
+    validatePositiveNumber(schedule.daily.quantity, 'schedule.daily.quantity');
+  }
+
+  // Validate weekly schedule
+  if (schedule.weekly) {
+    validateRequiredString(
+      schedule.weekly.dayOfWeek,
+      'schedule.weekly.dayOfWeek'
+    );
+    validateDateFormat(schedule.weekly.startDate, 'schedule.weekly.startDate');
+    validatePositiveNumber(
+      schedule.weekly.quantity,
+      'schedule.weekly.quantity'
+    );
+  }
+
+  // Validate monthly schedule
+  if (schedule.monthly) {
+    if (
+      typeof schedule.monthly.dayOfMonth !== 'number' ||
+      schedule.monthly.dayOfMonth < 1 ||
+      schedule.monthly.dayOfMonth > 31
+    ) {
+      throw new LinaPayError(
+        'schedule.monthly.dayOfMonth must be a number between 1 and 31'
+      );
+    }
+    validateDateFormat(
+      schedule.monthly.startDate,
+      'schedule.monthly.startDate'
+    );
+    validatePositiveNumber(
+      schedule.monthly.quantity,
+      'schedule.monthly.quantity'
+    );
+  }
+
+  // Validate custom schedule
+  if (schedule.custom) {
+    if (
+      !Array.isArray(schedule.custom.dates) ||
+      schedule.custom.dates.length === 0
+    ) {
+      throw new LinaPayError(
+        'schedule.custom.dates must be a non-empty array'
+      );
+    }
+
+    schedule.custom.dates.forEach((date: string, index: number) => {
+      validateDateFormat(date, `schedule.custom.dates[${index}]`);
+    });
+  }
+}
+

package/src/utils/http.utils.ts

@@ -0,0 +1,80 @@
+/**
+ * HTTP utilities for error handling and request management
+ */
+
+export class LinaPayError extends Error {
+  constructor(
+    message: string,
+    public statusCode?: number,
+    public originalError?: unknown
+  ) {
+    super(message);
+    this.name = 'LinaPayError';
+  }
+}
+
+/**
+ * Handle HTTP response errors
+ */
+export async function handleHttpError(response: Response): Promise<never> {
+  let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+
+  try {
+    const errorBody = await response.json();
+    if (
+      errorBody &&
+      typeof errorBody === 'object' &&
+      'error_description' in errorBody
+    ) {
+      errorMessage = String(errorBody.error_description);
+    } else if (
+      errorBody &&
+      typeof errorBody === 'object' &&
+      'message' in errorBody
+    ) {
+      errorMessage = String(errorBody.message);
+    } else if (
+      errorBody &&
+      typeof errorBody === 'object' &&
+      'error' in errorBody
+    ) {
+      errorMessage = String(errorBody.error);
+    }
+  } catch {
+    // If response is not JSON, use default message
+  }
+
+  throw new LinaPayError(errorMessage, response.status);
+}
+
+/**
+ * Validate credentials before making requests
+ */
+export function validateCredentials(
+  subtenantId: string,
+  subtenantSecret: string
+): void {
+  if (!subtenantId || subtenantId.trim() === '') {
+    throw new LinaPayError('subtenantId is required and cannot be empty');
+  }
+
+  if (!subtenantSecret || subtenantSecret.trim() === '') {
+    throw new LinaPayError('subtenantSecret is required and cannot be empty');
+  }
+}
+
+/**
+ * Handle network errors
+ */
+export function handleNetworkError(error: unknown): never {
+  if (error instanceof LinaPayError) {
+    throw error;
+  }
+
+  const message =
+    error instanceof Error
+      ? `Network error: ${error.message}`
+      : 'Unknown network error occurred';
+
+  throw new LinaPayError(message, undefined, error);
+}

package/src/utils/payment.utils.ts

@@ -0,0 +1,32 @@
+/**
+ * Payment utilities for payload validation
+ */
+
+import { LinaPayError } from './http.utils';
+import type { CreatePaymentRequest } from '../types/payment.types';
+
+/**
+ * Validate required string field
+ */
+function validateRequiredString(
+  value: string | undefined,
+  fieldName: string
+): void {
+  if (!value || value.trim() === '') {
+    throw new LinaPayError(`${fieldName} is required and cannot be empty`);
+  }
+}
+
+/**
+ * Validate payment payload before sending to API
+ * Throws LinaPayError if validation fails
+ */
+export function validatePaymentPayload(
+  payload: CreatePaymentRequest
+): void {
+  validateRequiredString(payload.state, 'state');
+  validateRequiredString(payload.code, 'code');
+  validateRequiredString(payload.idToken, 'idToken');
+  validateRequiredString(payload.tenantId, 'tenantId');
+}
+