or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

analytics.mdapi.mdauth.mddatastore.mdindex.mdnotifications.mdserver.mdstorage.mdutilities.md
tile.json

tessl/npm-aws-amplify

AWS Amplify is a JavaScript library for Frontend and mobile developers building cloud-enabled applications.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/aws-amplify@6.15.x

To install, run

npx @tessl/cli install tessl/npm-aws-amplify@6.15.0

index.mddocs/

AWS Amplify

AWS Amplify is a comprehensive JavaScript library that provides a declarative interface for building cloud-enabled applications. It offers modular functionality across multiple categories including authentication, analytics, APIs, storage, DataStore, push notifications, and utilities, designed to work seamlessly with React, React Native, and other JavaScript frameworks.

Package Information

  • Package Name: aws-amplify
  • Package Type: npm
  • Language: TypeScript/JavaScript
  • Installation: npm install aws-amplify

Core Imports

import { Amplify } from "aws-amplify";

For specific capabilities:

import { signIn, signUp, signOut } from "aws-amplify/auth";
import { get, post, generateClient } from "aws-amplify/api";
// Or use the data alias: import { generateClient } from "aws-amplify/data";
import { uploadData, downloadData } from "aws-amplify/storage";
import { record, identifyUser } from "aws-amplify/analytics";
import { save, query } from "aws-amplify/datastore";
import { initializePushNotifications } from "aws-amplify/push-notifications";
import { initializeInAppMessaging } from "aws-amplify/in-app-messaging";
import { Hub, I18n } from "aws-amplify/utils";

For provider-specific functionality:

import { signIn } from "aws-amplify/auth/cognito";
import { record } from "aws-amplify/analytics/pinpoint";
import { uploadData } from "aws-amplify/storage/s3";

For server-side usage:

import { runWithAmplifyServerContext } from "aws-amplify/adapter-core";
import { getCurrentUser } from "aws-amplify/auth/server";
import { generateClient } from "aws-amplify/api/server";
import { getUrl, list } from "aws-amplify/storage/server";

CommonJS:

const { Amplify } = require("aws-amplify");
const { signIn, signUp } = require("aws-amplify/auth");

Basic Usage

import { Amplify } from "aws-amplify";
import { signUp, signIn, getCurrentUser } from "aws-amplify/auth";

// Configure Amplify
Amplify.configure({
  Auth: {
    Cognito: {
      userPoolId: "us-east-1_example",
      userPoolClientId: "exampleclientid",
      region: "us-east-1"
    }
  }
});

// Sign up a new user
const { isSignUpComplete, userId } = await signUp({
  username: "user@example.com",
  password: "TempPassword123!",
  options: {
    userAttributes: {
      name: "John Doe"
    }
  }
});

// Sign in
const { isSignedIn } = await signIn({
  username: "user@example.com",
  password: "TempPassword123!"
});

// Get current user
const user = await getCurrentUser();

Architecture

AWS Amplify is built around several key architectural components:

  • Amplify Singleton: Central configuration and management object that coordinates all services
  • Modular Design: Each capability (auth, API, storage, etc.) is available as a separate import path
  • Provider System: Support for multiple backend providers (AWS services, custom implementations)
  • Server Context Support: Dedicated server-side APIs for Next.js, Node.js environments
  • Type Safety: Full TypeScript support with comprehensive type definitions
  • Tree Shaking: Modular imports allow bundlers to include only used functionality

Capabilities

Core Configuration

Central configuration management for all Amplify services and resources.

interface Amplify {
  configure(resourceConfig: ResourcesConfig | LegacyConfig | AmplifyOutputsUnknown, libraryOptions?: LibraryOptions): void;
  getConfig(): ResourcesConfig;
}

interface ResourcesConfig {
  Auth?: AuthConfig;
  API?: APIConfig;
  Storage?: StorageConfig;
  Analytics?: AnalyticsConfig;
  Notifications?: NotificationsConfig;
}

Authentication

Comprehensive authentication system with support for sign-up, sign-in, MFA, social providers, and user management.

