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

package/src/services/auth.service.ts

@@ -0,0 +1,88 @@
+/**
+ * Authentication service for OAuth2 token management
+ */
+
+import { getConfig, ENDPOINTS } from '../config/environment';
+import type {
+  LinaPayCredentials,
+  TokenResponse,
+  CachedToken,
+} from '../types/auth.types';
+import {
+  handleHttpError,
+  handleNetworkError,
+  validateCredentials,
+} from '../utils/http.utils';
+
+// Token cache with 5-minute buffer before expiration
+let tokenCache: CachedToken | null = null;
+const EXPIRATION_BUFFER_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Get access token from cache or request new one
+ */
+export async function getAccessToken(
+  credentials: LinaPayCredentials
+): Promise<string> {
+  // Validate credentials
+  validateCredentials(credentials.subtenantId, credentials.subtenantSecret);
+
+  // Check if cached token is still valid
+  if (tokenCache && Date.now() < tokenCache.expiresAt) {
+    return tokenCache.accessToken;
+  }
+
+  // Request new token
+  return await requestNewToken(credentials);
+}
+
+/**
+ * Request new OAuth2 token from IAM
+ */
+async function requestNewToken(
+  credentials: LinaPayCredentials
+): Promise<string> {
+  const config = getConfig();
+  const url = `${config.iamBaseUrl}${ENDPOINTS.TOKEN}`;
+
+  // Prepare form data for OAuth2 token request
+  const formData = new URLSearchParams();
+  formData.append('client_id', credentials.subtenantId);
+  formData.append('client_secret', credentials.subtenantSecret);
+  formData.append('grant_type', 'client_credentials');
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: formData.toString(),
+    });
+
+    if (!response.ok) {
+      await handleHttpError(response);
+    }
+
+    const data = (await response.json()) as TokenResponse;
+
+    // Cache token with expiration (subtract buffer to refresh before actual expiry)
+    const expiresAt =
+      Date.now() + data.expires_in * 1000 - EXPIRATION_BUFFER_MS;
+    tokenCache = {
+      accessToken: data.access_token,
+      expiresAt,
+    };
+
+    return data.access_token;
+  } catch (error) {
+    handleNetworkError(error);
+  }
+}
+
+/**
+ * Clear token cache (useful for testing or manual logout)
+ */
+export function clearTokenCache(): void {
+  tokenCache = null;
+}

package/src/services/consent.service.ts

@@ -0,0 +1,63 @@
+/**
+ * Consent service for creating payment consents
+ */
+
+import { getConfig, ENDPOINTS } from '../config/environment';
+import type {
+  CreateConsentRequest,
+  CreateConsentResponse,
+  CreateConsentApiResponse,
+} from '../types/consent.types';
+import { handleHttpError, handleNetworkError } from '../utils/http.utils';
+import { validateConsentPayload } from '../utils/consent.utils';
+
+/**
+ * Create payment consent
+ */
+export async function createConsent(
+  accessToken: string,
+  payload: CreateConsentRequest
+): Promise<CreateConsentResponse> {
+  // Validate payload before sending
+  validateConsentPayload(payload);
+
+  const config = getConfig();
+  const url = `${config.apiBaseUrl}${ENDPOINTS.CONSENTS}`;
+
+  // Normalize txId to array if it's a string
+  const normalizedPayload = {
+    ...payload,
+    redirectUri: payload.redirectUri || payload.payment.redirectUri,
+    payment: {
+      ...payload.payment,
+      txId: Array.isArray(payload.payment.txId)
+        ? payload.payment.txId
+        : payload.payment.txId
+          ? [payload.payment.txId]
+          : undefined,
+    },
+  };
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(normalizedPayload),
+    });
+
+    if (!response.ok) {
+      await handleHttpError(response);
+    }
+
+    const apiResponse = (await response.json()) as CreateConsentApiResponse;
+
+    // Extract and return the data from the wrapper
+    return apiResponse.data;
+  } catch (error) {
+    handleNetworkError(error);
+  }
+}
+

package/src/services/participants.service.ts

