@chaim-tools/cdk-lib 0.1.0

package/lib/services/snapshot-cleanup.js

@@ -0,0 +1,220 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pruneOldSnapshots = exports.pruneStackSnapshots = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os_cache_paths_1 = require("./os-cache-paths");
+/**
+ * Delete all snapshots for a specific stack.
+ *
+ * This is the PRUNE_STACK behavior - scoped to a single stack only.
+ * Deletes: ~/.chaim/cache/snapshots/aws/{account}/{region}/{stackName}/
+ *
+ * @param options - Cleanup options
+ * @returns Cleanup result summary
+ */
+function pruneStackSnapshots(options) {
+    const { stackName, verbose = false } = options;
+    const result = {
+        deletedCount: 0,
+        skippedCount: 0,
+        deletedPaths: [],
+        errors: [],
+    };
+    if (!stackName) {
+        result.errors.push('stackName is required for pruneStackSnapshots');
+        return result;
+    }
+    const accountId = (0, os_cache_paths_1.normalizeAccountId)(options.accountId);
+    const region = (0, os_cache_paths_1.normalizeRegion)(options.region);
+    const stackDir = path.join((0, os_cache_paths_1.getSnapshotBaseDir)(), 'aws', accountId, region, stackName);
+    if (!fs.existsSync(stackDir)) {
+        if (verbose) {
+            console.log(`[Chaim] No snapshots found for stack: ${stackName}`);
+        }
+        return result;
+    }
+    if (verbose) {
+        console.log(`[Chaim] Pruning snapshots for stack: ${stackName}`);
+        console.log(`[Chaim] Path: ${stackDir}`);
+    }
+    try {
+        // Recursively delete stack directory
+        const snapshotFiles = collectSnapshotFiles(stackDir);
+        for (const filePath of snapshotFiles) {
+            try {
+                fs.unlinkSync(filePath);
+                result.deletedCount++;
+                result.deletedPaths.push(filePath);
+                if (verbose) {
+                    console.log(`[Chaim]   Deleted: ${path.relative(stackDir, filePath)}`);
+                }
+            }
+            catch (error) {
+                result.errors.push(`Failed to delete ${filePath}: ${error}`);
+                result.skippedCount++;
+            }
+        }
+        // Clean up empty directories
+        cleanEmptyDirectories(stackDir);
+        if (verbose) {
+            console.log(`[Chaim] Deleted ${result.deletedCount} snapshot(s)`);
+        }
+    }
+    catch (error) {
+        result.errors.push(`Failed to prune stack snapshots: ${error}`);
+    }
+    return result;
+}
+exports.pruneStackSnapshots = pruneStackSnapshots;
+/**
+ * Delete snapshots older than a specified age (TTL cleanup).
+ *
+ * This is a maintenance operation that can be run periodically
+ * to clean up very old snapshots across all stacks.
+ *
+ * @param options - TTL cleanup options
+ * @returns Cleanup result summary
+ */
+function pruneOldSnapshots(options = {}) {
+    const { olderThanDays = 30, dryRun = false, verbose = false, } = options;
+    const result = {
+        deletedCount: 0,
+        skippedCount: 0,
+        deletedPaths: [],
+        errors: [],
+    };
+    const baseDir = (0, os_cache_paths_1.getSnapshotBaseDir)();
+    const now = Date.now();
+    const cutoffMs = olderThanDays * 24 * 60 * 60 * 1000;
+    if (verbose) {
+        console.log(`[Chaim] Scanning for snapshots older than ${olderThanDays} days...`);
+        console.log(`[Chaim] Base directory: ${baseDir}`);
+        if (dryRun) {
+            console.log(`[Chaim] DRY RUN - no files will be deleted`);
+        }
+    }
+    if (!fs.existsSync(baseDir)) {
+        if (verbose) {
+            console.log(`[Chaim] Snapshot directory does not exist: ${baseDir}`);
+        }
+        return result;
+    }
+    try {
+        const allSnapshots = collectSnapshotFiles(baseDir);
+        for (const filePath of allSnapshots) {
+            try {
+                const stats = fs.statSync(filePath);
+                const ageMs = now - stats.mtimeMs;
+                if (ageMs > cutoffMs) {
+                    const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1000));
+                    if (dryRun) {
+                        result.skippedCount++;
+                        if (verbose) {
+                            console.log(`[Chaim] Would delete (${ageDays} days old): ${filePath}`);
+                        }
+                    }
+                    else {
+                        fs.unlinkSync(filePath);
+                        result.deletedCount++;
+                        result.deletedPaths.push(filePath);
+                        if (verbose) {
+                            console.log(`[Chaim] Deleted (${ageDays} days old): ${filePath}`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                result.errors.push(`Failed to process ${filePath}: ${error}`);
+                result.skippedCount++;
+            }
+        }
+        // Clean up empty directories (only if not dry run)
+        if (!dryRun) {
+            cleanEmptyDirectories(baseDir);
+        }
+        if (verbose) {
+            if (dryRun) {
+                console.log(`[Chaim] Would delete ${result.skippedCount} snapshot(s)`);
+            }
+            else {
+                console.log(`[Chaim] Deleted ${result.deletedCount} snapshot(s)`);
+            }
+        }
+    }
+    catch (error) {
+        result.errors.push(`Failed to prune old snapshots: ${error}`);
+    }
+    return result;
+}
+exports.pruneOldSnapshots = pruneOldSnapshots;
+/**
+ * Recursively collect all .json snapshot files in a directory.
+ */
+function collectSnapshotFiles(dir) {
+    const files = [];
+    if (!fs.existsSync(dir)) {
+        return files;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...collectSnapshotFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.json')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+/**
+ * Recursively remove empty directories.
+ */
+function cleanEmptyDirectories(dir) {
+    if (!fs.existsSync(dir)) {
+        return;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    // First, recursively clean subdirectories
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const fullPath = path.join(dir, entry.name);
+            cleanEmptyDirectories(fullPath);
+        }
+    }
+    // Now check if directory is empty and remove it
+    const remainingEntries = fs.readdirSync(dir);
+    if (remainingEntries.length === 0) {
+        try {
+            fs.rmdirSync(dir);
+        }
+        catch {
+            // Ignore errors (directory might not be empty or might be in use)
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snapshot-cleanup.js","sourceRoot":"","sources":["../../src/services/snapshot-cleanup.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { getSnapshotBaseDir, normalizeAccountId, normalizeRegion } from './os-cache-paths';\n\n/**\n * Options for snapshot cleanup operations.\n */\nexport interface CleanupOptions {\n  /**\n   * AWS account ID to scope cleanup.\n   * If undefined, operates on 'unknown' account (for local dev).\n   */\n  accountId?: string;\n\n  /**\n   * AWS region to scope cleanup.\n   * If undefined, operates on 'unknown' region (for local dev).\n   */\n  region?: string;\n\n  /**\n   * CDK stack name to scope cleanup.\n   * REQUIRED for PRUNE_STACK operations.\n   */\n  stackName: string;\n\n  /**\n   * If true, log cleanup operations to console.\n   * Default: false\n   */\n  verbose?: boolean;\n}\n\n/**\n * Options for TTL-based cleanup.\n */\nexport interface TTLCleanupOptions {\n  /**\n   * Delete snapshots older than this many days.\n   * Default: 30 days\n   */\n  olderThanDays?: number;\n\n  /**\n   * If true, perform a dry run without deleting files.\n   * Default: false\n   */\n  dryRun?: boolean;\n\n  /**\n   * If true, log cleanup operations to console.\n   * Default: false\n   */\n  verbose?: boolean;\n}\n\n/**\n * Result of a cleanup operation.\n */\nexport interface CleanupResult {\n  /** Number of snapshots deleted */\n  deletedCount: number;\n\n  /** Number of snapshots found but not deleted (dry run or errors) */\n  skippedCount: number;\n\n  /** Paths of deleted snapshot files */\n  deletedPaths: string[];\n\n  /** Errors encountered during cleanup */\n  errors: string[];\n}\n\n/**\n * Delete all snapshots for a specific stack.\n * \n * This is the PRUNE_STACK behavior - scoped to a single stack only.\n * Deletes: ~/.chaim/cache/snapshots/aws/{account}/{region}/{stackName}/\n * \n * @param options - Cleanup options\n * @returns Cleanup result summary\n */\nexport function pruneStackSnapshots(options: CleanupOptions): CleanupResult {\n  const { stackName, verbose = false } = options;\n  const result: CleanupResult = {\n    deletedCount: 0,\n    skippedCount: 0,\n    deletedPaths: [],\n    errors: [],\n  };\n\n  if (!stackName) {\n    result.errors.push('stackName is required for pruneStackSnapshots');\n    return result;\n  }\n\n  const accountId = normalizeAccountId(options.accountId);\n  const region = normalizeRegion(options.region);\n\n  const stackDir = path.join(\n    getSnapshotBaseDir(),\n    'aws',\n    accountId,\n    region,\n    stackName\n  );\n\n  if (!fs.existsSync(stackDir)) {\n    if (verbose) {\n      console.log(`[Chaim] No snapshots found for stack: ${stackName}`);\n    }\n    return result;\n  }\n\n  if (verbose) {\n    console.log(`[Chaim] Pruning snapshots for stack: ${stackName}`);\n    console.log(`[Chaim] Path: ${stackDir}`);\n  }\n\n  try {\n    // Recursively delete stack directory\n    const snapshotFiles = collectSnapshotFiles(stackDir);\n    \n    for (const filePath of snapshotFiles) {\n      try {\n        fs.unlinkSync(filePath);\n        result.deletedCount++;\n        result.deletedPaths.push(filePath);\n        \n        if (verbose) {\n          console.log(`[Chaim]   Deleted: ${path.relative(stackDir, filePath)}`);\n        }\n      } catch (error) {\n        result.errors.push(`Failed to delete ${filePath}: ${error}`);\n        result.skippedCount++;\n      }\n    }\n\n    // Clean up empty directories\n    cleanEmptyDirectories(stackDir);\n\n    if (verbose) {\n      console.log(`[Chaim] Deleted ${result.deletedCount} snapshot(s)`);\n    }\n  } catch (error) {\n    result.errors.push(`Failed to prune stack snapshots: ${error}`);\n  }\n\n  return result;\n}\n\n/**\n * Delete snapshots older than a specified age (TTL cleanup).\n * \n * This is a maintenance operation that can be run periodically\n * to clean up very old snapshots across all stacks.\n * \n * @param options - TTL cleanup options\n * @returns Cleanup result summary\n */\nexport function pruneOldSnapshots(options: TTLCleanupOptions = {}): CleanupResult {\n  const {\n    olderThanDays = 30,\n    dryRun = false,\n    verbose = false,\n  } = options;\n\n  const result: CleanupResult = {\n    deletedCount: 0,\n    skippedCount: 0,\n    deletedPaths: [],\n    errors: [],\n  };\n\n  const baseDir = getSnapshotBaseDir();\n  const now = Date.now();\n  const cutoffMs = olderThanDays * 24 * 60 * 60 * 1000;\n\n  if (verbose) {\n    console.log(`[Chaim] Scanning for snapshots older than ${olderThanDays} days...`);\n    console.log(`[Chaim] Base directory: ${baseDir}`);\n    if (dryRun) {\n      console.log(`[Chaim] DRY RUN - no files will be deleted`);\n    }\n  }\n\n  if (!fs.existsSync(baseDir)) {\n    if (verbose) {\n      console.log(`[Chaim] Snapshot directory does not exist: ${baseDir}`);\n    }\n    return result;\n  }\n\n  try {\n    const allSnapshots = collectSnapshotFiles(baseDir);\n\n    for (const filePath of allSnapshots) {\n      try {\n        const stats = fs.statSync(filePath);\n        const ageMs = now - stats.mtimeMs;\n\n        if (ageMs > cutoffMs) {\n          const ageDays = Math.floor(ageMs / (24 * 60 * 60 * 1000));\n          \n          if (dryRun) {\n            result.skippedCount++;\n            if (verbose) {\n              console.log(`[Chaim] Would delete (${ageDays} days old): ${filePath}`);\n            }\n          } else {\n            fs.unlinkSync(filePath);\n            result.deletedCount++;\n            result.deletedPaths.push(filePath);\n            \n            if (verbose) {\n              console.log(`[Chaim] Deleted (${ageDays} days old): ${filePath}`);\n            }\n          }\n        }\n      } catch (error) {\n        result.errors.push(`Failed to process ${filePath}: ${error}`);\n        result.skippedCount++;\n      }\n    }\n\n    // Clean up empty directories (only if not dry run)\n    if (!dryRun) {\n      cleanEmptyDirectories(baseDir);\n    }\n\n    if (verbose) {\n      if (dryRun) {\n        console.log(`[Chaim] Would delete ${result.skippedCount} snapshot(s)`);\n      } else {\n        console.log(`[Chaim] Deleted ${result.deletedCount} snapshot(s)`);\n      }\n    }\n  } catch (error) {\n    result.errors.push(`Failed to prune old snapshots: ${error}`);\n  }\n\n  return result;\n}\n\n/**\n * Recursively collect all .json snapshot files in a directory.\n */\nfunction collectSnapshotFiles(dir: string): string[] {\n  const files: string[] = [];\n\n  if (!fs.existsSync(dir)) {\n    return files;\n  }\n\n  const entries = fs.readdirSync(dir, { withFileTypes: true });\n\n  for (const entry of entries) {\n    const fullPath = path.join(dir, entry.name);\n\n    if (entry.isDirectory()) {\n      files.push(...collectSnapshotFiles(fullPath));\n    } else if (entry.isFile() && entry.name.endsWith('.json')) {\n      files.push(fullPath);\n    }\n  }\n\n  return files;\n}\n\n/**\n * Recursively remove empty directories.\n */\nfunction cleanEmptyDirectories(dir: string): void {\n  if (!fs.existsSync(dir)) {\n    return;\n  }\n\n  const entries = fs.readdirSync(dir, { withFileTypes: true });\n\n  // First, recursively clean subdirectories\n  for (const entry of entries) {\n    if (entry.isDirectory()) {\n      const fullPath = path.join(dir, entry.name);\n      cleanEmptyDirectories(fullPath);\n    }\n  }\n\n  // Now check if directory is empty and remove it\n  const remainingEntries = fs.readdirSync(dir);\n  if (remainingEntries.length === 0) {\n    try {\n      fs.rmdirSync(dir);\n    } catch {\n      // Ignore errors (directory might not be empty or might be in use)\n    }\n  }\n}\n"]}

package/lib/types/base-binder-props.d.ts

@@ -0,0 +1,32 @@
+import { TableBindingConfig } from './table-binding-config';
+/**
+ * Base properties shared by all Chaim data store binders.
+ */
+export interface BaseBinderProps {
+    /** Path to the .bprint schema file (JSON format) */
+    readonly schemaPath: string;
+    /**
+     * Binding configuration (appId, credentials, failureMode).
+     *
+     * For single-table design, create one config and share across all entity bindings.
+     *
+     * @example
+     * ```typescript
+     * const config = new TableBindingConfig(
+     *   'my-app',
+     *   ChaimCredentials.fromSecretsManager('chaim/api-credentials')
+     * );
+     *
+     * new ChaimDynamoDBBinder(this, 'UserBinding', {
+     *   schemaPath: './schemas/user.bprint',
+     *   table: usersTable,
+     *   config,
+     * });
+     * ```
+     */
+    readonly config: TableBindingConfig;
+}
+/**
+ * Validate binder props.
+ */
+export declare function validateBinderProps(props: BaseBinderProps): void;

package/lib/types/base-binder-props.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBinderProps = void 0;
+/**
+ * Validate binder props.
+ */
+function validateBinderProps(props) {
+    if (!props.schemaPath || props.schemaPath.trim() === '') {
+        throw new Error('schemaPath is required and cannot be empty');
+    }
+    if (!props.config) {
+        throw new Error('config is required. Create a TableBindingConfig with your appId and credentials.');
+    }
+    // TableBindingConfig validates itself in its constructor
+}
+exports.validateBinderProps = validateBinderProps;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/credentials.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Interface for Chaim API credentials.
+ * Use ChaimCredentials factory methods to create instances.
+ */
+export interface IChaimCredentials {
+    /** The type of credential configuration */
+    readonly credentialType: 'secretsManager' | 'direct';
+    /** Secret name in AWS Secrets Manager (only for secretsManager type) */
+    readonly secretName?: string;
+    /** API key for direct authentication (only for direct type) */
+    readonly apiKey?: string;
+    /** API secret for direct authentication (only for direct type) */
+    readonly apiSecret?: string;
+}
+/**
+ * Factory class for creating Chaim API credentials.
+ *
+ * @example
+ * ```typescript
+ * // Using AWS Secrets Manager (recommended for production)
+ * const credentials = ChaimCredentials.fromSecretsManager('chaim/api-credentials');
+ *
+ * // Using direct API keys (for development/testing)
+ * const credentials = ChaimCredentials.fromApiKeys(
+ *   process.env.CHAIM_API_KEY!,
+ *   process.env.CHAIM_API_SECRET!
+ * );
+ * ```
+ */
+export declare class ChaimCredentials {
+    /**
+     * Create credentials from AWS Secrets Manager.
+     *
+     * The secret must contain JSON with `apiKey` and `apiSecret` fields:
+     * ```json
+     * {
+     *   "apiKey": "your-chaim-api-key",
+     *   "apiSecret": "your-chaim-api-secret"
+     * }
+     * ```
+     *
+     * @param secretName - The name or ARN of the secret in AWS Secrets Manager
+     * @returns Credentials configured to use Secrets Manager
+     */
+    static fromSecretsManager(secretName: string): IChaimCredentials;
+    /**
+     * Create credentials from direct API key and secret.
+     *
+     * Note: For production deployments, prefer `fromSecretsManager()` to avoid
+     * exposing credentials in CDK code or environment variables.
+     *
+     * @param apiKey - The Chaim API key
+     * @param apiSecret - The Chaim API secret
+     * @returns Credentials configured with direct API keys
+     */
+    static fromApiKeys(apiKey: string, apiSecret: string): IChaimCredentials;
+}

package/lib/types/credentials.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChaimCredentials = void 0;
+/**
+ * Internal implementation for Secrets Manager credentials.
+ */
+class SecretsManagerCredentials {
+    credentialType = 'secretsManager';
+    secretName;
+    constructor(secretName) {
+        if (!secretName || secretName.trim() === '') {
+            throw new Error('secretName is required and cannot be empty');
+        }
+        this.secretName = secretName;
+    }
+}
+/**
+ * Internal implementation for direct API credentials.
+ */
+class DirectCredentials {
+    credentialType = 'direct';
+    apiKey;
+    apiSecret;
+    constructor(apiKey, apiSecret) {
+        if (!apiKey || apiKey.trim() === '') {
+            throw new Error('apiKey is required and cannot be empty');
+        }
+        if (!apiSecret || apiSecret.trim() === '') {
+            throw new Error('apiSecret is required and cannot be empty');
+        }
+        this.apiKey = apiKey;
+        this.apiSecret = apiSecret;
+    }
+}
+/**
+ * Factory class for creating Chaim API credentials.
+ *
+ * @example
+ * ```typescript
+ * // Using AWS Secrets Manager (recommended for production)
+ * const credentials = ChaimCredentials.fromSecretsManager('chaim/api-credentials');
+ *
+ * // Using direct API keys (for development/testing)
+ * const credentials = ChaimCredentials.fromApiKeys(
+ *   process.env.CHAIM_API_KEY!,
+ *   process.env.CHAIM_API_SECRET!
+ * );
+ * ```
+ */
+class ChaimCredentials {
+    /**
+     * Create credentials from AWS Secrets Manager.
+     *
+     * The secret must contain JSON with `apiKey` and `apiSecret` fields:
+     * ```json
+     * {
+     *   "apiKey": "your-chaim-api-key",
+     *   "apiSecret": "your-chaim-api-secret"
+     * }
+     * ```
+     *
+     * @param secretName - The name or ARN of the secret in AWS Secrets Manager
+     * @returns Credentials configured to use Secrets Manager
+     */
+    static fromSecretsManager(secretName) {
+        return new SecretsManagerCredentials(secretName);
+    }
+    /**
+     * Create credentials from direct API key and secret.
+     *
+     * Note: For production deployments, prefer `fromSecretsManager()` to avoid
+     * exposing credentials in CDK code or environment variables.
+     *
+     * @param apiKey - The Chaim API key
+     * @param apiSecret - The Chaim API secret
+     * @returns Credentials configured with direct API keys
+     */
+    static fromApiKeys(apiKey, apiSecret) {
+        return new DirectCredentials(apiKey, apiSecret);
+    }
+}
+exports.ChaimCredentials = ChaimCredentials;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/data-store-metadata.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Base metadata interface for all data store types.
+ * Each data store binder extends this with store-specific fields.
+ */
+export interface BaseDataStoreMetadata {
+    /** Data store type identifier */
+    readonly type: string;
+    /** AWS region */
+    readonly region: string;
+    /** Encryption key ARN (if configured) */
+    readonly encryptionKeyArn?: string;
+}
+/**
+ * DynamoDB table metadata captured during binding.
+ *
+ * Note: Removed duplicate fields from v1.1:
+ * - arn (use tableArn instead - globally unique)
+ * - name (use tableName instead)
+ * - account (use top-level accountId instead)
+ */
+export interface DynamoDBMetadata extends BaseDataStoreMetadata {
+    readonly type: 'dynamodb';
+    /** Table name */
+    readonly tableName: string;
+    /** Table ARN (globally unique identifier) */
+    readonly tableArn: string;
+    /** Partition key attribute name */
+    readonly partitionKey: string;
+    /** Sort key attribute name (if composite key) */
+    readonly sortKey?: string;
+    /** Global Secondary Indexes */
+    readonly globalSecondaryIndexes?: GSIMetadata[];
+    /** Local Secondary Indexes */
+    readonly localSecondaryIndexes?: LSIMetadata[];
+    /** TTL attribute name (if enabled) */
+    readonly ttlAttribute?: string;
+    /** Whether DynamoDB Streams is enabled */
+    readonly streamEnabled?: boolean;
+    /** Stream view type (if streams enabled) */
+    readonly streamViewType?: string;
+    /** Billing mode */
+    readonly billingMode?: 'PAY_PER_REQUEST' | 'PROVISIONED';
+}
+/**
+ * Global Secondary Index metadata
+ */
+export interface GSIMetadata {
+    readonly indexName: string;
+    readonly partitionKey: string;
+    readonly sortKey?: string;
+    readonly projectionType: 'ALL' | 'KEYS_ONLY' | 'INCLUDE';
+    readonly nonKeyAttributes?: string[];
+}
+/**
+ * Local Secondary Index metadata
+ */
+export interface LSIMetadata {
+    readonly indexName: string;
+    readonly sortKey: string;
+    readonly projectionType: 'ALL' | 'KEYS_ONLY' | 'INCLUDE';
+    readonly nonKeyAttributes?: string[];
+}
+/**
+ * Union type for all supported data store metadata.
+ * Extend this union as new data stores are added.
+ */
+export type DataStoreMetadata = DynamoDBMetadata;

package/lib/types/data-store-metadata.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Future: | AuroraMetadata | RDSMetadata | DocumentDBMetadata;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/failure-mode.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Behavior when schema ingestion fails during deployment.
+ */
+export declare enum FailureMode {
+    /**
+     * Log errors but return SUCCESS to CloudFormation.
+     * Deployment continues even if ingestion fails.
+     * This is the default.
+     */
+    BEST_EFFORT = "BEST_EFFORT",
+    /**
+     * Return FAILED to CloudFormation on any ingestion error.
+     * WARNING: Deployment will roll back if ingestion fails.
+     */
+    STRICT = "STRICT"
+}

package/lib/types/failure-mode.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailureMode = void 0;
+/**
+ * Behavior when schema ingestion fails during deployment.
+ */
+var FailureMode;
+(function (FailureMode) {
+    /**
+     * Log errors but return SUCCESS to CloudFormation.
+     * Deployment continues even if ingestion fails.
+     * This is the default.
+     */
+    FailureMode["BEST_EFFORT"] = "BEST_EFFORT";
+    /**
+     * Return FAILED to CloudFormation on any ingestion error.
+     * WARNING: Deployment will roll back if ingestion fails.
+     */
+    FailureMode["STRICT"] = "STRICT";
+})(FailureMode = exports.FailureMode || (exports.FailureMode = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmFpbHVyZS1tb2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3R5cGVzL2ZhaWx1cmUtbW9kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7R0FFRztBQUNILElBQVksV0FhWDtBQWJELFdBQVksV0FBVztJQUNyQjs7OztPQUlHO0lBQ0gsMENBQTJCLENBQUE7SUFFM0I7OztPQUdHO0lBQ0gsZ0NBQWlCLENBQUE7QUFDbkIsQ0FBQyxFQWJXLFdBQVcsR0FBWCxtQkFBVyxLQUFYLG1CQUFXLFFBYXRCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBCZWhhdmlvciB3aGVuIHNjaGVtYSBpbmdlc3Rpb24gZmFpbHMgZHVyaW5nIGRlcGxveW1lbnQuXG4gKi9cbmV4cG9ydCBlbnVtIEZhaWx1cmVNb2RlIHtcbiAgLyoqXG4gICAqIExvZyBlcnJvcnMgYnV0IHJldHVybiBTVUNDRVNTIHRvIENsb3VkRm9ybWF0aW9uLlxuICAgKiBEZXBsb3ltZW50IGNvbnRpbnVlcyBldmVuIGlmIGluZ2VzdGlvbiBmYWlscy5cbiAgICogVGhpcyBpcyB0aGUgZGVmYXVsdC5cbiAgICovXG4gIEJFU1RfRUZGT1JUID0gJ0JFU1RfRUZGT1JUJyxcblxuICAvKipcbiAgICogUmV0dXJuIEZBSUxFRCB0byBDbG91ZEZvcm1hdGlvbiBvbiBhbnkgaW5nZXN0aW9uIGVycm9yLlxuICAgKiBXQVJOSU5HOiBEZXBsb3ltZW50IHdpbGwgcm9sbCBiYWNrIGlmIGluZ2VzdGlvbiBmYWlscy5cbiAgICovXG4gIFNUUklDVCA9ICdTVFJJQ1QnLFxufVxuXG4iXX0=