API Connector Package

A dynamic and flexible TypeScript-based API connector package designed to facilitate seamless integration between a local database and external APIs. The package includes features like dynamic field mapping, endpoint configuration, and robust authentication support.

Features

• Dynamic API Configuration: Manage API settings like base URL, authentication, and headers dynamically.
• Endpoint Management: Configure endpoints with methods, headers, and field mappings.
• Field Mapping: Dynamically map request and response fields for six resources: Patient, Physician, Facility, Schedule, Slot, and Appointment.
• Authentication: Supports multiple authentication types (BASIC, BEARER, API_KEY, or NONE).
• Retry and Timeout Policies: Define retry strategies and request timeouts for robust communication.
• Prisma Integration: Leverages Prisma for database interactions with models such as ApiConfig, EndpointConfig, and FieldMapping.

Installation

Install the package using npm:

npm install <package-name>

Database Design

Models

• ApiConfig: Stores the top-level configuration for APIs.
• EndpointConfig: Manages endpoint-specific configurations linked to an API.
• FieldMapping: Handles request and response field mappings for endpoints.

Example Schema

model ApiConfig {
  id              String           @id @default(uuid())
  baseUrl         String
  authType        String
  infoForAuthType Json             @default("{}")
  defaultHeaders  Json             @default("{}")
  timeout         Int?
  environment     String?
  retryPolicy     Json             @default("{}")
  orgId           String?
  doneBy          String?
  createdAt       DateTime         @default(now())
  updatedAt       DateTime         @updatedAt
  endpoints       EndpointConfig[]
}

model EndpointConfig {
  id           String         @id @default(uuid())
  name         String
  method       String
  suburl       String
  headers      Json           @default("{}")
  createdAt    DateTime       @default(now())
  updatedAt    DateTime       @updatedAt
  apiConfigId  String
  apiConfig    ApiConfig      @relation(fields: [apiConfigId], references: [id])
  FieldMapping FieldMapping[]

  @@unique([name, apiConfigId])
}

model FieldMapping {
  id              String         @id @default(uuid())
  resourceType    ResourceType
  requestMapping  Json?
  responseMapping Json?
  createdAt       DateTime       @default(now())
  updatedAt       DateTime       @updatedAt
  endpointId      String
  endpoint        EndpointConfig @relation(fields: [endpointId], references: [id])
}

enum ResourceType {
  Patient
  Physician
  Facility
  Schedule
  Slot
  Appointment
}

Usage

API Configuration

Use saveApiConfig to save or update API configurations dynamically:

import { PrismaClient } from '@prisma/client';
import { saveApiConfig } from '<package-name>';

const prisma = new PrismaClient();

const apiConfig = {
  baseUrl: 'https://api.example.com',
  authType: 'BEARER',
  infoForAuthType: { token: 'your-token' },
};

const result = await saveApiConfig(prisma, apiConfig, { orgId: '123' });
console.log(result);

Endpoint Configuration

Save or update endpoint configurations linked to an API configuration:

import { saveEndpointConfig } from '<package-name>';

const endpointConfig = {
  name: 'getPatients',
  method: 'GET',
  suburl: '/patients',
  apiConfigId: 'api-config-id',
};

const result = await saveEndpointConfig(prisma, endpointConfig);
console.log(result);

Field Mapping

Configure dynamic mappings for request and response data:

import { saveFieldMapping } from '<package-name>';

const fieldMapping = {
  resourceType: 'Patient',
  requestMapping: { localField1: 'apiField1', localField2: 'apiField2' },
  responseMapping: { apiField1: 'localField1', apiField2: 'localField2' },
  endpointId: 'endpoint-id',
};

const result = await saveFieldMapping(prisma, fieldMapping);
console.log(result);

API Call with Dynamic Mapping

Make API calls with dynamic field mapping applied to request and response data:

import { callApiWithMapping } from '<package-name>';

const response = await callApiWithMapping(prisma, 'endpoint-id', {
  localField1: 'value1',
});
console.log(response);

Authentication Types

• BASIC: Username and password authentication.
• BEARER: Token-based authentication.
• API_KEY: API key authentication.
• NONE: No authentication.

Development

Directory Structure

/src
  /dto
    api-config.dto.ts
    endpoint-config.dto.ts
    field-mapping.dto.ts
  index.ts

Exported Functions

• saveApiConfig
• updateApiConfig
• saveEndpointConfig
• saveFieldMapping
• callApiWithMapping

Contributing

Contributions are welcome! Submit issues or pull requests on GitHub.

License

MIT License

Let me know if there are additional details or changes you'd like to make!