@@ -0,0 +1,89 @@
+/**
+ * Participants service for fetching and transforming participant data
+ */
+
+import { getConfig, ENDPOINTS } from '../config/environment';
+import type {
+  Participant,
+  ParticipantsApiResponse,
+  ParticipantFull,
+  AuthorisationServer,
+} from '../types/participants.types';
+import { handleHttpError, handleNetworkError } from '../utils/http.utils';
+
+/**
+ * Fetch participants list from API
+ */
+export async function fetchParticipants(
+  accessToken: string
+): Promise<Participant[]> {
+  const config = getConfig();
+  const url = `${config.apiBaseUrl}${ENDPOINTS.PARTICIPANTS}`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      await handleHttpError(response);
+    }
+
+    const data = (await response.json()) as ParticipantsApiResponse;
+
+    // Transform and flatten participants
+    return transformParticipants(data.data);
+  } catch (error) {
+    handleNetworkError(error);
+  }
+}
+
+/**
+ * Transform full participants data to simplified format
+ * Flattens AuthorisationServers array - creates one Participant per AuthorisationServer
+ * Filters out participants without AuthorisationServers
+ */
+function transformParticipants(
+  participantsFull: ParticipantFull[]
+): Participant[] {
+  const participants: Participant[] = [];
+
+  for (const participantFull of participantsFull) {
+    // Skip participants without AuthorisationServers
+    if (
+      !participantFull.AuthorisationServers ||
+      participantFull.AuthorisationServers.length === 0
+    ) {
+      continue;
+    }
+
+    // Create one Participant entry per AuthorisationServer
+    for (const authServer of participantFull.AuthorisationServers) {
+      participants.push(transformParticipant(participantFull, authServer));
+    }
+  }
+
+  return participants;
+}
+
+/**
+ * Transform a single participant with its authorisation server
+ */
+function transformParticipant(
+  participantFull: ParticipantFull,
+  authServer: AuthorisationServer
+): Participant {
+  return {
+    organisationId: participantFull.OrganisationId,
+    organisationName: participantFull.OrganisationName,
+    legalEntityName: participantFull.LegalEntityName,
+    registrationNumber: participantFull.RegistrationNumber,
+    authorisationServerId: authServer.AuthorisationServerId,
+    customerFriendlyName: authServer.CustomerFriendlyName,
+    customerFriendlyLogoUri: authServer.CustomerFriendlyLogoUri,
+  };
+}

package/src/services/payment.service.ts

@@ -0,0 +1,49 @@
+/**
+ * Payment service for creating payments
+ */
+
+import { getConfig, ENDPOINTS } from '../config/environment';
+import type {
+  CreatePaymentRequest,
+  CreatePaymentResponse,
+  CreatePaymentApiResponse,
+} from '../types/payment.types';
+import { handleHttpError, handleNetworkError } from '../utils/http.utils';
+import { validatePaymentPayload } from '../utils/payment.utils';
+
+/**
+ * Create payment
+ */
+export async function createPayment(
+  accessToken: string,
+  payload: CreatePaymentRequest
+): Promise<CreatePaymentResponse> {
+  // Validate payload before sending
+  validatePaymentPayload(payload);
+
+  const config = getConfig();
+  const url = `${config.apiBaseUrl}${ENDPOINTS.PAYMENTS}`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      await handleHttpError(response);
+    }
+
+    const apiResponse = (await response.json()) as CreatePaymentApiResponse;
+
+    // Extract and return the data from the wrapper
+    return apiResponse.data;
+  } catch (error) {
+    handleNetworkError(error);
+  }
+}
+

package/src/types/auth.types.ts

@@ -0,0 +1,24 @@
+/**
+ * Credentials for Lina Pay SDK authentication
+ */
+export interface LinaPayCredentials {
+  subtenantId: string;
+  subtenantSecret: string;
+}
+
+/**
+ * OAuth2 token response from IAM
+ */
+export interface TokenResponse {
+  access_token: string;
+  token_type: string;
+  expires_in: number;
+}
+
+/**
+ * Cached token with expiration tracking
+ */
+export interface CachedToken {
+  accessToken: string;
+  expiresAt: number; // timestamp in milliseconds
+}

package/src/types/consent.types.ts

