@chaim-tools/cdk-lib 0.1.0

package/lib/binders/base-chaim-binder.js

@@ -0,0 +1,532 @@
+"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.BaseChaimBinder = void 0;
+const cdk = __importStar(require("aws-cdk-lib"));
+const lambda = __importStar(require("aws-cdk-lib/aws-lambda"));
+const iam = __importStar(require("aws-cdk-lib/aws-iam"));
+const cr = __importStar(require("aws-cdk-lib/custom-resources"));
+const constructs_1 = require("constructs");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const base_binder_props_1 = require("../types/base-binder-props");
+const schema_service_1 = require("../services/schema-service");
+const snapshot_cache_policy_1 = require("../types/snapshot-cache-policy");
+const chaim_endpoints_1 = require("../config/chaim-endpoints");
+const os_cache_paths_1 = require("../services/os-cache-paths");
+const snapshot_cleanup_1 = require("../services/snapshot-cleanup");
+/**
+ * Path to the canonical Lambda handler file.
+ * This handler implements the presigned upload flow for Chaim ingestion.
+ */
+const LAMBDA_HANDLER_PATH = path.join(__dirname, '..', 'lambda-handler', 'handler.js');
+/**
+ * Abstract base class for all Chaim data store binders.
+ *
+ * Provides shared infrastructure:
+ * - Schema loading and validation
+ * - Snapshot payload construction
+ * - LOCAL snapshot writing during CDK synth (to OS cache)
+ * - Lambda-backed custom resource for S3 presigned upload + snapshot-ref
+ *
+ * Subclasses implement `extractMetadata()` for store-specific metadata extraction
+ * and optionally override `getTable()` for DynamoDB-like resources.
+ */
+class BaseChaimBinder extends constructs_1.Construct {
+    /** Validated schema data */
+    schemaData;
+    /** Extracted data store metadata */
+    dataStoreMetadata;
+    /** Generated resource ID ({resourceName}__{entityName}[__N]) */
+    resourceId;
+    /** Binding configuration */
+    config;
+    /** Base props (for internal use) */
+    baseProps;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.baseProps = props;
+        this.config = props.config;
+        // Validate props
+        (0, base_binder_props_1.validateBinderProps)(props);
+        // Validate consistency with other bindings to same table
+        this.validateTableConsistency();
+        // Load and validate schema
+        this.schemaData = schema_service_1.SchemaService.readSchema(props.schemaPath);
+        // Extract data store metadata (implemented by subclass)
+        this.dataStoreMetadata = this.extractMetadata();
+        // Build stack context
+        const stack = cdk.Stack.of(this);
+        const stackName = stack.stackName;
+        const datastoreType = this.dataStoreMetadata.type;
+        // Get resource and entity names
+        const resourceName = this.getResourceName();
+        const entityName = this.getEntityName();
+        // Generate resource ID
+        this.resourceId = `${resourceName}__${entityName}`;
+        // Normalize values for paths (handle CDK tokens)
+        const normalizedAccountId = (0, os_cache_paths_1.normalizeAccountId)(stack.account);
+        const normalizedRegion = (0, os_cache_paths_1.normalizeRegion)(stack.region);
+        const normalizedResourceName = (0, os_cache_paths_1.normalizeResourceName)(resourceName);
+        // Update resource ID with normalized name to avoid special characters
+        const normalizedResourceId = `${normalizedResourceName}__${entityName}`;
+        // Build LOCAL snapshot payload
+        const localSnapshot = this.buildLocalSnapshot({
+            accountId: normalizedAccountId,
+            region: normalizedRegion,
+            stackName,
+            datastoreType,
+            resourceName: normalizedResourceName,
+            resourceId: normalizedResourceId,
+        });
+        // Apply snapshot cache policy (cleanup if requested)
+        this.applySnapshotCachePolicy({
+            accountId: normalizedAccountId,
+            region: normalizedRegion,
+            stackName,
+        });
+        // Write LOCAL snapshot to OS cache for chaim-cli consumption
+        this.writeLocalSnapshotToDisk(localSnapshot);
+        // Get or create asset directory
+        const assetDir = this.writeSnapshotAsset(localSnapshot, stackName);
+        // Deploy Lambda-backed custom resource for ingestion
+        this.deployIngestionResources(assetDir);
+    }
+    /**
+     * Validate that all bindings to the same table use the same config.
+     *
+     * This is a safety check - sharing the same TableBindingConfig object
+     * already ensures consistency, but this catches cases where users
+     * create separate configs with identical values.
+     */
+    validateTableConsistency() {
+        // Only for DynamoDB binders (has table property)
+        const table = this.baseProps.table;
+        if (!table) {
+            return;
+        }
+        // Find other binders for the same table
+        const stack = cdk.Stack.of(this);
+        const otherBinders = stack.node.findAll()
+            .filter(node => node instanceof BaseChaimBinder)
+            .filter(binder => binder !== this)
+            .filter(binder => {
+            const otherTable = binder.baseProps.table;
+            return otherTable === table;
+        })
+            .map(binder => binder);
+        if (otherBinders.length === 0) {
+            return; // First binding for this table
+        }
+        const firstBinder = otherBinders[0];
+        // Check if they're using the exact same config object (recommended)
+        if (this.config === firstBinder.config) {
+            return; // Perfect - same config object
+        }
+        // Different config objects - validate they have same values
+        if (this.config.appId !== firstBinder.config.appId) {
+            throw new Error(`Configuration conflict for table "${table.tableName}".\n\n` +
+                `Binder "${firstBinder.node.id}" uses appId: "${firstBinder.config.appId}"\n` +
+                `Binder "${this.node.id}" uses appId: "${this.config.appId}"\n\n` +
+                `All bindings to the same table MUST use the same appId.\n\n` +
+                `RECOMMENDED: Share the same TableBindingConfig object:\n` +
+                `  const config = new TableBindingConfig('${firstBinder.config.appId}', credentials);\n` +
+                `  new ChaimDynamoDBBinder(this, '${firstBinder.node.id}', { ..., config });\n` +
+                `  new ChaimDynamoDBBinder(this, '${this.node.id}', { ..., config });`);
+        }
+        // Validate credentials match
+        const firstCreds = JSON.stringify(firstBinder.config.credentials);
+        const thisCreds = JSON.stringify(this.config.credentials);
+        if (firstCreds !== thisCreds) {
+            throw new Error(`Configuration conflict for table "${table.tableName}".\n\n` +
+                `Binder "${firstBinder.node.id}" uses different credentials than "${this.node.id}".\n\n` +
+                `All bindings to the same table MUST use the same credentials.\n\n` +
+                `RECOMMENDED: Share the same TableBindingConfig object to avoid this error.`);
+        }
+        // Warn about different failureMode (not an error)
+        if (this.config.failureMode !== firstBinder.config.failureMode) {
+            console.warn(`Warning: Different failureMode for table "${table.tableName}".\n` +
+                `  "${firstBinder.node.id}": ${firstBinder.config.failureMode}\n` +
+                `  "${this.node.id}": ${this.config.failureMode}\n` +
+                `Consider sharing the same TableBindingConfig object.`);
+        }
+    }
+    /**
+     * Override in subclasses to provide the table construct for stable identity.
+     * Default returns undefined (will fall back to construct path).
+     */
+    getTable() {
+        return undefined;
+    }
+    /**
+     * Get the resource name for display and filenames.
+     * For DynamoDB, this is the user label (not necessarily the physical table name).
+     *
+     * Subclasses can override this to provide a more meaningful name
+     * (e.g., construct node ID instead of physical resource name which may contain tokens).
+     */
+    getResourceName() {
+        const metadata = this.dataStoreMetadata;
+        return metadata.tableName || metadata.name || 'resource';
+    }
+    /**
+     * Get the entity name from schema.
+     */
+    getEntityName() {
+        return this.schemaData.entityName;
+    }
+    /**
+     * Read package version from package.json.
+     * Used to populate producer metadata in snapshots.
+     */
+    getPackageVersion() {
+        try {
+            const packagePath = path.join(__dirname, '..', '..', 'package.json');
+            const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+            return packageJson.version || '0.0.0';
+        }
+        catch (error) {
+            console.warn('Failed to read package version:', error);
+            return '0.0.0';
+        }
+    }
+    /**
+     * Build a LOCAL snapshot payload for CLI consumption.
+     * Does not include eventId or contentHash - those are generated at deploy-time.
+     */
+    buildLocalSnapshot(params) {
+        const capturedAt = new Date().toISOString();
+        const stack = cdk.Stack.of(this);
+        // Build provider identity
+        const providerIdentity = {
+            cloud: 'aws',
+            accountId: params.accountId,
+            region: params.region,
+            deploymentSystem: 'cloudformation',
+            deploymentId: stack.stackId,
+        };
+        // Build binding identity
+        const stableResourceKey = `${params.datastoreType}:path:${params.stackName}/${params.resourceName}`;
+        const entityId = `${this.config.appId}:${this.schemaData.entityName}`;
+        const bindingId = `${this.config.appId}:${stableResourceKey}:${this.schemaData.entityName}`;
+        const identity = {
+            appId: this.config.appId,
+            entityName: this.schemaData.entityName,
+            stableResourceKeyStrategy: 'cdk-construct-path',
+            stableResourceKey,
+            resourceId: params.resourceId,
+            entityId,
+            bindingId,
+        };
+        // Build operation metadata
+        const operation = {
+            eventId: this.generateUuid(),
+            requestType: 'Create',
+            failureMode: this.config.failureMode,
+        };
+        // Build resolution metadata
+        const hasTokens = this.detectUnresolvedTokens(this.dataStoreMetadata);
+        const resolution = {
+            mode: 'LOCAL',
+            hasTokens,
+        };
+        // Build hashes
+        const schemaBytes = JSON.stringify(this.schemaData);
+        const schemaHash = 'sha256:' + crypto.createHash('sha256').update(schemaBytes).digest('hex');
+        const hashes = {
+            schemaHash,
+            contentHash: '',
+        };
+        // Build resource metadata
+        const resource = this.buildResourceMetadata(params);
+        // Build producer metadata
+        const producer = {
+            component: 'chaim-cdk',
+            version: this.getPackageVersion(),
+            runtime: process.version,
+        };
+        return {
+            snapshotVersion: chaim_endpoints_1.SNAPSHOT_SCHEMA_VERSION,
+            action: 'UPSERT',
+            capturedAt,
+            providerIdentity,
+            identity,
+            operation,
+            resolution,
+            hashes,
+            schema: this.schemaData,
+            resource,
+            producer,
+        };
+    }
+    /**
+     * Build resource metadata from dataStore metadata.
+     */
+    buildResourceMetadata(params) {
+        const dynamoMetadata = this.dataStoreMetadata;
+        return {
+            type: 'dynamodb',
+            kind: 'table',
+            id: dynamoMetadata.tableArn,
+            name: dynamoMetadata.tableName,
+            region: params.region,
+            partitionKey: dynamoMetadata.partitionKey,
+            sortKey: dynamoMetadata.sortKey,
+            globalSecondaryIndexes: dynamoMetadata.globalSecondaryIndexes,
+            localSecondaryIndexes: dynamoMetadata.localSecondaryIndexes,
+            ttlAttribute: dynamoMetadata.ttlAttribute,
+            streamEnabled: dynamoMetadata.streamEnabled,
+            streamViewType: dynamoMetadata.streamViewType,
+            billingMode: dynamoMetadata.billingMode,
+            encryptionKeyArn: dynamoMetadata.encryptionKeyArn,
+        };
+    }
+    /**
+     * Detect if metadata contains unresolved CDK tokens.
+     */
+    detectUnresolvedTokens(metadata) {
+        const str = JSON.stringify(metadata);
+        return str.includes('${Token[');
+    }
+    /**
+     * Generate a UUID v4 for operation tracking.
+     */
+    generateUuid() {
+        return crypto.randomUUID();
+    }
+    /**
+     * Apply snapshot cache policy based on CDK context.
+     *
+     * Checks the `chaimSnapshotCachePolicy` context value:
+     * - NONE (default): No cleanup
+     * - PRUNE_STACK: Delete existing stack snapshots before writing new ones
+     *
+     * This runs once per stack (tracked by static flag) to avoid
+     * multiple cleanup attempts when binding multiple entities.
+     */
+    applySnapshotCachePolicy(params) {
+        // Get policy from CDK context (defaults to NONE)
+        const policyValue = this.node.tryGetContext(snapshot_cache_policy_1.SNAPSHOT_CACHE_POLICY_CONTEXT_KEY);
+        const policy = this.parseSnapshotCachePolicy(policyValue);
+        if (policy === snapshot_cache_policy_1.SnapshotCachePolicy.NONE) {
+            return; // No cleanup
+        }
+        // Check if we've already cleaned this stack in this synth
+        const stack = cdk.Stack.of(this);
+        const cleanupKey = `__chaim_snapshot_cleanup_${params.stackName}`;
+        if (stack.node[cleanupKey]) {
+            return; // Already cleaned in this synth
+        }
+        // Mark as cleaned to avoid duplicate cleanup
+        stack.node[cleanupKey] = true;
+        if (policy === snapshot_cache_policy_1.SnapshotCachePolicy.PRUNE_STACK) {
+            const result = (0, snapshot_cleanup_1.pruneStackSnapshots)({
+                accountId: params.accountId,
+                region: params.region,
+                stackName: params.stackName,
+                verbose: false, // Don't spam console during synth
+            });
+            // Only log if verbose mode or errors
+            if (result.deletedCount > 0 || result.errors.length > 0) {
+                console.log(`[Chaim] Pruned ${result.deletedCount} snapshot(s) for stack: ${params.stackName}`);
+                if (result.errors.length > 0) {
+                    console.warn(`[Chaim] Cleanup warnings:`, result.errors);
+                }
+            }
+        }
+    }
+    /**
+     * Parse snapshot cache policy from context value.
+     */
+    parseSnapshotCachePolicy(value) {
+        if (typeof value !== 'string') {
+            return snapshot_cache_policy_1.DEFAULT_SNAPSHOT_CACHE_POLICY;
+        }
+        const upperValue = value.toUpperCase();
+        if (upperValue === 'NONE' || upperValue === 'DISABLED') {
+            return snapshot_cache_policy_1.SnapshotCachePolicy.NONE;
+        }
+        if (upperValue === 'PRUNE_STACK' || upperValue === 'PRUNE') {
+            return snapshot_cache_policy_1.SnapshotCachePolicy.PRUNE_STACK;
+        }
+        console.warn(`[Chaim] Unknown chaimSnapshotCachePolicy: "${value}". ` +
+            `Valid values: NONE, PRUNE_STACK. Defaulting to NONE.`);
+        return snapshot_cache_policy_1.DEFAULT_SNAPSHOT_CACHE_POLICY;
+    }
+    /**
+     * Extract stack name from stableResourceKey.
+     * Format: dynamodb:path:StackName/ResourceName
+     */
+    extractStackNameFromResourceKey(stableResourceKey) {
+        const match = stableResourceKey.match(/path:([^/]+)/);
+        return match ? match[1] : 'unknown';
+    }
+    /**
+     * Write LOCAL snapshot to OS cache for chaim-cli consumption.
+     * Uses hierarchical path: aws/{accountId}/{region}/{stackName}/{datastoreType}/{resourceId}.json
+     *
+     * @param snapshot - The snapshot payload to write
+     * @returns The path where snapshot was written
+     */
+    writeLocalSnapshotToDisk(snapshot) {
+        const stackName = this.extractStackNameFromResourceKey(snapshot.identity.stableResourceKey);
+        const dir = (0, os_cache_paths_1.getSnapshotDir)({
+            accountId: snapshot.providerIdentity.accountId,
+            region: snapshot.providerIdentity.region,
+            stackName,
+            datastoreType: snapshot.resource.type,
+        });
+        (0, os_cache_paths_1.ensureDirExists)(dir);
+        const filePath = (0, os_cache_paths_1.getLocalSnapshotPath)({
+            accountId: snapshot.providerIdentity.accountId,
+            region: snapshot.providerIdentity.region,
+            stackName,
+            datastoreType: snapshot.resource.type,
+            resourceId: snapshot.identity.resourceId,
+        });
+        fs.writeFileSync(filePath, JSON.stringify(snapshot, null, 2), 'utf-8');
+        return filePath;
+    }
+    /**
+     * Find the CDK project root by walking up from current module.
+     */
+    findCdkProjectRoot() {
+        let currentDir = __dirname;
+        for (let i = 0; i < 10; i++) {
+            const cdkJsonPath = path.join(currentDir, 'cdk.json');
+            if (fs.existsSync(cdkJsonPath)) {
+                return currentDir;
+            }
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                break;
+            }
+            currentDir = parentDir;
+        }
+        // Fallback to cwd
+        return process.cwd();
+    }
+    /**
+     * Write snapshot and Lambda handler to isolated CDK asset directory for Lambda bundling.
+     *
+     * Asset directory is per {stackName}/{resourceId} and MUST NOT be shared.
+     * The Lambda reads ./snapshot.json from its bundle, NOT from env vars or OS cache.
+     *
+     * The handler is copied from the canonical handler file (src/lambda-handler/handler.js)
+     * rather than being generated inline - this ensures a single source of truth.
+     *
+     * @returns The asset directory path
+     */
+    writeSnapshotAsset(snapshot, stackName) {
+        const cdkRoot = this.findCdkProjectRoot();
+        const assetDir = path.join(cdkRoot, 'cdk.out', 'chaim', 'assets', stackName, this.resourceId);
+        (0, os_cache_paths_1.ensureDirExists)(assetDir);
+        // Write snapshot.json (OVERWRITE each synth)
+        const snapshotPath = path.join(assetDir, 'snapshot.json');
+        fs.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2), 'utf-8');
+        // Copy canonical Lambda handler (OVERWRITE each synth)
+        const handlerDestPath = path.join(assetDir, 'index.js');
+        fs.copyFileSync(LAMBDA_HANDLER_PATH, handlerDestPath);
+        return assetDir;
+    }
+    /**
+     * Deploy Lambda function and custom resource for ingestion.
+     */
+    deployIngestionResources(assetDir) {
+        const handler = this.createIngestionLambda(assetDir);
+        this.createCustomResource(handler);
+    }
+    /**
+     * Create Lambda function for ingestion workflow.
+     * Lambda reads snapshot from its bundled asset directory.
+     */
+    createIngestionLambda(assetDir) {
+        const handler = new lambda.Function(this, 'IngestionHandler', {
+            runtime: lambda.Runtime.NODEJS_20_X,
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(assetDir),
+            timeout: cdk.Duration.minutes(5),
+            environment: this.buildLambdaEnvironment(),
+        });
+        // Grant CloudWatch Logs permissions
+        handler.addToRolePolicy(new iam.PolicyStatement({
+            effect: iam.Effect.ALLOW,
+            actions: ['logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:PutLogEvents'],
+            resources: ['*'],
+        }));
+        // Grant Secrets Manager permissions if using secrets
+        const { credentials } = this.config;
+        if (credentials.credentialType === 'secretsManager' && credentials.secretName) {
+            handler.addToRolePolicy(new iam.PolicyStatement({
+                effect: iam.Effect.ALLOW,
+                actions: ['secretsmanager:GetSecretValue'],
+                resources: [`arn:aws:secretsmanager:*:*:secret:${credentials.secretName}*`],
+            }));
+        }
+        return handler;
+    }
+    /**
+     * Build Lambda environment variables.
+     * Note: Snapshot is NOT passed via env - Lambda reads from bundled asset.
+     */
+    buildLambdaEnvironment() {
+        // Allow maintainer override via CDK context, otherwise use default
+        const apiBaseUrl = this.node.tryGetContext('chaimApiBaseUrl') ?? chaim_endpoints_1.DEFAULT_CHAIM_API_BASE_URL;
+        const { credentials, failureMode } = this.config;
+        const env = {
+            APP_ID: this.config.appId,
+            FAILURE_MODE: failureMode,
+            CHAIM_API_BASE_URL: apiBaseUrl,
+            CHAIM_MAX_SNAPSHOT_BYTES: String(chaim_endpoints_1.DEFAULT_MAX_SNAPSHOT_BYTES),
+        };
+        if (credentials.credentialType === 'secretsManager') {
+            env.SECRET_NAME = credentials.secretName;
+        }
+        else {
+            env.API_KEY = credentials.apiKey;
+            env.API_SECRET = credentials.apiSecret;
+        }
+        return env;
+    }
+    /**
+     * Create CloudFormation custom resource.
+     */
+    createCustomResource(handler) {
+        const provider = new cr.Provider(this, 'IngestionProvider', {
+            onEventHandler: handler,
+        });
+        // Use resource ID for physical resource ID (stable across deploys)
+        new cdk.CustomResource(this, 'IngestionResource', {
+            serviceToken: provider.serviceToken,
+            properties: {
+                ResourceId: this.resourceId,
+                // ContentHash is computed at Lambda runtime
+            },
+        });
+    }
+}
+exports.BaseChaimBinder = BaseChaimBinder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-chaim-binder.js","sourceRoot":"","sources":["../../src/binders/base-chaim-binder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport * as cr from 'aws-cdk-lib/custom-resources';\nimport * as dynamodb from 'aws-cdk-lib/aws-dynamodb';\nimport { Construct } from 'constructs';\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as crypto from 'crypto';\n\nimport { SchemaData } from '@chaim-tools/chaim-bprint-spec';\nimport { BaseBinderProps, validateBinderProps } from '../types/base-binder-props';\nimport { DataStoreMetadata } from '../types/data-store-metadata';\nimport { LocalSnapshotPayload } from '../types/snapshot-payload';\nimport { SchemaService } from '../services/schema-service';\nimport { FailureMode } from '../types/failure-mode';\nimport { TableBindingConfig } from '../types/table-binding-config';\nimport {\n  SnapshotCachePolicy,\n  DEFAULT_SNAPSHOT_CACHE_POLICY,\n  SNAPSHOT_CACHE_POLICY_CONTEXT_KEY,\n} from '../types/snapshot-cache-policy';\nimport {\n  DEFAULT_CHAIM_API_BASE_URL,\n  DEFAULT_MAX_SNAPSHOT_BYTES,\n  SNAPSHOT_SCHEMA_VERSION,\n} from '../config/chaim-endpoints';\nimport {\n  normalizeAccountId,\n  normalizeRegion,\n  normalizeResourceName,\n  getSnapshotDir,\n  getLocalSnapshotPath,\n  ensureDirExists,\n} from '../services/os-cache-paths';\nimport { pruneStackSnapshots } from '../services/snapshot-cleanup';\n\n/**\n * Path to the canonical Lambda handler file.\n * This handler implements the presigned upload flow for Chaim ingestion.\n */\nconst LAMBDA_HANDLER_PATH = path.join(__dirname, '..', 'lambda-handler', 'handler.js');\n\n/**\n * Abstract base class for all Chaim data store binders.\n *\n * Provides shared infrastructure:\n * - Schema loading and validation\n * - Snapshot payload construction\n * - LOCAL snapshot writing during CDK synth (to OS cache)\n * - Lambda-backed custom resource for S3 presigned upload + snapshot-ref\n *\n * Subclasses implement `extractMetadata()` for store-specific metadata extraction\n * and optionally override `getTable()` for DynamoDB-like resources.\n */\nexport abstract class BaseChaimBinder extends Construct {\n  /** Validated schema data */\n  public readonly schemaData: SchemaData;\n\n  /** Extracted data store metadata */\n  public readonly dataStoreMetadata: DataStoreMetadata;\n\n  /** Generated resource ID ({resourceName}__{entityName}[__N]) */\n  public readonly resourceId: string;\n\n  /** Binding configuration */\n  public readonly config: TableBindingConfig;\n\n  /** Base props (for internal use) */\n  protected readonly baseProps: BaseBinderProps;\n\n  constructor(scope: Construct, id: string, props: BaseBinderProps) {\n    super(scope, id);\n\n    this.baseProps = props;\n    this.config = props.config;\n\n    // Validate props\n    validateBinderProps(props);\n\n    // Validate consistency with other bindings to same table\n    this.validateTableConsistency();\n\n    // Load and validate schema\n    this.schemaData = SchemaService.readSchema(props.schemaPath);\n\n    // Extract data store metadata (implemented by subclass)\n    this.dataStoreMetadata = this.extractMetadata();\n\n    // Build stack context\n    const stack = cdk.Stack.of(this);\n    const stackName = stack.stackName;\n    const datastoreType = this.dataStoreMetadata.type;\n\n    // Get resource and entity names\n    const resourceName = this.getResourceName();\n    const entityName = this.getEntityName();\n\n    // Generate resource ID\n    this.resourceId = `${resourceName}__${entityName}`;\n\n    // Normalize values for paths (handle CDK tokens)\n    const normalizedAccountId = normalizeAccountId(stack.account);\n    const normalizedRegion = normalizeRegion(stack.region);\n    const normalizedResourceName = normalizeResourceName(resourceName);\n\n    // Update resource ID with normalized name to avoid special characters\n    const normalizedResourceId = `${normalizedResourceName}__${entityName}`;\n\n    // Build LOCAL snapshot payload\n    const localSnapshot = this.buildLocalSnapshot({\n      accountId: normalizedAccountId,\n      region: normalizedRegion,\n      stackName,\n      datastoreType,\n      resourceName: normalizedResourceName,\n      resourceId: normalizedResourceId,\n    });\n\n    // Apply snapshot cache policy (cleanup if requested)\n    this.applySnapshotCachePolicy({\n      accountId: normalizedAccountId,\n      region: normalizedRegion,\n      stackName,\n    });\n\n    // Write LOCAL snapshot to OS cache for chaim-cli consumption\n    this.writeLocalSnapshotToDisk(localSnapshot);\n\n    // Get or create asset directory\n    const assetDir = this.writeSnapshotAsset(localSnapshot, stackName);\n\n    // Deploy Lambda-backed custom resource for ingestion\n    this.deployIngestionResources(assetDir);\n  }\n\n  /**\n   * Validate that all bindings to the same table use the same config.\n   * \n   * This is a safety check - sharing the same TableBindingConfig object\n   * already ensures consistency, but this catches cases where users\n   * create separate configs with identical values.\n   */\n  private validateTableConsistency(): void {\n    // Only for DynamoDB binders (has table property)\n    const table = (this.baseProps as any).table;\n    if (!table) {\n      return;\n    }\n\n    // Find other binders for the same table\n    const stack = cdk.Stack.of(this);\n    const otherBinders = stack.node.findAll()\n      .filter(node => node instanceof BaseChaimBinder)\n      .filter(binder => binder !== this)\n      .filter(binder => {\n        const otherTable = ((binder as BaseChaimBinder).baseProps as any).table;\n        return otherTable === table;\n      })\n      .map(binder => binder as BaseChaimBinder);\n\n    if (otherBinders.length === 0) {\n      return; // First binding for this table\n    }\n\n    const firstBinder = otherBinders[0];\n\n    // Check if they're using the exact same config object (recommended)\n    if (this.config === firstBinder.config) {\n      return; // Perfect - same config object\n    }\n\n    // Different config objects - validate they have same values\n    if (this.config.appId !== firstBinder.config.appId) {\n      throw new Error(\n        `Configuration conflict for table \"${table.tableName}\".\\n\\n` +\n        `Binder \"${firstBinder.node.id}\" uses appId: \"${firstBinder.config.appId}\"\\n` +\n        `Binder \"${this.node.id}\" uses appId: \"${this.config.appId}\"\\n\\n` +\n        `All bindings to the same table MUST use the same appId.\\n\\n` +\n        `RECOMMENDED: Share the same TableBindingConfig object:\\n` +\n        `  const config = new TableBindingConfig('${firstBinder.config.appId}', credentials);\\n` +\n        `  new ChaimDynamoDBBinder(this, '${firstBinder.node.id}', { ..., config });\\n` +\n        `  new ChaimDynamoDBBinder(this, '${this.node.id}', { ..., config });`\n      );\n    }\n\n    // Validate credentials match\n    const firstCreds = JSON.stringify(firstBinder.config.credentials);\n    const thisCreds = JSON.stringify(this.config.credentials);\n    \n    if (firstCreds !== thisCreds) {\n      throw new Error(\n        `Configuration conflict for table \"${table.tableName}\".\\n\\n` +\n        `Binder \"${firstBinder.node.id}\" uses different credentials than \"${this.node.id}\".\\n\\n` +\n        `All bindings to the same table MUST use the same credentials.\\n\\n` +\n        `RECOMMENDED: Share the same TableBindingConfig object to avoid this error.`\n      );\n    }\n\n    // Warn about different failureMode (not an error)\n    if (this.config.failureMode !== firstBinder.config.failureMode) {\n      console.warn(\n        `Warning: Different failureMode for table \"${table.tableName}\".\\n` +\n        `  \"${firstBinder.node.id}\": ${firstBinder.config.failureMode}\\n` +\n        `  \"${this.node.id}\": ${this.config.failureMode}\\n` +\n        `Consider sharing the same TableBindingConfig object.`\n      );\n    }\n  }\n\n  /**\n   * Abstract method - subclasses implement store-specific metadata extraction.\n   */\n  protected abstract extractMetadata(): DataStoreMetadata;\n\n  /**\n   * Override in subclasses to provide the table construct for stable identity.\n   * Default returns undefined (will fall back to construct path).\n   */\n  protected getTable(): dynamodb.ITable | undefined {\n    return undefined;\n  }\n\n  /**\n   * Get the resource name for display and filenames.\n   * For DynamoDB, this is the user label (not necessarily the physical table name).\n   * \n   * Subclasses can override this to provide a more meaningful name\n   * (e.g., construct node ID instead of physical resource name which may contain tokens).\n   */\n  protected getResourceName(): string {\n    const metadata = this.dataStoreMetadata as any;\n    return metadata.tableName || metadata.name || 'resource';\n  }\n\n  /**\n   * Get the entity name from schema.\n   */\n  private getEntityName(): string {\n    return this.schemaData.entityName;\n  }\n\n  /**\n   * Read package version from package.json.\n   * Used to populate producer metadata in snapshots.\n   */\n  private getPackageVersion(): string {\n    try {\n      const packagePath = path.join(__dirname, '..', '..', 'package.json');\n      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));\n      return packageJson.version || '0.0.0';\n    } catch (error) {\n      console.warn('Failed to read package version:', error);\n      return '0.0.0';\n    }\n  }\n\n\n\n  /**\n   * Build a LOCAL snapshot payload for CLI consumption.\n   * Does not include eventId or contentHash - those are generated at deploy-time.\n   */\n  private buildLocalSnapshot(params: {\n    accountId: string;\n    region: string;\n    stackName: string;\n    datastoreType: string;\n    resourceName: string;\n    resourceId: string;\n  }): LocalSnapshotPayload {\n    const capturedAt = new Date().toISOString();\n    const stack = cdk.Stack.of(this);\n\n    // Build provider identity\n    const providerIdentity = {\n      cloud: 'aws' as const,\n      accountId: params.accountId,\n      region: params.region,\n      deploymentSystem: 'cloudformation' as const,\n      deploymentId: stack.stackId,\n    };\n\n    // Build binding identity\n    const stableResourceKey = `${params.datastoreType}:path:${params.stackName}/${params.resourceName}`;\n    const entityId = `${this.config.appId}:${this.schemaData.entityName}`;\n    const bindingId = `${this.config.appId}:${stableResourceKey}:${this.schemaData.entityName}`;\n\n    const identity = {\n      appId: this.config.appId,\n      entityName: this.schemaData.entityName,\n      stableResourceKeyStrategy: 'cdk-construct-path' as const,\n      stableResourceKey,\n      resourceId: params.resourceId,\n      entityId,\n      bindingId,\n    };\n\n    // Build operation metadata\n    const operation = {\n      eventId: this.generateUuid(),\n      requestType: 'Create' as const,\n      failureMode: this.config.failureMode,\n    };\n\n    // Build resolution metadata\n    const hasTokens = this.detectUnresolvedTokens(this.dataStoreMetadata);\n    const resolution = {\n      mode: 'LOCAL' as const,\n      hasTokens,\n    };\n\n    // Build hashes\n    const schemaBytes = JSON.stringify(this.schemaData);\n    const schemaHash = 'sha256:' + crypto.createHash('sha256').update(schemaBytes).digest('hex');\n    const hashes = {\n      schemaHash,\n      contentHash: '',\n    };\n\n    // Build resource metadata\n    const resource = this.buildResourceMetadata(params);\n\n    // Build producer metadata\n    const producer = {\n      component: 'chaim-cdk' as const,\n      version: this.getPackageVersion(),\n      runtime: process.version,\n    };\n\n    return {\n      snapshotVersion: SNAPSHOT_SCHEMA_VERSION,\n      action: 'UPSERT',\n      capturedAt,\n      providerIdentity,\n      identity,\n      operation,\n      resolution,\n      hashes,\n      schema: this.schemaData,\n      resource,\n      producer,\n    };\n  }\n\n  /**\n   * Build resource metadata from dataStore metadata.\n   */\n  private buildResourceMetadata(params: any): any {\n    const dynamoMetadata = this.dataStoreMetadata as any;\n    \n    return {\n      type: 'dynamodb',\n      kind: 'table',\n      id: dynamoMetadata.tableArn,\n      name: dynamoMetadata.tableName,\n      region: params.region,\n      partitionKey: dynamoMetadata.partitionKey,\n      sortKey: dynamoMetadata.sortKey,\n      globalSecondaryIndexes: dynamoMetadata.globalSecondaryIndexes,\n      localSecondaryIndexes: dynamoMetadata.localSecondaryIndexes,\n      ttlAttribute: dynamoMetadata.ttlAttribute,\n      streamEnabled: dynamoMetadata.streamEnabled,\n      streamViewType: dynamoMetadata.streamViewType,\n      billingMode: dynamoMetadata.billingMode,\n      encryptionKeyArn: dynamoMetadata.encryptionKeyArn,\n    };\n  }\n\n  /**\n   * Detect if metadata contains unresolved CDK tokens.\n   */\n  private detectUnresolvedTokens(metadata: any): boolean {\n    const str = JSON.stringify(metadata);\n    return str.includes('${Token[');\n  }\n\n  /**\n   * Generate a UUID v4 for operation tracking.\n   */\n  private generateUuid(): string {\n    return crypto.randomUUID();\n  }\n\n  /**\n   * Apply snapshot cache policy based on CDK context.\n   * \n   * Checks the `chaimSnapshotCachePolicy` context value:\n   * - NONE (default): No cleanup\n   * - PRUNE_STACK: Delete existing stack snapshots before writing new ones\n   * \n   * This runs once per stack (tracked by static flag) to avoid\n   * multiple cleanup attempts when binding multiple entities.\n   */\n  private applySnapshotCachePolicy(params: {\n    accountId: string;\n    region: string;\n    stackName: string;\n  }): void {\n    // Get policy from CDK context (defaults to NONE)\n    const policyValue = this.node.tryGetContext(SNAPSHOT_CACHE_POLICY_CONTEXT_KEY);\n    const policy = this.parseSnapshotCachePolicy(policyValue);\n\n    if (policy === SnapshotCachePolicy.NONE) {\n      return; // No cleanup\n    }\n\n    // Check if we've already cleaned this stack in this synth\n    const stack = cdk.Stack.of(this);\n    const cleanupKey = `__chaim_snapshot_cleanup_${params.stackName}`;\n    \n    if ((stack.node as any)[cleanupKey]) {\n      return; // Already cleaned in this synth\n    }\n\n    // Mark as cleaned to avoid duplicate cleanup\n    (stack.node as any)[cleanupKey] = true;\n\n    if (policy === SnapshotCachePolicy.PRUNE_STACK) {\n      const result = pruneStackSnapshots({\n        accountId: params.accountId,\n        region: params.region,\n        stackName: params.stackName,\n        verbose: false, // Don't spam console during synth\n      });\n\n      // Only log if verbose mode or errors\n      if (result.deletedCount > 0 || result.errors.length > 0) {\n        console.log(`[Chaim] Pruned ${result.deletedCount} snapshot(s) for stack: ${params.stackName}`);\n        \n        if (result.errors.length > 0) {\n          console.warn(`[Chaim] Cleanup warnings:`, result.errors);\n        }\n      }\n    }\n  }\n\n  /**\n   * Parse snapshot cache policy from context value.\n   */\n  private parseSnapshotCachePolicy(value: unknown): SnapshotCachePolicy {\n    if (typeof value !== 'string') {\n      return DEFAULT_SNAPSHOT_CACHE_POLICY;\n    }\n\n    const upperValue = value.toUpperCase();\n    \n    if (upperValue === 'NONE' || upperValue === 'DISABLED') {\n      return SnapshotCachePolicy.NONE;\n    }\n    \n    if (upperValue === 'PRUNE_STACK' || upperValue === 'PRUNE') {\n      return SnapshotCachePolicy.PRUNE_STACK;\n    }\n\n    console.warn(\n      `[Chaim] Unknown chaimSnapshotCachePolicy: \"${value}\". ` +\n      `Valid values: NONE, PRUNE_STACK. Defaulting to NONE.`\n    );\n    \n    return DEFAULT_SNAPSHOT_CACHE_POLICY;\n  }\n\n  /**\n   * Extract stack name from stableResourceKey.\n   * Format: dynamodb:path:StackName/ResourceName\n   */\n  private extractStackNameFromResourceKey(stableResourceKey: string): string {\n    const match = stableResourceKey.match(/path:([^/]+)/);\n    return match ? match[1] : 'unknown';\n  }\n\n  /**\n   * Write LOCAL snapshot to OS cache for chaim-cli consumption.\n   * Uses hierarchical path: aws/{accountId}/{region}/{stackName}/{datastoreType}/{resourceId}.json\n   * \n   * @param snapshot - The snapshot payload to write\n   * @returns The path where snapshot was written\n   */\n  private writeLocalSnapshotToDisk(snapshot: LocalSnapshotPayload): string {\n    const stackName = this.extractStackNameFromResourceKey(snapshot.identity.stableResourceKey);\n    \n    const dir = getSnapshotDir({\n      accountId: snapshot.providerIdentity.accountId,\n      region: snapshot.providerIdentity.region,\n      stackName,\n      datastoreType: snapshot.resource.type,\n    });\n    \n    ensureDirExists(dir);\n    \n    const filePath = getLocalSnapshotPath({\n      accountId: snapshot.providerIdentity.accountId,\n      region: snapshot.providerIdentity.region,\n      stackName,\n      datastoreType: snapshot.resource.type,\n      resourceId: snapshot.identity.resourceId,\n    });\n    \n    fs.writeFileSync(filePath, JSON.stringify(snapshot, null, 2), 'utf-8');\n    \n    return filePath;\n  }\n\n\n  /**\n   * Find the CDK project root by walking up from current module.\n   */\n  private findCdkProjectRoot(): string {\n    let currentDir = __dirname;\n    for (let i = 0; i < 10; i++) {\n      const cdkJsonPath = path.join(currentDir, 'cdk.json');\n      if (fs.existsSync(cdkJsonPath)) {\n        return currentDir;\n      }\n      const parentDir = path.dirname(currentDir);\n      if (parentDir === currentDir) {\n        break;\n      }\n      currentDir = parentDir;\n    }\n    // Fallback to cwd\n    return process.cwd();\n  }\n\n  /**\n   * Write snapshot and Lambda handler to isolated CDK asset directory for Lambda bundling.\n   * \n   * Asset directory is per {stackName}/{resourceId} and MUST NOT be shared.\n   * The Lambda reads ./snapshot.json from its bundle, NOT from env vars or OS cache.\n   * \n   * The handler is copied from the canonical handler file (src/lambda-handler/handler.js)\n   * rather than being generated inline - this ensures a single source of truth.\n   *\n   * @returns The asset directory path\n   */\n  private writeSnapshotAsset(snapshot: LocalSnapshotPayload, stackName: string): string {\n    const cdkRoot = this.findCdkProjectRoot();\n    const assetDir = path.join(cdkRoot, 'cdk.out', 'chaim', 'assets', stackName, this.resourceId);\n    ensureDirExists(assetDir);\n\n    // Write snapshot.json (OVERWRITE each synth)\n    const snapshotPath = path.join(assetDir, 'snapshot.json');\n    fs.writeFileSync(snapshotPath, JSON.stringify(snapshot, null, 2), 'utf-8');\n\n    // Copy canonical Lambda handler (OVERWRITE each synth)\n    const handlerDestPath = path.join(assetDir, 'index.js');\n    fs.copyFileSync(LAMBDA_HANDLER_PATH, handlerDestPath);\n\n    return assetDir;\n  }\n\n  /**\n   * Deploy Lambda function and custom resource for ingestion.\n   */\n  private deployIngestionResources(assetDir: string): void {\n    const handler = this.createIngestionLambda(assetDir);\n    this.createCustomResource(handler);\n  }\n\n  /**\n   * Create Lambda function for ingestion workflow.\n   * Lambda reads snapshot from its bundled asset directory.\n   */\n  private createIngestionLambda(assetDir: string): lambda.Function {\n    const handler = new lambda.Function(this, 'IngestionHandler', {\n      runtime: lambda.Runtime.NODEJS_20_X,\n      handler: 'index.handler',\n      code: lambda.Code.fromAsset(assetDir),\n      timeout: cdk.Duration.minutes(5),\n      environment: this.buildLambdaEnvironment(),\n    });\n\n    // Grant CloudWatch Logs permissions\n    handler.addToRolePolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: ['logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:PutLogEvents'],\n        resources: ['*'],\n      })\n    );\n\n    // Grant Secrets Manager permissions if using secrets\n    const { credentials } = this.config;\n    if (credentials.credentialType === 'secretsManager' && credentials.secretName) {\n      handler.addToRolePolicy(\n        new iam.PolicyStatement({\n          effect: iam.Effect.ALLOW,\n          actions: ['secretsmanager:GetSecretValue'],\n          resources: [`arn:aws:secretsmanager:*:*:secret:${credentials.secretName}*`],\n        })\n      );\n    }\n\n    return handler;\n  }\n\n  /**\n   * Build Lambda environment variables.\n   * Note: Snapshot is NOT passed via env - Lambda reads from bundled asset.\n   */\n  private buildLambdaEnvironment(): Record<string, string> {\n    // Allow maintainer override via CDK context, otherwise use default\n    const apiBaseUrl = this.node.tryGetContext('chaimApiBaseUrl') ?? DEFAULT_CHAIM_API_BASE_URL;\n    const { credentials, failureMode } = this.config;\n\n    const env: Record<string, string> = {\n      APP_ID: this.config.appId,\n      FAILURE_MODE: failureMode,\n      CHAIM_API_BASE_URL: apiBaseUrl,\n      CHAIM_MAX_SNAPSHOT_BYTES: String(DEFAULT_MAX_SNAPSHOT_BYTES),\n    };\n\n    if (credentials.credentialType === 'secretsManager') {\n      env.SECRET_NAME = credentials.secretName!;\n    } else {\n      env.API_KEY = credentials.apiKey!;\n      env.API_SECRET = credentials.apiSecret!;\n    }\n\n    return env;\n  }\n\n  /**\n   * Create CloudFormation custom resource.\n   */\n  private createCustomResource(handler: lambda.Function): void {\n    const provider = new cr.Provider(this, 'IngestionProvider', {\n      onEventHandler: handler,\n    });\n\n    // Use resource ID for physical resource ID (stable across deploys)\n    new cdk.CustomResource(this, 'IngestionResource', {\n      serviceToken: provider.serviceToken,\n      properties: {\n        ResourceId: this.resourceId,\n        // ContentHash is computed at Lambda runtime\n      },\n    });\n  }\n}\n"]}