Client Configuration & Setup

/**
 * Main service client for AWS Cognito Identity Provider operations
 * Supports full middleware stack including retry, authentication, logging, and custom middleware
 */
class CognitoIdentityProviderClient {
  constructor(configuration: CognitoIdentityProviderClientConfig);
  
  /** Send a command to the service and return the response */
  send<InputType, OutputType>(
    command: Command<InputType, OutputType>,
    options?: HttpHandlerOptions
  ): Promise<OutputType>;
  
  /** Destroy the client and clean up resources */
  destroy(): void;
}

interface CognitoIdentityProviderClientConfig {
  /** AWS region where the Cognito User Pool is located */
  region?: string | Provider<string>;
  
  /** AWS credentials for authentication */
  credentials?: AwsCredentialIdentityProvider;
  
  /** Custom endpoint URL (useful for testing or custom domains) */
  endpoint?: string | EndpointV2 | Provider<EndpointV2>;
  
  /** Maximum number of retry attempts for failed requests */
  maxAttempts?: number | Provider<number>;
  
  /** Retry mode configuration (standard, adaptive) */
  retryMode?: string | Provider<string>;
  
  /** Custom HTTP handler for requests */
  requestHandler?: HttpHandler;
  
  /** Custom user agent string */
  customUserAgent?: string;
  
  /** Logger for debugging and monitoring */
  logger?: Logger;
  
  /** Default configuration mode */
  defaultsMode?: DefaultsMode;
  
  /** Runtime extensions for middleware customization */
  extensions?: RuntimeExtension[];
}

import { CognitoIdentityProviderClient } from "@aws-sdk/client-cognito-identity-provider";

// Basic client with region
const client = new CognitoIdentityProviderClient({
  region: "us-east-1"
});

// Client with explicit credentials
const clientWithCreds = new CognitoIdentityProviderClient({
  region: "us-east-1",
  credentials: {
    accessKeyId: "AKIAIOSFODNN7EXAMPLE",
    secretAccessKey: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
  }
});

// Client with custom endpoint (for testing)
const testClient = new CognitoIdentityProviderClient({
  region: "us-east-1",
  endpoint: "http://localhost:8000"
});

/**
 * Aggregated client with convenience methods for each operation
 * Extends CognitoIdentityProviderClient with direct method calls
 */
class CognitoIdentityProvider extends CognitoIdentityProviderClient {
  /** User sign-up operation */
  signUp(
    args: SignUpCommandInput,
    options?: HttpHandlerOptions
  ): Promise<SignUpCommandOutput>;
  
  /** User authentication initiation */
  initiateAuth(
    args: InitiateAuthCommandInput,
    options?: HttpHandlerOptions
  ): Promise<InitiateAuthCommandOutput>;
  
  /** Create user pool */
  createUserPool(
    args: CreateUserPoolCommandInput,
    options?: HttpHandlerOptions
  ): Promise<CreateUserPoolCommandOutput>;
  
  /** Administrative user creation */
  adminCreateUser(
    args: AdminCreateUserCommandInput,
    options?: HttpHandlerOptions
  ): Promise<AdminCreateUserCommandOutput>;
  
  // ... all other 115 operations as direct methods
}

import { CognitoIdentityProvider } from "@aws-sdk/client-cognito-identity-provider";

const cognito = new CognitoIdentityProvider({
  region: "us-east-1"
});

// Direct method calls instead of commands
const user = await cognito.adminCreateUser({
  UserPoolId: "us-east-1_example123",
  Username: "johndoe",
  UserAttributes: [
    { Name: "email", Value: "john@example.com" }
  ]
});

const authResult = await cognito.initiateAuth({
  AuthFlow: "USER_PASSWORD_AUTH",
  ClientId: "your-client-id",
  AuthParameters: {
    USERNAME: "johndoe",
    PASSWORD: "TempPassword123!"
  }
});

interface EnvironmentConfig {
  /** Node.js specific configuration */
  node?: {
    requestHandler?: NodeHttpHandler;
    logger?: NodeLogger;
  };
  
  /** Browser specific configuration */
  browser?: {
    requestHandler?: FetchHttpHandler;
    credentials?: WebIdentityCredentials;
  };
  
  /** React Native specific configuration */
  reactNative?: {
    requestHandler?: FetchHttpHandler;
    storage?: AsyncStorage;
  };
}