@@ -0,0 +1,152 @@
+/**
+ * Consent types for payment consent creation
+ */
+
+/**
+ * Person type for creditor
+ */
+export type PersonType = 'PESSOA_NATURAL' | 'PESSOA_JURIDICA';
+
+/**
+ * Account type
+ */
+export type AccountType = 'CACC' | 'SLRY' | 'SVGS' | 'TRAN';
+
+/**
+ * Day of week for weekly schedule
+ */
+export type DayOfWeek =
+  | 'SEGUNDA_FEIRA'
+  | 'TERCA_FEIRA'
+  | 'QUARTA_FEIRA'
+  | 'QUINTA_FEIRA'
+  | 'SEXTA_FEIRA'
+  | 'SABADO'
+  | 'DOMINGO';
+
+/**
+ * Platform type
+ */
+export type Platform = 'APP' | 'WEB';
+
+/**
+ * Creditor information (payment recipient)
+ */
+export interface Creditor {
+  name: string; // Required
+  personType: PersonType; // Required
+  cpfCnpj: string; // Required
+  accountNumber: string; // Required
+  accountIssuer: string; // Required
+  accountPixKey: string; // Required
+  accountIspb: string; // Required
+  accountType: AccountType; // Required
+}
+
+/**
+ * Debitor information (payment sender)
+ */
+export interface Debitor {
+  accountNumber?: string;
+  accountIssuer?: string;
+  accountIspb?: string;
+  accountType?: AccountType;
+}
+
+/**
+ * Single payment schedule
+ */
+export interface SingleSchedule {
+  date: string; // Format: YYYY-MM-DD
+}
+
+/**
+ * Daily recurring payment schedule
+ */
+export interface DailySchedule {
+  startDate: string; // Format: YYYY-MM-DD
+  quantity: number;
+}
+
+/**
+ * Weekly recurring payment schedule
+ */
+export interface WeeklySchedule {
+  dayOfWeek: DayOfWeek;
+  startDate: string; // Format: YYYY-MM-DD
+  quantity: number;
+}
+
+/**
+ * Monthly recurring payment schedule
+ */
+export interface MonthlySchedule {
+  dayOfMonth: number; // 1-31
+  startDate: string; // Format: YYYY-MM-DD
+  quantity: number;
+}
+
+/**
+ * Custom payment schedule with specific dates
+ */
+export interface CustomSchedule {
+  dates: string[]; // Array of dates in format YYYY-MM-DD
+  additionalInformation?: string;
+}
+
+/**
+ * Payment schedule (only one type should be provided)
+ */
+export interface Schedule {
+  single?: SingleSchedule;
+  daily?: DailySchedule;
+  weekly?: WeeklySchedule;
+  monthly?: MonthlySchedule;
+  custom?: CustomSchedule;
+}
+
+/**
+ * Payment information
+ */
+export interface Payment {
+  details?: string;
+  externalId?: string;
+  redirectUri: string; // Required
+  cpfCnpj?: string;
+  value: number; // Required - must be positive
+  creditor: Creditor; // Required
+  debitor?: Debitor;
+  originalRecurringPaymentId?: string;
+  schedule?: Schedule;
+  txId?: string | string[]; // Can be single string or array
+}
+
+/**
+ * Request payload for consent creation
+ */
+export interface CreateConsentRequest {
+  organisationId: string; // Required
+  authorisationServerId: string; // Required
+  payment: Payment; // Required
+  redirectUri?: string;
+  platform?: Platform;
+}
+
+/**
+ * Response from consent creation API
+ */
+export interface CreateConsentResponse {
+  consentId: string;
+  redirectUrl: string;
+  id: string;
+}
+
+/**
+ * API response wrapper
+ */
+export interface CreateConsentApiResponse {
+  data: CreateConsentResponse;
+  message: string;
+  type: 'success' | 'error';
+}
+

package/src/types/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Public types exported by Lina Pay SDK
+ */
+
+export type { LinaPayCredentials } from './auth.types';
+export type { Participant } from './participants.types';
+export type { LinaPayConfig } from '../config/environment';
+export type {
+  CreateConsentRequest,
+  CreateConsentResponse,
+  Payment,
+  Creditor,
+  Debitor,
+  Schedule,
+  SingleSchedule,
+  DailySchedule,
+  WeeklySchedule,
+  MonthlySchedule,
+  CustomSchedule,
+  PersonType,
+  AccountType,
+  DayOfWeek,
+  Platform,
+} from './consent.types';
+export type {
+  CreatePaymentRequest,
+  CreatePaymentResponse,
+  PaymentItem,
+  PaymentCreditor,
+  PaymentDebitor,
+  PaymentType,
+  PaymentStatus,
+  PaymentItemStatus,
+} from './payment.types';

package/src/types/participants.types.ts

