TypeScript DynamoDB

Ce générateur crée un nouveau projet TypeScript DynamoDB basé sur Amazon DynamoDB, utilisant ElectroDB pour la modélisation d’entités avec sécurité de type. Il génère le code d’application et l’infrastructure nécessaires pour provisionner et gérer une table DynamoDB en utilisant AWS CDK ou Terraform, avec prise en charge de la conception à table unique et développement local intégré via DynamoDB Local.

Utilisation

Générer un projet TypeScript DynamoDB

VSCode

1. Installez le Nx Console VSCode Plugin si ce n'est pas déjà fait
2. Ouvrez la console Nx dans VSCode
3. Cliquez sur Generate (UI) dans la section "Common Nx Commands"
4. Recherchez @aws/nx-plugin - ts#dynamodb
5. Remplissez les paramètres requis
6. Cliquez sur Generate

CLI

pnpm

pnpm nx g @aws/nx-plugin:ts#dynamodb

yarn

yarn nx g @aws/nx-plugin:ts#dynamodb

npm

npx nx g @aws/nx-plugin:ts#dynamodb

bun

bunx nx g @aws/nx-plugin:ts#dynamodb

Vous pouvez également effectuer une simulation pour voir quels fichiers seraient modifiés

pnpm

pnpm nx g @aws/nx-plugin:ts#dynamodb --dry-run

yarn

yarn nx g @aws/nx-plugin:ts#dynamodb --dry-run

npm

npx nx g @aws/nx-plugin:ts#dynamodb --dry-run

bun

bunx nx g @aws/nx-plugin:ts#dynamodb --dry-run

Options

Paramètre	Type	Par défaut	Description
name Requis	string	-	Nom du projet DynamoDB à générer
directory	string	packages	Le répertoire dans lequel stocker le projet.
subDirectory	string	-	Le sous-répertoire dans lequel le projet est placé. Par défaut, il s'agit du nom du projet.
framework	electrodb	electrodb	Le framework à utiliser pour les entités DynamoDB.
tableName	string	-	Le nom de la table DynamoDB. Généré automatiquement si non spécifié.
infra	dynamodb | none	dynamodb	Infrastructure à provisionner pour la table DynamoDB.
iac	inherit | cdk | terraform	inherit	Le fournisseur IaC préféré. Par défaut, celui-ci est hérité de votre sélection initiale.
preferInstallDependencies	boolean	true	Indique s'il faut privilégier l'installation des dépendances après l'exécution du générateur. Définir sur false pour différer l'installation lors de l'exécution de plusieurs générateurs en lot (une installation s'exécute quand même si nécessaire pour que les générateurs suivants puissent calculer le graphe de projet Nx) ; installer une seule fois à la fin.

Sortie du générateur

Le générateur crée la structure de projet suivante dans le répertoire <directory>/<name> :

• Répertoiresrc

  • index.ts Point d’entrée du projet et exports
  • client.ts Singleton du client DynamoDB et résolution du nom de table
  • Répertoireentities

    • example.ts Exemple de définition d’entité ElectroDB
    • index.ts Exports des entités
• config.json Configuration de la table incluant les définitions GSI et les paramètres de développement local
• project.json Configuration du projet et cibles de build

Les scripts de développement local sont partagés entre tous les projets DynamoDB (TypeScript et Python) et générés une fois dans :

• Répertoirepackages/common/scripts/src/dynamodb

  • create-local-table.ts Crée la table DynamoDB dans l’instance DynamoDB Local locale
  • pull-image.ts Télécharge l’image DynamoDB Local
  • start-container.ts Démarre le conteneur DynamoDB Local

Infrastructure

Ce générateur fournit de l’infrastructure as code basée sur votre iacProvider choisi. Il créera un projet dans packages/common qui inclut les constructions CDK ou modules Terraform pertinents.

Le projet commun d’infrastructure as code est structuré comme suit :

CDK

• Répertoirepackages/common/constructs

  • Répertoiresrc

    • Répertoireapp/ Constructions pour l’infrastructure spécifique à un projet/générateur

      • …
    • Répertoirecore/ Constructions génériques réutilisées par celles dans app

      • …
    • index.ts Point d’entrée exportant les constructions depuis app
  • project.json Cibles de build et configuration du projet

Projet généré

Ce projet est généré avec le générateur ts#project et configure donc les mêmes cibles de build.

Terraform

