External Service Integration

Lazy Loading

Connection Pooling

Optimize resource usage with smart connection management.

Type Safety

Available Bindings

GraphQL Client

Type-safe GraphQL operations with automatic query validation.

HTTP Client

Configurable HTTP client with retry and circuit breaker support.

Database Clients

Optimized database access with connection pooling.

Message Queues

Reliable message queue integration for async operations.

Client Configuration

Configuration options often include settings for reliability features like retries and circuit breakers. Learn more in Retry Policies.

import { defineWorkflow } from '@identity-flow/sdk';
import { createGraphqlClient } from '@identity-flow/sdk/bindings/graphql';

const GraphqlClient = () => createGraphqlClient({
url: 'https://api.example.com/graphql',
headers: {
'Authorization': 'Bearer ${process.env.API_TOKEN}'
},
retries: {
limit: 3,
backoff: 'exponential'
},
circuitBreaker: {
failureThreshold: 5,
resetTimeout: '1 minute'
},
caching: {
ttl: '5 minutes',
staleWhileRevalidate: true
}
});

See [Retry Policies](../15-retry-policies/) for detailed configuration.

const HttpClient = () => createHttpClient({
  baseURL: 'https://api.example.com',
  timeout: '30 seconds',
  retries: {
    limit: 3,
    backoff: 'exponential'
  },
  circuitBreaker: {
    failureThreshold: 5,
    resetTimeout: '1 minute'
  },
  keepAlive: true,
  compression: true,
  agent: {
    maxSockets: 100,
    keepAlive: true,
    timeout: 60000
  }
});

const DbClient = () => createDbClient({
  poolSize: 10,
  minConnections: 2,
  maxIdleTime: '5 minutes',
  retries: {
    limit: 3,
    backoff: 'exponential'
  },
  circuitBreaker: {
    failureThreshold: 5,
    resetTimeout: '1 minute'
  },
  queryTimeout: '30 seconds',
  ssl: true,
  monitoring: {
    metrics: true,
    slowQueryThreshold: '1 second'
  }
});

const QueueClient = () => createQueueClient({
  prefetch: 10,
  retries: {
    limit: 3,
    backoff: 'exponential'
  },
  deadLetter: {
    exchange: 'dlx',
    routingKey: 'dead-letter'
  },
  monitoring: {
    metrics: true,
    healthCheck: {
      interval: '30 seconds',
      timeout: '5 seconds'
    }
  }
});

Usage Examples

export default defineWorkflow('user-data-sync', async (flow) => {
  const client = flow.use(GraphqlClient);

// Type-safe query execution
const user = await flow.do('fetch user data', async () => {
return client.request<{ user: User }>(`       query GetUser($id: ID!) {
        user(id: $id) {
          id
          name
          email
          profile {
            avatar
            bio
          }
        }
      }
    `, { id: flow.params.userId });
});

// Process results
await flow.do('update local data', async () => {
await updateUserData(user.data.user);
});
});

export default defineWorkflow('data-processing', async (flow) => {
  const db = flow.use(DbClient);

// Transaction handling
await flow.do('process data', async () => {
const result = await db.transaction(async (tx) => {
// Query with parameterized values
const user = await tx.query(
'SELECT \* FROM users WHERE id = $1',
[flow.params.userId]
);

      // Batch operations
      await tx.batch([
        ['UPDATE users SET last_login = NOW() WHERE id = $1', [user.id]],
        ['INSERT INTO audit_log (user_id, action) VALUES ($1, $2)', [user.id, 'login']]
      ]);

      return user;
    });

    return result;

});
});

export default defineWorkflow('event-processing', async (flow) => {
  const queue = flow.use(QueueClient);

// Publish with confirmation
await flow.do('publish event', async () => {
await queue.publish('events', {
type: 'user.created',
data: flow.params,
timestamp: new Date().toISOString()
}, {
persistent: true,
priority: 1,
expiration: '24h'
});
});

// Consume messages
await flow.do('process messages', async () => {
await queue.consume('events', async (msg) => {
try {
await processMessage(msg);
await msg.ack();
} catch (error) {
await msg.nack({ requeue: true });
}
});
});
});

export default defineWorkflow('api-integration', async (flow) => {
  const client = flow.use(HttpClient);

// Request with automatic retries
const response = await flow.do('fetch data', async () => {
return client.get('/users', {
params: { id: flow.params.userId },
headers: {
'Accept': 'application/json',
'X-Request-ID': flow.instance.id
},
validateStatus: (status) => status === 200
});
});

// Handle response
await flow.do('process response', async () => {
if (response.data.status === 'success') {
await processUserData(response.data.user);
}
});
});

Error Handling

Circuit Breaker Pattern

export default defineWorkflow('resilient-integration', async (flow) => {
  const client = flow.use(HttpClient);

  await flow.do(
    'external api call',
    { circuitBreaker: { failureThreshold: 5, resetTimeout: '1 minute', halfOpenMaxCalls: 1 } },
    async () => {
      try {
        return await client.get('/api/data');
      } catch (error) {
        if (error.code === 'RATE_LIMITED') {
          // Add retry delay hint
          error.retryAfter = '60 seconds';
        }
        throw error;
      }
    },
  );
});

Fallback Strategies

export default defineWorkflow('reliable-integration', async (flow) => {
  const primary = flow.use(HttpClient);
  const backup = flow.use(BackupClient);

  await flow.do(
    'fetch data',
    {
      fallback: async (error) => {
        if (error.code === 'SERVICE_UNAVAILABLE') {
          // Use backup service
          return await backup.get('/api/data');
        }
        throw error;
      },
    },
    async () => {
      return await primary.get('/api/data');
    },
  );
});

Resource Management

Connection Pooling

Configure appropriate pool sizes and timeouts for optimal resource usage.

Circuit Breakers

Protect your system from cascading failures with circuit breakers.

Rate Limiting

Implement rate limiting to respect API quotas and prevent overload.

Example: Resource Configuration

const DbClient = () =>
  createDbClient({
    // Connection pool settings
    poolSize: 10,
    minConnections: 2,
    maxIdleTime: '5 minutes',

    // Circuit breaker
    circuitBreaker: { failureThreshold: 5, resetTimeout: '1 minute' },

    // Rate limiting
    rateLimit: { maxRequests: 1000, perInterval: '1 minute' },

    // Monitoring
    monitoring: {
      metrics: true,
      slowQueryThreshold: '1 second',
      healthCheck: { interval: '30 seconds' },
    },
  });