Absolutely, you can make this work! Since most npm modules only handle single-table exports, you’ll just need to add some custom logic to aggregate data from multiple tables into one CSV, then push it to S3. Here are a few practical, battle-tested approaches:

This method leverages AWS SDK v3 and a lightweight CSV writer to scan multiple tables, combine their data, and upload the final CSV to S3. It’s ideal for small-to-medium datasets and fits seamlessly into Serverless frameworks like AWS Lambda.

Step 1: Install Dependencies #

First, add the required packages to your project:

npm install @aws-sdk/client-dynamodb @aws-sdk/client-s3 @aws-sdk/util-dynamodb csv-writer

Step 2: Write the Script #

Here’s a complete, reusable script that handles pagination (critical for large DynamoDB tables), auto-merges headers from different tables, and uploads to S3:

const { DynamoDBClient, ScanCommand } = require("@aws-sdk/client-dynamodb");
const { unmarshall } = require("@aws-sdk/util-dynamodb");
const { S3Client, PutObjectCommand } = require("@aws-sdk/client-s3");
const createCsvWriter = require('csv-writer').createObjectCsvWriter;
const fs = require('fs').promises;

// Initialize AWS clients (use your region)
const dynamoClient = new DynamoDBClient({ region: 'us-east-1' });
const s3Client = new S3Client({ region: 'us-east-1' });

// Configure your resources
const CONFIG = {
  TABLES: ['CustomerTable', 'OrderTable', 'ProductTable'], // Your tables here
  S3_BUCKET: 'your-export-bucket-name',
  TEMP_CSV_PATH: '/tmp/combined-dynamo-data.csv' // Use /tmp for Lambda's ephemeral storage
};

// Scan all items from a DynamoDB table (handles pagination)
async function fetchAllTableItems(tableName) {
  let allItems = [];
  let lastEvaluatedKey = null;

  do {
    const scanCmd = new ScanCommand({
      TableName: tableName,
      ExclusiveStartKey: lastEvaluatedKey
    });

    const response = await dynamoClient.send(scanCmd);
    // Convert DynamoDB's native format to regular JS objects
    const parsedItems = response.Items.map(item => unmarshall(item));
    allItems = [...allItems, ...parsedItems];
    lastEvaluatedKey = response.LastEvaluatedKey;
  } while (lastEvaluatedKey); // Keep scanning until no more items

  // Optional: Add a source table identifier to track where each row came from
  return allItems.map(item => ({ ...item, source_table: tableName }));
}

// Main workflow
async function exportCombineAndUpload() {
  try {
    // Fetch data from all tables
    console.log('Starting data fetch from tables...');
    const combinedData = [];
    for (const table of CONFIG.TABLES) {
      console.log(`Scanning table: ${table}`);
      const tableData = await fetchAllTableItems(table);
      combinedData.push(...tableData);
    }

    // Auto-generate CSV headers from all unique fields across tables
    const allUniqueFields = [...new Set(combinedData.flatMap(item => Object.keys(item)))];
    const csvWriter = createCsvWriter({
      path: CONFIG.TEMP_CSV_PATH,
      header: allUniqueFields.map(field => ({ id: field, title: field.toUpperCase() }))
    });

    // Write combined data to CSV
    await csvWriter.writeRecords(combinedData);
    console.log(`Combined CSV created at ${CONFIG.TEMP_CSV_PATH}`);

    // Upload to S3
    const csvContent = await fs.readFile(CONFIG.TEMP_CSV_PATH);
    const uploadCmd = new PutObjectCommand({
      Bucket: CONFIG.S3_BUCKET,
      Key: `exports/dynamo-combined-${new Date().toISOString().slice(0,10)}.csv`, // Add date for versioning
      Body: csvContent,
      ContentType: 'text/csv'
    });

    await s3Client.send(uploadCmd);
    console.log(`Successfully uploaded to S3: s3://${CONFIG.S3_BUCKET}/${uploadCmd.input.Key}`);

    // Clean up temp file (optional in Lambda, as /tmp resets after execution)
    await fs.unlink(CONFIG.TEMP_CSV_PATH);
  } catch (err) {
    console.error('Workflow failed:', err);
    throw err;
  }
}

// Run the workflow
exportCombineAndUpload();

Step 3: IAM Permissions #

Make sure your execution environment (Lambda, local machine) has these IAM permissions:

• dynamodb:Scan on all target tables
• s3:PutObject on your target S3 bucket

If you’re dealing with huge tables that would timeout a single Lambda, use Step Functions to parallelize the table scans, then merge the results:

1. Initiate: A start Lambda lists all tables to export.
2. Parallel Scans: For each table, run a dedicated Lambda to scan and save partial CSV data to S3.
3. Merge CSVs: A final Lambda pulls all partial CSVs, combines them into one, and uploads the final version.
4. Cleanup: (Optional) Delete partial files from S3.

This approach scales better for large workloads and avoids Lambda timeout limits.

For enterprise-scale datasets, use AWS Glue (a serverless ETL service):

1. Crawl Tables: Create a Glue Crawler to scan all your DynamoDB tables and populate the Glue Data Catalog with schema info.
2. Create ETL Job: Build a Glue Job that reads all tables from the Data Catalog, unions the datasets, and writes the output to S3 as a CSV.
3. Schedule: Set up a trigger to run the job on demand or on a schedule.

No custom code required, and Glue handles distributed processing for massive datasets.

• Schema Differences: If your tables have different fields, the CSV will include all unique fields with empty values where data doesn’t exist. You can filter fields manually if needed.
• Lambda Timeouts: For very large tables, split the scan into smaller chunks or use Step Functions to avoid hitting Lambda’s timeout limit (15 mins max).
• Cost: DynamoDB Scan operations consume read capacity units (RCUs), so be mindful of costs for large tables. Use Select: 'ALL_ATTRIBUTES' only if needed, or use pagination to control throughput.

内容的提问来源于stack exchange，提问作者Anbazhagan p