• Répertoirepackages/common/terraform

  • Répertoiresrc

    • Répertoireapp/ Modules Terraform pour l’infrastructure spécifique à un projet/générateur

      • …
    • Répertoirecore/ Modules génériques réutilisés par ceux dans app

      • …
  • project.json Cibles de build et configuration du projet

Projet généré

Ce projet est généré avec le générateur terraform#project et configure donc les mêmes cibles de build.

CDK

• Répertoirepackages/common/constructs/src

  • Répertoireapp

    • Répertoiredynamodb

      • <name>.ts Infrastructure spécifique à votre table
  • Répertoirecore

    • dynamodb.ts Construct générique de table DynamoDB

Terraform

• Répertoirepackages/common/terraform/src

  • Répertoireapp

    • Répertoiredynamodb

      • Répertoire<name>

        • <name>.tf Module spécifique à votre table
  • Répertoirecore

    • Répertoiredynamodb

      • dynamodb.tf Module DynamoDB générique

Développement local

Démarrer DynamoDB Local

Le générateur configure une cible dev qui démarre une instance DynamoDB Local et crée la table. Utilisez la cible dev du projet :

pnpm

pnpm nx dev <project-name>

yarn

yarn nx dev <project-name>

npm

npx nx dev <project-name>

bun

bunx nx dev <project-name>

Cela effectue automatiquement :

1. Télécharge l’image DynamoDB Local (cible pull-image)
2. Démarre un conteneur
3. Crée une table locale avec les index définis dans config.json

Modélisation des données

Le projet généré utilise ElectroDB pour la modélisation d’entités avec sécurité de type sur une seule table DynamoDB, en suivant la conception à table unique de DynamoDB. Ajoutez ou mettez à jour les fichiers d’entités sous src/entities/, en utilisant l’exemple d’entité généré comme point de départ.

Exemple de définition d’entité :

packages/my-table/src/entities/example.ts

import { Entity } from 'electrodb';
import { getDynamoDBClient, resolveTableName } from '../client.js';

export const createExampleEntity = async () =>
  new Entity(
    {
      model: {
        entity: 'example',
        version: '1',
        service: 'MyTable',
      },
      attributes: {
        id: {
          type: 'string',
          required: true,
        },
        createdAt: {
          type: 'string',
          required: true,
          default: () => new Date().toISOString(),
          readOnly: true,
        },
        updatedAt: {
          type: 'string',
          required: true,
          default: () => new Date().toISOString(),
          watch: '*',
          set: () => new Date().toISOString(),
        },
      },
      indexes: {
        primary: {
          pk: {
            field: 'pk',
            composite: ['id'],
          },
          sk: {
            field: 'sk',
            composite: [],
          },
        },
      },
    },
    { client: getDynamoDBClient(), table: await resolveTableName() },
  );

Pour plus de détails, consultez la documentation des entités ElectroDB.

Utilisation du client DynamoDB

Le fichier généré src/client.ts exporte deux utilitaires clés :

• getDynamoDBClient() — retourne un singleton DynamoDBClient en cache. Lorsque LOCAL_DEV=true, se connecte à l’instance DynamoDB Local locale ; sinon crée un client AWS utilisant la chaîne d’identification par défaut.
• resolveTableName() — retourne le nom de la table DynamoDB. Lorsque LOCAL_DEV=true, retourne la constante du nom de table locale ; sinon récupère le nom depuis AWS AppConfig en utilisant la variable d’environnement RUNTIME_CONFIG_APP_ID et le met en cache pour les appels suivants.

Arrêter DynamoDB Local

L’arrêt de dev (par exemple avec Ctrl+C) supprime automatiquement le conteneur DynamoDB Local, mais préserve le volume nommé afin que vos données persistent entre les redémarrages.

Windows

En raison de limitations dans la gestion des signaux sur Windows, le conteneur n’est pas automatiquement supprimé lorsque dev est arrêté. Vous devrez le supprimer manuellement :

<engine> rm -f <scope>-dynamodb

Remplacez <engine> par votre moteur de conteneurs (docker ou finch) et <scope> par la portée de votre espace de travail Nx (par exemple proj).

Ajout/Suppression d’index secondaires globaux

Les GSI sont définis dans config.json à la racine du projet sous la clé tableConfig.globalSecondaryIndexes. Ajoutez une entrée pour chaque GSI, en suivant la convention de nommage de conception à table unique pour les clés GSI :

config.json