@@ -0,0 +1,53 @@
+/**
+ * API Resource information
+ */
+export interface ApiResource {
+  ApiFamilyType: string;
+  ApiVersion: string;
+  ApiDiscoveryEndpoints: string[];
+}
+
+/**
+ * Authorisation Server (from API response)
+ */
+export interface AuthorisationServer {
+  AuthorisationServerId: string;
+  CustomerFriendlyName: string;
+  CustomerFriendlyDescription: string;
+  CustomerFriendlyLogoUri: string;
+  OpenIDDiscoveryDocument: string;
+  ApiResources: ApiResource[];
+}
+
+/**
+ * Full participant data from API
+ */
+export interface ParticipantFull {
+  OrganisationName: string;
+  OrganisationId: string;
+  LegalEntityName: string;
+  RegistrationNumber: string;
+  ParentOrganisationReference: string;
+  AuthorisationServers: AuthorisationServer[];
+}
+
+/**
+ * API response for participants list
+ */
+export interface ParticipantsApiResponse {
+  data: ParticipantFull[];
+}
+
+/**
+ * Simplified participant data returned by SDK
+ * One entry per AuthorisationServer (flattened from API response)
+ */
+export interface Participant {
+  organisationId: string;
+  organisationName: string;
+  legalEntityName: string;
+  registrationNumber: string;
+  authorisationServerId: string;
+  customerFriendlyName: string;
+  customerFriendlyLogoUri: string;
+}

package/src/types/payment.types.ts

@@ -0,0 +1,141 @@
+/**
+ * Payment types for payment creation
+ */
+
+/**
+ * Payment type
+ */
+export type PaymentType =
+  | 'NOW'
+  | 'SINGLE'
+  | 'DAILY'
+  | 'WEEKLY'
+  | 'MONTHLY'
+  | 'CUSTOM';
+
+/**
+ * Payment status
+ */
+export type PaymentStatus =
+  | 'PENDENTE'
+  | 'EM_PROCESSAMENTO'
+  | 'CONSUMIDO'
+  | 'EXPIRADO'
+  | 'CANCELADO'
+  | 'ERRO_NA_DETENTORA'
+  | 'ERRO';
+
+/**
+ * Payment item status
+ */
+export type PaymentItemStatus =
+  | 'PENDENTE'
+  | 'REJEITADO'
+  | 'EM_PROCESSAMENTO'
+  | 'PAGO'
+  | 'EXPIRADO'
+  | 'CANCELADO'
+  | 'ERRO_NA_DETENTORA'
+  | 'ERRO'
+  | 'PROGRAMADO'
+  | 'AGUARDANDO_VALOR'
+  | 'PRONTO_PARA_ENVIO';
+
+/**
+ * Payment item in the payments array
+ */
+export interface PaymentItem {
+  endToEndId: string;
+  id: string;
+  dueDate: string; // ISO 8601 date
+  externalComment?: string;
+  txId: string | null;
+  status: PaymentItemStatus;
+  externalPaymentId: string;
+}
+
+/**
+ * Creditor information in payment response
+ */
+export interface PaymentCreditor {
+  name: string;
+  personType: 'PESSOA_NATURAL' | 'PESSOA_JURIDICA';
+  cpfCnpj: string;
+  accountIspb: string;
+  accountIssuer: string;
+  accountNumber: string;
+  accountPixKey: string | null;
+  accountType: 'CACC' | 'SLRY' | 'SVGS' | 'TRAN';
+}
+
+/**
+ * Debitor information in payment response
+ */
+export interface PaymentDebitor {
+  accountIspb: string;
+  accountIssuer: string;
+  accountNumber: string;
+  accountType: 'CACC' | 'SLRY' | 'SVGS' | 'TRAN';
+}
+
+/**
+ * Payment data from API
+ */
+export interface PaymentData {
+  id: string;
+  type: PaymentType;
+  createDateTime: string; // ISO 8601 date
+  externalId?: string;
+  externalComment?: string;
+  lastChangedDateTime: string; // ISO 8601 date
+  status: PaymentStatus;
+  tenantId: string;
+  cpfCnpj: string;
+  redirectUri: string;
+  value: string; // Value as string from API
+  consentId: string;
+  creditor: PaymentCreditor;
+  debitor?: PaymentDebitor;
+  payments: PaymentItem[];
+}
+
+/**
+ * Request payload for payment creation
+ */
+export interface CreatePaymentRequest {
+  state: string;
+  code: string;
+  idToken: string;
+  tenantId: string;
+}
+
+/**
+ * Response from payment creation API (with wrapper)
+ */
+export interface CreatePaymentApiResponse {
+  data: PaymentData;
+  message: string;
+  type: 'success' | 'error';
+}
+
+/**
+ * Response from payment creation (transformed, without wrapper)
+ */
+export interface CreatePaymentResponse {
+  id: string;
+  type: PaymentType;
+  createDateTime: string;
+  externalId?: string;
+  externalComment?: string;
+  lastChangedDateTime: string;
+  status: PaymentStatus;
+  tenantId: string;
+  cpfCnpj: string;
+  redirectUri: string;
+  value: string;
+  consentId: string;
+  creditor: PaymentCreditor;
+  debitor?: PaymentDebitor;
+  payments: PaymentItem[];
+}
+