import { CognitoIdentityProviderClient } from "@aws-sdk/client-cognito-identity-provider";
import { NodeHttpHandler } from "@smithy/node-http-handler";
import { fromIni } from "@aws-sdk/credential-providers";

const nodeClient = new CognitoIdentityProviderClient({
  region: "us-east-1",
  credentials: fromIni({ profile: "default" }),
  requestHandler: new NodeHttpHandler({
    httpsAgent: new https.Agent({ keepAlive: true })
  })
});

import { CognitoIdentityProviderClient } from "@aws-sdk/client-cognito-identity-provider";
import { fromCognitoIdentityPool } from "@aws-sdk/credential-providers";

const browserClient = new CognitoIdentityProviderClient({
  region: "us-east-1",
  credentials: fromCognitoIdentityPool({
    identityPoolId: "us-east-1:example-1234-5678-9012-123456789012",
    clientId: "your-cognito-client-id"
  })
});

import { CognitoIdentityProviderClient } from "@aws-sdk/client-cognito-identity-provider";
import { FetchHttpHandler } from "@smithy/fetch-http-handler";

const reactNativeClient = new CognitoIdentityProviderClient({
  region: "us-east-1",
  requestHandler: new FetchHttpHandler(),
  credentials: {
    accessKeyId: "your-access-key",
    secretAccessKey: "your-secret-key"
  }
});

interface AdvancedClientConfig {
  /** Retry configuration for failed requests */
  retryConfig?: {
    maxAttempts: number;
    retryMode: "standard" | "adaptive";
    retryDelayOptions?: {
      base?: number;
      customBackoff?: (attempt: number) => number;
    };
  };
  
  /** Timeout configuration */
  timeoutConfig?: {
    requestTimeout?: number;
    connectionTimeout?: number;
  };
  
  /** Middleware configuration */
  middleware?: {
    addToStart?: Middleware[];
    addToEnd?: Middleware[];
    override?: Record<string, Middleware>;
  };
}

import { CognitoIdentityProviderClient } from "@aws-sdk/client-cognito-identity-provider";

const advancedClient = new CognitoIdentityProviderClient({
  region: "us-east-1",
  maxAttempts: 5,
  retryMode: "adaptive",
  requestHandler: new NodeHttpHandler({
    requestTimeout: 30000,
    connectionTimeout: 5000
  }),
  logger: console,
  defaultsMode: "standard"
});

interface ErrorHandlingConfig {
  /** Service exception handling */
  serviceExceptions: {
    retryable: string[];
    nonRetryable: string[];
  };
  
  /** Network error handling */
  networkErrors: {
    timeoutAction: "retry" | "fail";
    connectionErrorAction: "retry" | "fail";
  };
}

import { 
  CognitoIdentityProviderClient,
  InitiateAuthCommand,
  NotAuthorizedException,
  UserNotFoundException
} from "@aws-sdk/client-cognito-identity-provider";

const client = new CognitoIdentityProviderClient({ region: "us-east-1" });

try {
  const command = new InitiateAuthCommand({
    AuthFlow: "USER_PASSWORD_AUTH",
    ClientId: "your-client-id",
    AuthParameters: {
      USERNAME: "user@example.com",
      PASSWORD: "password123"
    }
  });
  
  const result = await client.send(command);
} catch (error) {
  if (error instanceof NotAuthorizedException) {
    console.log("Invalid credentials");
  } else if (error instanceof UserNotFoundException) {
    console.log("User does not exist");
  } else {
    console.log("Other error:", error.message);
  }
}

interface PaginationConfig {
  /** Default page size for paginated operations */
  pageSize?: number;
  
  /** Starting token for pagination */
  startingToken?: string;
  
  /** Client instance for pagination */
  client: CognitoIdentityProviderClient;
}

interface CognitoIdentityProviderPaginationConfiguration 
  extends PaginationConfiguration {
  client: CognitoIdentityProviderClient;
}

import { 
  paginateListUsers,
  CognitoIdentityProviderClient 
} from "@aws-sdk/client-cognito-identity-provider";

const client = new CognitoIdentityProviderClient({ region: "us-east-1" });

const paginator = paginateListUsers(
  { client, pageSize: 25 },
  { UserPoolId: "us-east-1_example123" }
);

for await (const page of paginator) {
  console.log("Users:", page.Users);
  console.log("Next page token:", page.PaginationToken);
}