{
  ...
  "tableConfig": {
    "globalSecondaryIndexes": [
      {
        "indexName": "gsi1pk-gsi1sk-index",
        "partitionKey": "gsi1pk",
        "sortKey": "gsi1sk"
      },
      {
        "indexName": "gsi2pk-gsi2sk-index",
        "partitionKey": "gsi2pk",
        "sortKey": "gsi2sk"
      }
    ]
  }
}

Le champ sortKey est optionnel pour les GSI avec clé de hachage uniquement.

Ce fichier de configuration est la source unique de vérité lue par tous les consommateurs :

• Développement local — dev lit config.json et crée ou met à jour la table locale pour correspondre à la liste des GSI
• CDK — le construct lit config.json au moment de la synthèse, donc les modifications de GSI sont reflétées lors du prochain cdk deploy
• Terraform — le module lit config.json au moment du plan/apply

Un GSI par Déploiement

Attention

DynamoDB ne permet pas de créer ou supprimer plus d’un GSI dans une seule mise à jour de table.

Chaque déploiement peut ajouter ou supprimer au maximum un GSI. Si vous devez ajouter ou supprimer plusieurs GSI, faites-le un à la fois — mettez à jour config.json et les classes d’entités concernées, déployez la stack, puis répétez pour le changement suivant.

Connexion à la table

Dans n’importe quel projet TypeScript, importez les factories d’entités depuis votre package DynamoDB et utilisez-les directement :

import { createExampleEntity } from ':my-scope/my-table';

const entity = await createExampleEntity();
const result = await entity.query.primary({ id: '123' }).go();

Configuration d’exécution

Lors de l’exécution dans AWS, resolveTableName() récupère le nom de la table depuis AWS AppConfig en utilisant la variable d’environnement RUNTIME_CONFIG_APP_ID. Les projets construits avec ce plugin (API tRPC, API Smithy, agents, serveurs MCP) ont déjà cette variable configurée automatiquement. Pour les autres projets TypeScript, assurez-vous que RUNTIME_CONFIG_APP_ID est définie dans l’environnement d’exécution avec l’ID d’application AppConfig provisionné par votre infrastructure. Pour plus d’informations, consultez le guide de configuration d’exécution.

Déploiement de votre table

Le générateur DynamoDB crée une infrastructure CDK ou Terraform en fonction de votre iac sélectionné.

CDK

Le construct CDK est créé dans common/constructs. Exemple d’utilisation :

packages/infra/src/stacks/application-stack.ts

import { MyTable } from ':my-scope/common-constructs';

export class ApplicationStack extends Stack {
  constructor(scope: Construct, id: string, props?: StackProps) {
    super(scope, id, props);

    const table = new MyTable(this, 'Table');
  }
}

Cela provisionne une table DynamoDB avec :

• pk (clé de partition) et sk (clé de tri), toutes deux de type String
• Des index secondaires globaux tels que définis dans config.json
• Une facturation à la demande (PAY_PER_REQUEST)
• Un chiffrement KMS géré par le client avec rotation automatique des clés
• La récupération à un instant donné activée
• La protection contre la suppression activée
• Le nom de la table enregistré dans Runtime Config sous l’espace de noms dynamodb dans AWS AppConfig

Terraform

Le module Terraform est créé dans common/terraform. Exemple d’utilisation :

packages/infra/src/main.tf

module "my_table" {
  source = "../../common/terraform/src/app/dynamodb/my-table"
}

Cela provisionne une table DynamoDB avec :

• pk (clé de partition) et sk (clé de tri), toutes deux de type String
• Des index secondaires globaux tels que définis dans config.json
• Une facturation à la demande (PAY_PER_REQUEST)
• Un chiffrement KMS géré par le client avec rotation automatique des clés
• La récupération à un instant donné activée
• La protection contre la suppression activée
• Le nom de la table enregistré dans Runtime Config

Accorder l’accès

Pour permettre aux fonctions Lambda d’accéder à la table DynamoDB, accordez les permissions nécessaires dans votre infrastructure.

CDK

Appelez grantReadWriteData sur le construct de la table. Cela accorde à la fois les permissions DynamoDB et KMS requises par le rôle d’exécution Lambda :

packages/infra/src/stacks/application-stack.ts

import { MyTable } from ':my-scope/common-constructs';

const table = new MyTable(this, 'Table');

const api = new Api(this, 'Api', {
  integrations: Api.defaultIntegrations(this).build(),
});

Object.entries(api.integrations).forEach(([, integration]) => {
  table.grantReadWriteData(integration.handler);
});

Note

