dynamodb-reactive 0.1.22 → 0.2.1

package/dist/infra.cjs

@@ -0,0 +1,623 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var cdk2 = require('aws-cdk-lib');
+var apigatewayv2 = require('aws-cdk-lib/aws-apigatewayv2');
+var apigatewayv2Integrations = require('aws-cdk-lib/aws-apigatewayv2-integrations');
+var dynamodb = require('aws-cdk-lib/aws-dynamodb');
+var iam = require('aws-cdk-lib/aws-iam');
+var lambda = require('aws-cdk-lib/aws-lambda');
+var nodejs = require('aws-cdk-lib/aws-lambda-nodejs');
+var logs = require('aws-cdk-lib/aws-logs');
+var constructs = require('constructs');
+var zod = require('zod');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+var cdk2__namespace = /*#__PURE__*/_interopNamespace(cdk2);
+var apigatewayv2__namespace = /*#__PURE__*/_interopNamespace(apigatewayv2);
+var apigatewayv2Integrations__namespace = /*#__PURE__*/_interopNamespace(apigatewayv2Integrations);
+var dynamodb__namespace = /*#__PURE__*/_interopNamespace(dynamodb);
+var iam__namespace = /*#__PURE__*/_interopNamespace(iam);
+var lambda__namespace = /*#__PURE__*/_interopNamespace(lambda);
+var nodejs__namespace = /*#__PURE__*/_interopNamespace(nodejs);
+var logs__namespace = /*#__PURE__*/_interopNamespace(logs);
+
+// ../infra/src/engine.ts
+
+// ../infra/src/handlers/lambda-handlers.ts
+function generateEntryPointCode() {
+  return `// Auto-generated entry point for reactive Lambda handlers
+// No user code required - all configuration comes from environment variables
+import { createLambdaHandlers } from 'dynamodb-reactive/server';
+
+const handlers = createLambdaHandlers();
+
+export const connectHandler = handlers.connectHandler;
+export const disconnectHandler = handlers.disconnectHandler;
+export const messageHandler = handlers.messageHandler;
+export const streamHandler = handlers.streamHandler;
+`;
+}
+var FilterConditionSchema = zod.z.lazy(() => {
+  const comparison = zod.z.object({
+    type: zod.z.literal("comparison"),
+    operator: zod.z.enum(["eq", "ne", "gt", "gte", "lt", "lte"]),
+    field: zod.z.string().min(1),
+    value: zod.z.unknown()
+  }).strict();
+  const queryFunction = zod.z.union([
+    zod.z.object({
+      type: zod.z.literal("function"),
+      operator: zod.z.literal("between"),
+      field: zod.z.string().min(1),
+      value: zod.z.unknown(),
+      value2: zod.z.unknown()
+    }).strict(),
+    zod.z.object({
+      type: zod.z.literal("function"),
+      operator: zod.z.enum(["beginsWith", "contains"]),
+      field: zod.z.string().min(1),
+      value: zod.z.unknown()
+    }).strict()
+  ]);
+  const logical = zod.z.object({
+    type: zod.z.literal("logical"),
+    operator: zod.z.enum(["and", "or", "not"]),
+    conditions: zod.z.array(FilterConditionSchema).min(1)
+  }).strict().superRefine((condition, context) => {
+    if (condition.operator === "not" && condition.conditions.length !== 1) {
+      context.addIssue({
+        code: "custom",
+        path: ["conditions"],
+        message: "not requires exactly one condition"
+      });
+    }
+  });
+  return zod.z.union([comparison, queryFunction, logical]);
+});
+var QueryMetadataSchema = zod.z.object({
+  planVersion: zod.z.literal(1),
+  tableName: zod.z.string().min(1),
+  indexName: zod.z.string().min(1).optional(),
+  indexPkField: zod.z.string().min(1).optional(),
+  indexSkField: zod.z.string().min(1).optional(),
+  filterConditions: zod.z.array(FilterConditionSchema),
+  sortField: zod.z.string().min(1).optional(),
+  sortOrder: zod.z.enum(["asc", "desc"]).optional(),
+  limit: zod.z.number().int().positive().optional()
+}).strict().superRefine((metadata, context) => {
+  if (metadata.indexName && !metadata.indexPkField) {
+    context.addIssue({
+      code: "custom",
+      path: ["indexPkField"],
+      message: "Index metadata requires its partition key field"
+    });
+  }
+  if (!metadata.indexName && (metadata.indexPkField || metadata.indexSkField)) {
+    context.addIssue({
+      code: "custom",
+      path: ["indexName"],
+      message: "Index key fields require an index name"
+    });
+  }
+  if (Boolean(metadata.sortField) !== Boolean(metadata.sortOrder)) {
+    context.addIssue({
+      code: "custom",
+      path: ["sortOrder"],
+      message: "Sort field and order must be specified together"
+    });
+  }
+});
+var DeliveryVersionSchema = zod.z.object({
+  generation: zod.z.number().int().nonnegative(),
+  fromVersion: zod.z.number().int().nonnegative(),
+  toVersion: zod.z.number().int().positive(),
+  messageId: zod.z.string().min(1)
+});
+var PendingDeliverySchema = zod.z.discriminatedUnion("type", [
+  DeliveryVersionSchema.extend({
+    type: zod.z.literal("patch"),
+    patches: zod.z.array(
+      zod.z.object({
+        op: zod.z.enum(["add", "remove", "replace", "move", "copy", "test"]),
+        path: zod.z.string(),
+        value: zod.z.unknown().optional(),
+        from: zod.z.string().optional()
+      })
+    )
+  }),
+  DeliveryVersionSchema.extend({
+    type: zod.z.literal("resync")
+  }).strict()
+]);
+({
+  /**
+   * ReactiveConnectionsV2 - Tracks active WebSocket connections
+   */
+  connections: zod.z.object({
+    connectionId: zod.z.string(),
+    status: zod.z.enum(["open", "closed"]),
+    context: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+    authorizerContext: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+    requestIdentity: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
+    connectedAt: zod.z.number(),
+    ttl: zod.z.number()
+  }),
+  /**
+   * ReactiveDependenciesV2 - The inverted index for O(1) lookups
+   */
+  dependencies: zod.z.object({
+    pk: zod.z.string(),
+    // Versioned encoded dependency key
+    sk: zod.z.string(),
+    // ConnectionID#SubscriptionID
+    connectionId: zod.z.string(),
+    subscriptionId: zod.z.string(),
+    tableName: zod.z.string(),
+    fieldName: zod.z.string(),
+    fieldValue: zod.z.string(),
+    generation: zod.z.number().int().nonnegative(),
+    registrationId: zod.z.string().min(1),
+    ttl: zod.z.number()
+  }),
+  /**
+   * ReactiveConnectionQueriesV2 - Stores subscription state for diffing
+   */
+  queries: zod.z.object({
+    pk: zod.z.string(),
+    // ConnectionID
+    sk: zod.z.string(),
+    // SubscriptionID
+    connectionId: zod.z.string(),
+    subscriptionId: zod.z.string(),
+    status: zod.z.enum(["registering", "active", "cancelled", "faulted"]),
+    generation: zod.z.number().int().nonnegative(),
+    registrationId: zod.z.string().min(1),
+    queryMetadata: QueryMetadataSchema,
+    lastResult: zod.z.array(zod.z.unknown()),
+    dependencies: zod.z.array(zod.z.string()),
+    version: zod.z.number().int().nonnegative(),
+    pendingDelivery: PendingDeliverySchema.optional(),
+    createdAt: zod.z.number(),
+    updatedAt: zod.z.number(),
+    ttl: zod.z.number()
+  })
+});
+var SystemTableNames = {
+  connections: "ReactiveConnectionsV2",
+  dependencies: "ReactiveDependenciesV2",
+  queries: "ReactiveConnectionQueriesV2"
+};
+var ReactiveSystemTables = class extends constructs.Construct {
+  /**
+   * ReactiveConnections table - tracks WebSocket connections
+   */
+  connectionsTable;
+  /**
+   * ReactiveDependencies table - the inverted index
+   */
+  dependenciesTable;
+  /**
+   * ReactiveConnectionQueries table - stores subscription state
+   */
+  queriesTable;
+  constructor(scope, id, props) {
+    super(scope, id);
+    if (cdk2__namespace.Token.isUnresolved(props.tablePrefix) || !/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(props.tablePrefix) || props.tablePrefix.length > 229) {
+      throw new Error(
+        "ReactiveSystemTables tablePrefix must be a nonempty concrete value of at most 229 letters, numbers, hyphens, or underscores, starting with a letter or number."
+      );
+    }
+    const tableName = (name) => `${props.tablePrefix}-${name}`;
+    const provisioningMode = props.provisioningMode ?? "ON_DEMAND";
+    const removalPolicy = props.removalPolicy ?? cdk2__namespace.RemovalPolicy.RETAIN;
+    const isOnDemand = provisioningMode === "ON_DEMAND";
+    const capacityProps = isOnDemand ? { billingMode: dynamodb__namespace.BillingMode.PAY_PER_REQUEST } : {
+      billingMode: dynamodb__namespace.BillingMode.PROVISIONED,
+      readCapacity: provisioningMode.readWrite,
+      writeCapacity: provisioningMode.readWrite
+    };
+    this.connectionsTable = new dynamodb__namespace.Table(this, "ConnectionsTable", {
+      tableName: tableName(SystemTableNames.connections),
+      partitionKey: {
+        name: "connectionId",
+        type: dynamodb__namespace.AttributeType.STRING
+      },
+      ...capacityProps,
+      removalPolicy,
+      timeToLiveAttribute: "ttl"
+    });
+    this.dependenciesTable = new dynamodb__namespace.Table(this, "DependenciesTable", {
+      tableName: tableName(SystemTableNames.dependencies),
+      partitionKey: {
+        name: "pk",
+        // Format: "TableName#FieldName#FieldValue"
+        type: dynamodb__namespace.AttributeType.STRING
+      },
+      sortKey: {
+        name: "sk",
+        // Format: "ConnectionID#SubscriptionID"
+        type: dynamodb__namespace.AttributeType.STRING
+      },
+      ...capacityProps,
+      removalPolicy,
+      timeToLiveAttribute: "ttl"
+    });
+    const gsiProps = isOnDemand ? {} : {
+      readCapacity: provisioningMode.readWrite,
+      writeCapacity: provisioningMode.readWrite
+    };
+    this.dependenciesTable.addGlobalSecondaryIndex({
+      indexName: "byConnectionId",
+      partitionKey: {
+        name: "connectionId",
+        type: dynamodb__namespace.AttributeType.STRING
+      },
+      projectionType: dynamodb__namespace.ProjectionType.KEYS_ONLY,
+      ...gsiProps
+    });
+    this.queriesTable = new dynamodb__namespace.Table(this, "QueriesTable", {
+      tableName: tableName(SystemTableNames.queries),
+      partitionKey: {
+        name: "pk",
+        // ConnectionID
+        type: dynamodb__namespace.AttributeType.STRING
+      },
+      sortKey: {
+        name: "sk",
+        // SubscriptionID
+        type: dynamodb__namespace.AttributeType.STRING
+      },
+      ...capacityProps,
+      removalPolicy,
+      timeToLiveAttribute: "ttl"
+    });
+  }
+};
+
+// ../infra/src/engine.ts
+var PARTIQL_ACTIONS = [
+  "dynamodb:PartiQLInsert",
+  "dynamodb:PartiQLUpdate",
+  "dynamodb:PartiQLDelete"
+];
+var ReactiveEngine = class extends constructs.Construct {
+  tables;
+  systemTables;
+  webSocketApi;
+  webSocketStage;
+  connectHandler;
+  disconnectHandler;
+  messageHandler;
+  streamHandler;
+  webSocketUrl;
+  callbackUrl;
+  constructor(scope, id, props) {
+    super(scope, id);
+    if (cdk2__namespace.Token.isUnresolved(props.resourcePrefix) || !/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(props.resourcePrefix) || props.resourcePrefix.length > 45) {
+      throw new Error(
+        "ReactiveEngine resourcePrefix must be a nonempty concrete value of at most 45 letters, numbers, hyphens, or underscores, starting with a letter or number."
+      );
+    }
+    if (props.connectAuthorizer && props.allowUnauthenticatedConnections) {
+      throw new Error(
+        "Specify either connectAuthorizer or allowUnauthenticatedConnections, not both."
+      );
+    }
+    if (props.connectAuthorizer instanceof apigatewayv2__namespace.WebSocketNoneAuthorizer) {
+      throw new Error(
+        "WebSocketNoneAuthorizer does not authenticate connections. Set allowUnauthenticatedConnections to true instead."
+      );
+    }
+    if (!props.connectAuthorizer && !props.allowUnauthenticatedConnections) {
+      throw new Error(
+        "WebSocket authentication is required. Provide connectAuthorizer or explicitly set allowUnauthenticatedConnections to true."
+      );
+    }
+    for (const binding of props.tables) {
+      this.validateTableName(binding);
+      this.validateStream(binding);
+    }
+    this.tables = [...props.tables];
+    const resourceName = (name) => `${props.resourcePrefix}-${name}`;
+    const memorySize = 128;
+    const timeout = cdk2__namespace.Duration.seconds(30);
+    this.systemTables = new ReactiveSystemTables(this, "SystemTables", {
+      ...props.systemTablesProps,
+      tablePrefix: props.resourcePrefix
+    });
+    this.webSocketApi = new apigatewayv2__namespace.WebSocketApi(this, "WebSocketApi", {
+      apiName: resourceName("ReactiveWebSocket")
+    });
+    this.webSocketStage = new apigatewayv2__namespace.WebSocketStage(
+      this,
+      "WebSocketStage",
+      {
+        webSocketApi: this.webSocketApi,
+        stageName: "prod",
+        autoDeploy: true
+      }
+    );
+    this.webSocketUrl = this.webSocketStage.url;
+    this.callbackUrl = this.webSocketStage.callbackUrl;
+    const cdkOutDir = path__namespace.join(process.cwd(), "cdk.out", ".generated");
+    fs__namespace.mkdirSync(cdkOutDir, { recursive: true });
+    const entryPointPath = path__namespace.join(cdkOutDir, "reactive-entry.ts");
+    fs__namespace.writeFileSync(entryPointPath, generateEntryPointCode());
+    const environment = {
+      ...props.environment,
+      CONNECTIONS_TABLE: this.systemTables.connectionsTable.tableName,
+      DEPENDENCIES_TABLE: this.systemTables.dependenciesTable.tableName,
+      QUERIES_TABLE: this.systemTables.queriesTable.tableName,
+      WEBSOCKET_ENDPOINT: this.callbackUrl,
+      LOG_LEVEL: props.environment?.LOG_LEVEL ?? "INFO"
+    };
+    const bundling = {
+      format: nodejs__namespace.OutputFormat.CJS,
+      minify: true,
+      sourceMap: false,
+      target: "node24"
+    };
+    this.connectHandler = new nodejs__namespace.NodejsFunction(this, "ConnectHandler", {
+      functionName: resourceName("ReactiveConnect"),
+      runtime: lambda__namespace.Runtime.NODEJS_24_X,
+      handler: "connectHandler",
+      entry: entryPointPath,
+      bundling,
+      environment,
+      memorySize,
+      timeout,
+      logGroup: this.createLogGroup("ConnectLogGroup")
+    });
+    this.disconnectHandler = new nodejs__namespace.NodejsFunction(
+      this,
+      "DisconnectHandler",
+      {
+        functionName: resourceName("ReactiveDisconnect"),
+        runtime: lambda__namespace.Runtime.NODEJS_24_X,
+        handler: "disconnectHandler",
+        entry: entryPointPath,
+        bundling,
+        environment,
+        memorySize,
+        timeout,
+        logGroup: this.createLogGroup("DisconnectLogGroup")
+      }
+    );
+    this.messageHandler = new nodejs__namespace.NodejsFunction(this, "MessageHandler", {
+      functionName: resourceName("ReactiveMessage"),
+      runtime: lambda__namespace.Runtime.NODEJS_24_X,
+      handler: "messageHandler",
+      entry: entryPointPath,
+      bundling,
+      environment,
+      memorySize,
+      timeout,
+      logGroup: this.createLogGroup("MessageLogGroup")
+    });
+    this.streamHandler = new nodejs__namespace.NodejsFunction(this, "StreamHandler", {
+      functionName: resourceName("ReactiveStream"),
+      runtime: lambda__namespace.Runtime.NODEJS_24_X,
+      handler: "streamHandler",
+      entry: entryPointPath,
+      bundling,
+      environment: {
+        ...environment,
+        USER_TABLES: props.tables.map(({ definition }) => definition.tableName).join(",")
+      },
+      memorySize,
+      timeout,
+      logGroup: this.createLogGroup("StreamLogGroup")
+    });
+    iam__namespace.Grant.addToPrincipal({
+      grantee: this.connectHandler,
+      actions: ["dynamodb:PutItem"],
+      resourceArns: [this.systemTables.connectionsTable.tableArn]
+    });
+    iam__namespace.Grant.addToPrincipal({
+      grantee: this.disconnectHandler,
+      actions: ["dynamodb:UpdateItem"],
+      resourceArns: [this.systemTables.connectionsTable.tableArn]
+    });
+    iam__namespace.Grant.addToPrincipal({
+      grantee: this.disconnectHandler,
+      actions: ["dynamodb:Query", "dynamodb:UpdateItem"],
+      resourceArns: [this.systemTables.queriesTable.tableArn]
+    });
+    iam__namespace.Grant.addToPrincipal({
+      grantee: this.disconnectHandler,
+      actions: ["dynamodb:DeleteItem"],
+      resourceArns: [this.systemTables.dependenciesTable.tableArn]
+    });
+    iam__namespace.Grant.addToPrincipal({
+      grantee: this.messageHandler,
+      actions: ["dynamodb:UpdateItem"],
+      resourceArns: [this.systemTables.connectionsTable.tableArn]
+    });
+    iam__namespace.Grant.addToPrincipal({
+      grantee: this.streamHandler,
+      actions: ["dynamodb:UpdateItem"],
+      resourceArns: [this.systemTables.connectionsTable.tableArn]
+    });
+    iam__namespace.Grant.addToPrincipal({
+      grantee: this.streamHandler,
+      actions: ["dynamodb:Query", "dynamodb:DeleteItem"],
+      resourceArns: [this.systemTables.dependenciesTable.tableArn]
+    });
+    iam__namespace.Grant.addToPrincipal({
+      grantee: this.streamHandler,
+      actions: [
+        "dynamodb:GetItem",
+        "dynamodb:Query",
+        "dynamodb:UpdateItem"
+      ],
+      resourceArns: [this.systemTables.queriesTable.tableArn]
+    });
+    const managementPolicy = new iam__namespace.PolicyStatement({
+      actions: ["execute-api:ManageConnections"],
+      resources: [
+        cdk2__namespace.Stack.of(this).formatArn({
+          service: "execute-api",
+          resource: this.webSocketApi.apiId,
+          resourceName: `${this.webSocketStage.stageName}/POST/@connections/*`,
+          arnFormat: cdk2__namespace.ArnFormat.SLASH_RESOURCE_NAME
+        })
+      ]
+    });
+    this.messageHandler.addToRolePolicy(managementPolicy);
+    this.streamHandler.addToRolePolicy(managementPolicy);
+    const connectAuthorizer = props.connectAuthorizer ? {
+      bind: (options) => {
+        const config = props.connectAuthorizer.bind(options);
+        if (config.authorizationType === "NONE") {
+          throw new Error(
+            "The connectAuthorizer bind result uses NONE authorization. Set allowUnauthenticatedConnections to true instead."
+          );
+        }
+        return config;
+      }
+    } : void 0;
+    this.webSocketApi.addRoute("$connect", {
+      authorizer: connectAuthorizer,
+      integration: new apigatewayv2Integrations__namespace.WebSocketLambdaIntegration(
+        "ConnectIntegration",
+        this.connectHandler
+      )
+    });
+    this.webSocketApi.addRoute("$disconnect", {
+      integration: new apigatewayv2Integrations__namespace.WebSocketLambdaIntegration(
+        "DisconnectIntegration",
+        this.disconnectHandler
+      )
+    });
+    this.webSocketApi.addRoute("$default", {
+      integration: new apigatewayv2Integrations__namespace.WebSocketLambdaIntegration(
+        "DefaultIntegration",
+        this.messageHandler
+      )
+    });
+    for (const [index, binding] of props.tables.entries()) {
+      this.setupStreamProcessing(binding, index);
+    }
+    new cdk2__namespace.CfnOutput(this, "WebSocketUrl", {
+      value: this.webSocketUrl,
+      description: "WebSocket URL for reactive connections"
+    });
+  }
+  /** Grant an external application handler access to reactive and user data. */
+  grantApplicationAccess(grantee) {
+    this.systemTables.connectionsTable.grantReadWriteData(grantee);
+    this.systemTables.dependenciesTable.grantReadWriteData(grantee);
+    this.systemTables.queriesTable.grantReadWriteData(grantee);
+    iam__namespace.Grant.addToPrincipal({
+      grantee,
+      actions: ["dynamodb:TransactWriteItems"],
+      resourceArns: [
+        this.systemTables.connectionsTable.tableArn,
+        this.systemTables.dependenciesTable.tableArn,
+        this.systemTables.queriesTable.tableArn
+      ]
+    });
+    for (const { table } of this.tables) {
+      table.grantReadWriteData(grantee);
+      iam__namespace.Grant.addToPrincipal({
+        grantee,
+        actions: ["dynamodb:PartiQLSelect"],
+        resourceArns: [table.tableArn, `${table.tableArn}/index/*`]
+      });
+      iam__namespace.Grant.addToPrincipal({
+        grantee,
+        actions: PARTIQL_ACTIONS,
+        resourceArns: [table.tableArn]
+      });
+    }
+  }
+  setupStreamProcessing(binding, index) {
+    const { table } = binding;
+    table.grantStreamRead(this.streamHandler);
+    iam__namespace.Grant.addToPrincipal({
+      grantee: this.streamHandler,
+      actions: ["dynamodb:PartiQLSelect"],
+      resourceArns: [table.tableArn, `${table.tableArn}/index/*`]
+    });
+    new lambda__namespace.EventSourceMapping(this, `UserTableStream${index}`, {
+      target: this.streamHandler,
+      eventSourceArn: table.tableStreamArn,
+      startingPosition: lambda__namespace.StartingPosition.TRIM_HORIZON,
+      batchSize: 100,
+      maxBatchingWindow: cdk2__namespace.Duration.seconds(5),
+      bisectBatchOnError: true,
+      reportBatchItemFailures: true
+    });
+  }
+  createLogGroup(id) {
+    return new logs__namespace.LogGroup(this, id, {
+      retention: logs__namespace.RetentionDays.ONE_DAY,
+      removalPolicy: cdk2__namespace.RemovalPolicy.DESTROY
+    });
+  }
+  validateStream(binding) {
+    const { definition, table } = binding;
+    if (!table.tableStreamArn) {
+      throw new Error(
+        `Table ${definition.tableName} does not have DynamoDB Streams enabled. NEW_AND_OLD_IMAGES is required.`
+      );
+    }
+    const child = table.node.defaultChild;
+    if (!(child instanceof dynamodb__namespace.CfnTable) && !(child instanceof dynamodb__namespace.CfnGlobalTable)) {
+      return;
+    }
+    const specification = cdk2__namespace.Stack.of(this).resolve(
+      child.streamSpecification
+    );
+    if (!specification || cdk2__namespace.Token.isUnresolved(specification) || typeof specification !== "object" || !("streamViewType" in specification)) {
+      return;
+    }
+    const streamViewType = specification.streamViewType;
+    if (!cdk2__namespace.Token.isUnresolved(streamViewType) && streamViewType !== dynamodb__namespace.StreamViewType.NEW_AND_OLD_IMAGES) {
+      throw new Error(
+        `Table ${definition.tableName} uses stream view ${streamViewType}; NEW_AND_OLD_IMAGES is required.`
+      );
+    }
+  }
+  validateTableName(binding) {
+    const { definition, table } = binding;
+    const child = table.node.defaultChild;
+    const childTableName = child && typeof child === "object" && "tableName" in child ? child.tableName : void 0;
+    const physicalTableName = !cdk2__namespace.Token.isUnresolved(table.tableName) ? table.tableName : childTableName && !cdk2__namespace.Token.isUnresolved(childTableName) ? childTableName : table.tableName;
+    if (!physicalTableName || cdk2__namespace.Token.isUnresolved(physicalTableName)) {
+      throw new Error(
+        `Table ${definition.tableName} has an unresolved physical table name. Set an explicit tableName equal to definition.tableName; separately bundled application code cannot coordinate CloudFormation-generated names.`
+      );
+    }
+    if (physicalTableName !== definition.tableName) {
+      throw new Error(
+        `Table binding name mismatch: definition.tableName is "${definition.tableName}" but the physical table name is "${physicalTableName}". Set an explicit matching tableName.`
+      );
+    }
+  }
+};
+
+exports.ReactiveEngine = ReactiveEngine;
+//# sourceMappingURL=infra.cjs.map
+//# sourceMappingURL=infra.cjs.map