function signUp(input: SignUpInput): Promise<SignUpOutput>;
function signIn(input: SignInInput): Promise<SignInOutput>;
function signOut(input?: SignOutInput): Promise<void>;
function getCurrentUser(): Promise<AuthUser>;
function fetchAuthSession(options?: FetchAuthSessionOptions): Promise<AuthSession>;

Authentication

API

REST and GraphQL API capabilities with support for AWS API Gateway, AWS AppSync, and custom endpoints.

function get(apiRequest: RestApiRequest): Promise<RestApiResponse>;
function post(apiRequest: RestApiRequest): Promise<RestApiResponse>;
function generateClient<T = never>(): Client<T>;

interface Client<T> {
  graphql<K extends keyof T>(query: GraphQLQuery<T, K>): Promise<GraphQLResult<T[K]>>;
  cancel(): void;
  isCancelled: boolean;
}

API

Analytics

Event tracking and user analytics with support for Amazon Pinpoint, Kinesis, and other providers.

function record(input: AnalyticsEvent): Promise<void>;
function identifyUser(input: IdentifyUserInput): Promise<void>;
function enable(): void;
function disable(): void;

Analytics

Storage

File upload, download, and management with support for Amazon S3 and custom storage providers.

function uploadData(input: UploadDataInput): Promise<UploadDataOutput>;
function downloadData(input: DownloadDataInput): Promise<DownloadDataOutput>;
function list(input?: ListInput): Promise<ListOutput>;
function remove(input: RemoveInput): Promise<RemoveOutput>;
function getUrl(input: GetUrlInput): Promise<GetUrlOutput>;

Storage

DataStore

Real-time data synchronization with offline support and conflict resolution.

function save<T extends PersistentModel>(model: T): Promise<T>;
function query<T extends PersistentModel>(modelConstructor: PersistentModelConstructor<T>, criteria?: ModelPredicate<T>): Promise<T[]>;
function delete<T extends PersistentModel>(model: T | PersistentModelConstructor<T>): Promise<T | T[]>;
function clear(): Promise<void>;

DataStore

Notifications

Push notifications and in-app messaging with support for Amazon Pinpoint.

// Push notifications
function initializePushNotifications(): Promise<void>;
function requestPermissions(): Promise<boolean>;

// In-app messaging  
function initializeInAppMessaging(): Promise<void>;
function displayMessage(message: InAppMessage): Promise<void>;

Notifications

Utilities

Core utilities including event hub, caching, logging, and storage abstractions.

interface Hub {
  dispatch(channel: string, payload: HubPayload, source?: string): void;
  listen(channel: string, callback: HubCallback): HubCapsule;
  remove(channel: string, listener: HubCapsule): void;
}

interface I18n {
  get(key: string, options?: object): string;
  putVocabularies(vocabularies: object): I18n;
  setLanguage(language: string): I18n;
}

Utilities

Server Context

Server-side support for Next.js, Node.js, and other server environments with proper context isolation.

function runWithAmplifyServerContext<T>(
  context: AmplifyServer,
  operation: (contextSpec: AmplifyServerContextSpec) => T | Promise<T>
): Promise<T>;

interface AmplifyServer {
  config: ResourcesConfig;
  cookies?: CookieOptions;
  headers?: Record<string, string>;
}

Server Context

Types

interface AuthUser {
  userId: string;
  username: string;
  signInDetails?: AuthSignInDetails;
}

interface AuthSession {
  tokens?: AuthTokens;
  credentials?: AWSCredentials;
  userSub?: string;
}

interface AuthTokens {
  accessToken: JWT;
  idToken?: JWT;
  refreshToken?: string;
}

interface JWT {
  toString(): string;
  payload: JWTPayload;
}

interface LegacyConfig {
  [key: string]: any;
}

interface LibraryOptions {
  API?: {
    GraphQL?: {
      maxRetryAttempts?: number;
    };
  };
  Auth?: {
    tokenRefreshHandlers?: Record<string, TokenRefreshHandler>;
    credentialsProvider?: CredentialsProvider;
  };
}