Cet exemple accorde l’accès à tous les gestionnaires de votre API. Si seuls certains gestionnaires ont besoin d’accès, configurez-les individuellement.

Terraform

Accordez au rôle d’exécution Lambda la permission d’accéder à la table DynamoDB et à sa clé de chiffrement KMS :

packages/infra/src/main.tf

module "my_table" {
  source = "../../common/terraform/src/app/dynamodb/my-table"
}

resource "aws_iam_role_policy" "dynamodb_access" {
  role = module.my_api.lambda_role_name

  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Effect = "Allow"
        Action = [
          "dynamodb:GetItem",
          "dynamodb:PutItem",
          "dynamodb:UpdateItem",
          "dynamodb:DeleteItem",
          "dynamodb:Query",
          "dynamodb:Scan",
          "dynamodb:BatchGetItem",
          "dynamodb:BatchWriteItem",
        ]
        Resource = [
          module.my_table.table_arn,
          "${module.my_table.table_arn}/index/*",
        ]
      },
      {
        Effect = "Allow"
        Action = [
          "kms:Encrypt",
          "kms:Decrypt",
          "kms:ReEncrypt*",
          "kms:GenerateDataKey*",
          "kms:DescribeKey"
        ]
        Resource = [module.my_table.kms_key_arn]
      },
    ]
  })
}

Protection contre la suppression

La protection contre la suppression est activée par défaut pour empêcher la suppression accidentelle de la table.

Désactiver la protection contre la suppression

Désactivez-la pour les environnements où la suppression de la table est attendue, tels que les stacks de développement ou de prévisualisation éphémères.

CDK

packages/infra/src/stacks/application-stack.ts

import { MyTable } from ':my-scope/common-constructs';

const table = new MyTable(this, 'Table', {
  deletionProtection: false,
});

Terraform

packages/infra/src/main.tf

module "my_table" {
  source                      = "../../common/terraform/src/app/dynamodb/my-table"
  deletion_protection_enabled = false
}

Mode de facturation

La table utilise par défaut la facturation à la demande (PAY_PER_REQUEST). Passez à la capacité provisionnée pour des charges de travail prévisibles et à haut débit.

CDK

packages/infra/src/stacks/application-stack.ts

import { BillingMode } from 'aws-cdk-lib/aws-dynamodb';
import { MyTable } from ':my-scope/common-constructs';

const table = new MyTable(this, 'Table', {
  billingMode: BillingMode.PROVISIONED,
  readCapacity: 5,
  writeCapacity: 5,
});

Terraform

packages/infra/src/main.tf

module "my_table" {
  source       = "../../common/terraform/src/app/dynamodb/my-table"
  billing_mode = "PROVISIONED"
}

Récupération à un instant donné

La récupération à un instant donné est activée par défaut, vous permettant de restaurer la table à n’importe quel moment des 35 derniers jours.

Désactiver la récupération à un instant donné

CDK

packages/infra/src/stacks/application-stack.ts

import { MyTable } from ':my-scope/common-constructs';

const table = new MyTable(this, 'Table', {
  pointInTimeRecoverySpecification: { pointInTimeRecoveryEnabled: false },
});

Terraform

packages/infra/src/main.tf

module "my_table" {
  source                         = "../../common/terraform/src/app/dynamodb/my-table"
  point_in_time_recovery_enabled = false
}

Rotation des clés de chiffrement

La clé KMS utilisée pour chiffrer la table a la rotation automatique des clés activée par défaut. Désactivez-la si votre politique de sécurité gère la rotation en externe.

Désactiver la rotation des clés de chiffrement

CDK

packages/infra/src/stacks/application-stack.ts

import { MyTable } from ':my-scope/common-constructs';

const table = new MyTable(this, 'Table', {
  enableKeyRotation: false,
});

Terraform

packages/infra/src/main.tf

module "my_table" {
  source              = "../../common/terraform/src/app/dynamodb/my-table"
  enable_key_rotation = false
}

Connexions

Utilisez le générateur connection pour intégrer ce projet avec d’autres dans votre espace de travail. Les connexions suivantes impliquent ce projet :

API tRPC vers TypeScript DynamoDB Connecter une API tRPC à une table DynamoDB

API Smithy vers TypeScript DynamoDB Connecter une API Smithy à une table DynamoDB

TypeScript Agent vers TypeScript DynamoDB Connecter un TypeScript Agent à une table DynamoDB

Serveur MCP vers TypeScript DynamoDB Connecter un serveur MCP TypeScript à une table DynamoDB