@kensio/yulin 1.21.20 → 1.21.22

package/dist/service/athena/engine/sim-athena-engine-result.d.ts

@@ -1,6 +1,14 @@
 import type { DatabaseSync } from "node:sqlite";
 import { SimAthenaResolvedResult } from "../result/sim-athena-resolved-result.js";
 import type { SimAthenaLoadedTable } from "./sim-athena-table-rows.js";
+/** What one statement is run and read back with. */
+export interface SimAthenaEngineResultRun {
+    readonly database: DatabaseSync;
+    readonly sql: string;
+    readonly loaded: readonly SimAthenaLoadedTable[];
+    /** The decimal places each result column was rounded to, by position. */
+    readonly scales: ReadonlyMap<number, number>;
+}
 /**
  * Run one translated statement and read its answer back as a result set.
  *
@@ -8,4 +16,4 @@ import type { SimAthenaLoadedTable } from "./sim-athena-table-rows.js";
  * free to answer with two columns of one name and an object would keep one of
  * them.
  */
-export declare function simAthenaEngineResult(database: DatabaseSync, sql: string, loaded: readonly SimAthenaLoadedTable[]): SimAthenaResolvedResult;
+export declare function simAthenaEngineResult(run: SimAthenaEngineResultRun): SimAthenaResolvedResult;

package/dist/service/athena/engine/sim-athena-engine-result.js

@@ -1,5 +1,6 @@
 import { SimAthenaResolvedResult } from "../result/sim-athena-resolved-result.js";
 import { simAthenaResultColumns } from "./sim-athena-result-columns.js";
+import { simAthenaRoundedText } from "./sim-athena-round-scales.js";
 /**
  * Run one translated statement and read its answer back as a result set.
  *
@@ -7,8 +8,8 @@ import { simAthenaResultColumns } from "./sim-athena-result-columns.js";
  * free to answer with two columns of one name and an object would keep one of
  * them.
  */
-export function simAthenaEngineResult(database, sql, loaded) {
-    const statement = database.prepare(sql);
+export function simAthenaEngineResult(run) {
+    const statement = run.database.prepare(run.sql);
     statement.setReturnArrays(true);
     // A whole number comes back as a BigInt, because SQLite holds a 64 bit
     // integer and reading one past what a double represents exactly raises
@@ -16,12 +17,22 @@ export function simAthenaEngineResult(database, sql, loaded) {
     // Every one of them renders the same either way.
     statement.setReadBigInts(true);
     const rows = statement.all();
-    const columns = simAthenaResultColumns(statement.columns(), rows, loaded);
+    const columns = simAthenaResultColumns(statement.columns(), rows, run.loaded, run.scales);
     return new SimAthenaResolvedResult({
         columns,
-        rows: rows.map((row) => columns.map((column, index) => rendered(row[index], column))),
+        rows: rows.map((row) => columns.map((column, index) => renderedCell(row[index], column, run.scales.get(index)))),
     });
 }
+/**
+ * One value as `GetQueryResults` carries it, with the scale its column was
+ * rounded to where the statement asked for one.
+ */
+function renderedCell(value, column, scale) {
+    const text = rendered(value, column);
+    return scale === undefined || text === ""
+        ? text
+        : simAthenaRoundedText(value, scale);
+}
 /**
  * One value as `GetQueryResults` carries it.
  *

package/dist/service/athena/engine/sim-athena-engine-run.d.ts

@@ -14,6 +14,8 @@ export interface SimAthenaEngineRun {
     readonly caller: SimAwsCaller | undefined;
     readonly startedAt: Date;
     readonly sql: string;
+    /** The decimal places each result column was rounded to, by position. */
+    readonly scales: ReadonlyMap<number, number>;
 }
 /**
  * Load the tables, build the database and run the statement.

package/dist/service/athena/engine/sim-athena-engine-run.js

@@ -29,7 +29,12 @@ export async function simAthenaEngineRun(run) {
             startedAt: run.startedAt,
         });
         try {
-            return simAthenaEngineAnswered(simAthenaEngineResult(database, run.sql, loaded));
+            return simAthenaEngineAnswered(simAthenaEngineResult({
+                database,
+                sql: run.sql,
+                loaded,
+                scales: run.scales,
+            }));
         }
         finally {
             database.close();

package/dist/service/athena/engine/sim-athena-query-engine.js

@@ -85,6 +85,7 @@ export class SimAthenaQueryEngine {
                 sqlite,
                 objects,
                 sql: translated.sql,
+                scales: translated.scales,
             });
     }
 }

package/dist/service/athena/engine/sim-athena-result-columns.d.ts

@@ -15,4 +15,4 @@ import type { SimAthenaLoadedTable } from "./sim-athena-table-rows.js";
  * could not have been written as an identifier is how that is told apart from
  * an alias a statement chose.
  */
-export declare function simAthenaResultColumns(metadata: readonly StatementColumnMetadata[], rows: readonly (readonly SQLOutputValue[])[], loaded: readonly SimAthenaLoadedTable[]): readonly SimAthenaDeclaredColumn[];
+export declare function simAthenaResultColumns(metadata: readonly StatementColumnMetadata[], rows: readonly (readonly SQLOutputValue[])[], loaded: readonly SimAthenaLoadedTable[], scales?: ReadonlyMap<number, number>): readonly SimAthenaDeclaredColumn[];

package/dist/service/athena/engine/sim-athena-result-columns.js

@@ -15,15 +15,22 @@ const identifier = /^[A-Za-z_][\dA-Za-z_]*$/u;
  * could not have been written as an identifier is how that is told apart from
  * an alias a statement chose.
  */
-export function simAthenaResultColumns(metadata, rows, loaded) {
+export function simAthenaResultColumns(metadata, rows, loaded, scales = new Map()) {
     const types = glueColumnTypes(loaded);
     return metadata.map((column, index) => ({
         name: nameOf(column, index),
-        type: column.column === null
-            ? inferredType(rows, index)
-            : simAthenaResultType(types.get(originOf(column))),
+        // A column the statement rounded to a scale is a double whatever value it
+        // happens to hold, since a whole number rounded to one place is still one.
+        type: scales.has(index)
+            ? "double"
+            : columnType({ column, rows, index, types }),
     }));
 }
+function columnType(read) {
+    return read.column.column === null
+        ? inferredType(read.rows, read.index)
+        : simAthenaResultType(read.types.get(originOf(read.column)));
+}
 function nameOf(column, index) {
     const { name } = column;
     if (column.column !== null || identifier.test(name)) {

package/dist/service/athena/engine/sim-athena-round-scales.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The decimal places each result column was rounded to, by position.
+ *
+ * `round(x, 1)` answers `25.0` on Trino and `25` here, because SQLite hands
+ * back a double and nothing downstream knows how many places the statement
+ * asked to keep. The statement is the only thing that knows, so the scale is
+ * read off the syntax tree while it is still there and travels with the query.
+ *
+ * Only a literal scale is read. `round(x, n)` over a column is a scale that
+ * differs per row, and a result column has one rendering for every row in it.
+ */
+export declare function simAthenaRoundScales(ast: unknown): ReadonlyMap<number, number>;
+/**
+ * One rounded value as its column renders it.
+ *
+ * A whole number keeps the trailing zeros the scale asked for, which is the
+ * whole point of carrying the scale this far.
+ */
+export declare function simAthenaRoundedText(value: unknown, scale: number): string;

package/dist/service/athena/engine/sim-athena-round-scales.js

@@ -0,0 +1,80 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+/**
+ * The decimal places each result column was rounded to, by position.
+ *
+ * `round(x, 1)` answers `25.0` on Trino and `25` here, because SQLite hands
+ * back a double and nothing downstream knows how many places the statement
+ * asked to keep. The statement is the only thing that knows, so the scale is
+ * read off the syntax tree while it is still there and travels with the query.
+ *
+ * Only a literal scale is read. `round(x, n)` over a column is a scale that
+ * differs per row, and a result column has one rendering for every row in it.
+ */
+export function simAthenaRoundScales(ast) {
+    const scales = new Map();
+    for (const [index, item] of selectItems(ast).entries()) {
+        const scale = roundScaleOf(item);
+        if (scale !== undefined) {
+            scales.set(index, scale);
+        }
+    }
+    return scales;
+}
+/**
+ * One rounded value as its column renders it.
+ *
+ * A whole number keeps the trailing zeros the scale asked for, which is the
+ * whole point of carrying the scale this far.
+ */
+export function simAthenaRoundedText(value, scale) {
+    return typeof value === "number" ? value.toFixed(scale) : String(value);
+}
+/**
+ * The select list of the statement, which is the first one where a query
+ * carries several.
+ */
+function selectItems(ast) {
+    const statement = Array.isArray(ast) ? ast[0] : ast;
+    const columns = isRecord(statement) ? statement["columns"] : undefined;
+    return Array.isArray(columns) ? columns : [];
+}
+/**
+ * The scale one select item was rounded to, for an item that is a `round` call
+ * over a literal scale.
+ */
+function roundScaleOf(item) {
+    const expression = isRecord(item) ? item["expr"] : undefined;
+    if (!isRecord(expression) || functionNameOf(expression) !== "round") {
+        return undefined;
+    }
+    const arguments_ = callArguments(expression);
+    return arguments_.length === 2 ? literalScale(arguments_[1]) : undefined;
+}
+/**
+ * The name a function call node carries, which the parser holds as a list of
+ * the parts a qualified name would have.
+ */
+function functionNameOf(expression) {
+    const name = isRecord(expression["name"])
+        ? expression["name"]["name"]
+        : undefined;
+    const first = Array.isArray(name) ? name[0] : undefined;
+    const value = isRecord(first) ? first["value"] : undefined;
+    return typeof value === "string" ? value.toLowerCase() : "";
+}
+/**
+ * The arguments a function call node carries.
+ */
+function callArguments(expression) {
+    const arguments_ = expression["args"];
+    const value = isRecord(arguments_) ? arguments_["value"] : undefined;
+    return Array.isArray(value) ? value : [];
+}
+/**
+ * A whole number written into the statement, or nothing for anything else.
+ */
+function literalScale(node) {
+    const value = isRecord(node) && node["type"] === "number" ? node["value"] : undefined;
+    const scale = Number(value);
+    return Number.isSafeInteger(scale) && scale >= 0 ? scale : undefined;
+}

package/dist/service/athena/engine/sim-athena-sql-translation.d.ts

@@ -3,14 +3,23 @@ import type { SimAthenaSqlParser } from "./sim-athena-parser-module.js";
 /** One statement translated for SQLite, or why it was not. */
 export type SimAthenaTranslatedSql = {
     readonly sql: string;
+    /**
+     * The decimal places each result column was rounded to, by position.
+     *
+     * Read here because the syntax tree is the only place that knows, and
+     * the tree is gone by the time the answer is rendered.
+     */
+    readonly scales: ReadonlyMap<number, number>;
     readonly turnedDown: undefined;
     readonly rejected: undefined;
 } | {
     readonly sql: undefined;
+    readonly scales: undefined;
     readonly turnedDown: string;
     readonly rejected: undefined;
 } | {
     readonly sql: undefined;
+    readonly scales: undefined;
     readonly turnedDown: undefined;
     readonly rejected: string;
 };

package/dist/service/athena/engine/sim-athena-sql-translation.js

@@ -1,6 +1,7 @@
 import { simAthenaSqlForParser, simAthenaSqlForSqlite, } from "./sim-athena-sql-rewrites.js";
 import { simAthenaUnparsedStatement, simAthenaUnrewrittenUnnest, simAthenaUnwrittenStatement, } from "./sim-athena-turn-down.js";
 import { simAthenaRejectedStatement } from "./sim-athena-rejected-statement.js";
+import { simAthenaRoundScales } from "./sim-athena-round-scales.js";
 import { simAthenaRewriteUnnest } from "./sim-athena-unnest-rewrite.js";
 /**
  * One Athena statement written back out for SQLite, or why it is not.
@@ -29,7 +30,12 @@ export function simAthenaSqliteSql(request) {
     }
     const rejected = simAthenaRejectedStatement(ast);
     if (rejected !== undefined) {
-        return { sql: undefined, turnedDown: undefined, rejected };
+        return {
+            sql: undefined,
+            scales: undefined,
+            turnedDown: undefined,
+            rejected,
+        };
     }
     try {
         if (!simAthenaRewriteUnnest({
@@ -39,8 +45,12 @@ export function simAthenaSqliteSql(request) {
         })) {
             return turnedDown(simAthenaUnrewrittenUnnest);
         }
+        // Read before the tree is written back out, since the rewrites above can
+        // move a select item and the scale travels by position.
+        const scales = simAthenaRoundScales(ast);
         return {
             sql: simAthenaSqlForSqlite(parser.sqlify(ast, { database: "sqlite" })),
+            scales,
             turnedDown: undefined,
             rejected: undefined,
         };
@@ -50,5 +60,10 @@ export function simAthenaSqliteSql(request) {
     }
 }
 function turnedDown(reason) {
-    return { sql: undefined, turnedDown: reason, rejected: undefined };
+    return {
+        sql: undefined,
+        scales: undefined,
+        turnedDown: reason,
+        rejected: undefined,
+    };
 }

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-properties.js

@@ -1,3 +1,4 @@
+import { simLambdaFilterCriteriaInput } from "../../event-source/filter/sim-lambda-filter-criteria.js";
 import { simLambdaStreamDestinationConfig } from "../../event-source/sim-lambda-stream-destination-config.js";
 import { SimCfnLambdaPropertyParser } from "../function/sim-cfn-lambda-property-parser.js";
 import { recordUnsimulatedEventSourceMappingProperties } from "./sim-cfn-lambda-event-source-mapping-property-rules.js";
@@ -46,6 +47,7 @@ export class SimCfnLambdaEventSourceMappingProperties {
             StartingPosition: this.parser.optionalString(this.resource, this.properties["StartingPosition"], "StartingPosition"),
             StartingPositionTimestamp: this.startingPositionTimestamp(),
             FunctionResponseTypes: this.functionResponseTypes(),
+            FilterCriteria: simLambdaFilterCriteriaInput(this.properties["FilterCriteria"]),
         };
     }
     /**

package/dist/service/lambda/cfn/event-source-mapping/sim-cfn-lambda-event-source-mapping-property-names.js

@@ -44,13 +44,9 @@ const absentEventSource = "the mapping polls the source its EventSourceArn names
 export const unsimulatedPropertyReasons = new Map([
     ["AmazonManagedKafkaEventSourceConfig", absentEventSource],
     ["DocumentDBEventSourceConfig", absentEventSource],
-    [
-        "FilterCriteria",
-        "every record on the event source is delivered to the function, unfiltered",
-    ],
     [
         "KmsKeyArn",
-        "the key encrypts filter criteria, and filter criteria are not simulated",
+        "filter criteria are simulated in plaintext, and encrypting them is not",
     ],
     ["MetricsConfig", "the mapping publishes no CloudWatch metrics"],
     [

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping-input.d.ts

@@ -2,6 +2,7 @@ import { type SimLambdaStreamDestinationConfiguration } from "../../event-source
 import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
 import { type SimLambdaEventSourceArn } from "../../event-source/sim-lambda-event-source-arn.js";
 import type { SimLambdaFunctionResponseType } from "../../event-source/sim-lambda-event-source-mapping.js";
+import { SimLambdaFilterCriteria } from "../../event-source/filter/sim-lambda-filter-criteria.js";
 import type { SimLambdaStreamRetryLimits } from "../../event-source/sim-lambda-stream-retry-limits.js";
 import type { SimLambdaEventSourceStart } from "../../event-source/sim-lambda-event-source-starting-position.js";
 import type { SimCreateEventSourceMappingCommandInput } from "./event-source-mapping.command.js";
@@ -36,6 +37,10 @@ export declare class SimLambdaEventSourceMappingInput {
      * the counting to the mapping.
      */
     readonly streamRetryLimits: SimLambdaStreamRetryLimits | undefined;
+    /**
+     * The filters this mapping delivers through, if it was created with any.
+     */
+    readonly filterCriteria: SimLambdaFilterCriteria | undefined;
     private constructor();
     /**
      * Read a CreateEventSourceMapping request, refusing what this simulation

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping-input.js

@@ -1,5 +1,6 @@
 import { simLambdaStreamDestinationConfig, } from "../../event-source/sim-lambda-stream-destination-config.js";
 import { simLambdaEventSourceArnOf, } from "../../event-source/sim-lambda-event-source-arn.js";
+import { SimLambdaFilterCriteria } from "../../event-source/filter/sim-lambda-filter-criteria.js";
 import { SimLambdaInvalidParameterValueException } from "../../error/sim-lambda.error.js";
 import { simLambdaFunctionReferenceOf } from "../../function/sim-lambda-function-reference.js";
 import { functionResponseTypesIn, requiredString, } from "./create-event-source-mapping-values.js";
@@ -35,6 +36,10 @@ export class SimLambdaEventSourceMappingInput {
      * the counting to the mapping.
      */
     streamRetryLimits;
+    /**
+     * The filters this mapping delivers through, if it was created with any.
+     */
+    filterCriteria;
     constructor(properties) {
         this.eventSourceArn = properties.eventSourceArn;
         this.functionName = properties.functionName;
@@ -45,6 +50,7 @@ export class SimLambdaEventSourceMappingInput {
         this.functionResponseTypes = properties.functionResponseTypes;
         this.destinationConfig = properties.destinationConfig;
         this.streamRetryLimits = properties.streamRetryLimits;
+        this.filterCriteria = properties.filterCriteria;
     }
     /**
      * Read a CreateEventSourceMapping request, refusing what this simulation
@@ -65,6 +71,7 @@ export class SimLambdaEventSourceMappingInput {
             }),
             enabled: input.Enabled ?? true,
             functionResponseTypes: functionResponseTypesIn(input),
+            filterCriteria: SimLambdaFilterCriteria.of(input.FilterCriteria, eventSourceArn.kind),
             streamRetryLimits: eventSourceArn.retryLimitRules.limitsIn({
                 maximumRetryAttempts: input.MaximumRetryAttempts,
                 maximumRecordAgeInSeconds: input.MaximumRecordAgeInSeconds,

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping-refusals.js

@@ -9,7 +9,6 @@ import { SimLambdaInvalidParameterValueException } from "../../error/sim-lambda.
  * would not have.
  */
 const unsimulatedInputs = new Map([
-    ["FilterCriteria", "event filtering is not simulated"],
     ["ScalingConfig", "polling concurrency is not simulated"],
     ["ProvisionedPollerConfig", "polling concurrency is not simulated"],
     [

package/dist/service/lambda/command/event-source-mapping/create-event-source-mapping.handler.js

@@ -81,6 +81,7 @@ export class CreateEventSourceMappingCommandHandler {
             enabled: input.enabled,
             functionResponseTypes: input.functionResponseTypes,
             streamRetryLimits: input.streamRetryLimits,
+            filterCriteria: input.filterCriteria,
             destinationConfig: input.destinationConfig,
             destinations: this.properties.destinations,
             createdAt: this.properties.background.now(),

package/dist/service/lambda/command/event-source-mapping/event-source-mapping.command.d.ts

@@ -1,3 +1,4 @@
+import type { SimLambdaFilterCriteriaInput } from "../../event-source/filter/sim-lambda-filter-criteria.js";
 /**
  * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/lambda/command/CreateEventSourceMappingCommand/
  *
@@ -31,7 +32,7 @@ export interface SimCreateEventSourceMappingCommandInput {
     readonly BatchSize?: number | undefined;
     readonly MaximumBatchingWindowInSeconds?: number | undefined;
     readonly FunctionResponseTypes?: readonly string[] | undefined;
-    readonly FilterCriteria?: object | undefined;
+    readonly FilterCriteria?: SimLambdaFilterCriteriaInput | undefined;
     readonly ScalingConfig?: object | undefined;
     readonly DestinationConfig?: object | undefined;
     readonly SelfManagedEventSource?: object | undefined;

package/dist/service/lambda/command/event-source-mapping/event-source-mapping.command.js

@@ -1,7 +1 @@
-/**
- * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/lambda/command/CreateEventSourceMappingCommand/
- *
- * The event source mapping commands share their output shape, because every one
- * of them reports the mapping it acted on, so they share one module.
- */
 export {};

package/dist/service/lambda/event-source/filter/sim-lambda-filter-criteria.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The `FilterCriteria` a CreateEventSourceMapping request carries, as the
+ * command takes it.
+ */
+export interface SimLambdaFilterCriteriaInput {
+    readonly Filters?: readonly {
+        readonly Pattern?: string | undefined;
+    }[] | undefined;
+}
+/**
+ * Read a `FilterCriteria` value of unknown shape, as a template carries one.
+ *
+ * The same shape check for an SDK request and a CloudFormation Resource, so a
+ * mapping a template deployed filters the way an SDK caller's would.
+ */
+export declare function simLambdaFilterCriteriaInput(value: unknown): SimLambdaFilterCriteriaInput | undefined;
+/**
+ * The filters a mapping delivers through, read from what a request asked for.
+ *
+ * A record is delivered when any one of the filters matches it, which is how
+ * real Lambda ORs a list of patterns together. A mapping with no criteria has
+ * none of these, and delivers everything.
+ *
+ * The patterns are EventBridge event patterns. Lambda documents its filter
+ * rules as EventBridge's own syntax, so simulated EventBridge's matcher is what
+ * evaluates them, down to the operators it refuses.
+ */
+export declare class SimLambdaFilterCriteria {
+    private readonly patterns;
+    private constructor();
+    /**
+     * Read the criteria a request carries, refusing a pattern this simulation
+     * cannot evaluate.
+     *
+     * The refusal comes before the mapping exists, because a mapping created
+     * with a filter it cannot apply would deliver the wrong records rather than
+     * none.
+     */
+    static of(criteria: SimLambdaFilterCriteriaInput | undefined, eventSourceKind: string): SimLambdaFilterCriteria | undefined;
+    /**
+     * The criteria as Create, Get and List report them back.
+     */
+    configuration(): SimLambdaFilterCriteriaInput;
+    /**
+     * Whether a record, as a pattern reads it, passes any of these filters.
+     */
+    matches(document: Record<string, unknown>): boolean;
+}

package/dist/service/lambda/event-source/filter/sim-lambda-filter-criteria.js

@@ -0,0 +1,129 @@
+import { SimEventPattern } from "../../../eventbridge/pattern/sim-event-pattern.js";
+import { SimLambdaInvalidParameterValueException } from "../../error/sim-lambda.error.js";
+import { isRecord } from "../../../../util/type-guard/record.js";
+/**
+ * The one key an SQS mapping may filter on.
+ *
+ * Real Lambda filters an SQS message on its body alone, where a stream mapping
+ * filters on the whole record. A pattern naming anything else is refused here,
+ * since accepting one would match nothing and read as a pattern that was
+ * simply too specific.
+ */
+const sqsFilterKey = "body";
+/**
+ * Read a `FilterCriteria` value of unknown shape, as a template carries one.
+ *
+ * The same shape check for an SDK request and a CloudFormation Resource, so a
+ * mapping a template deployed filters the way an SDK caller's would.
+ */
+export function simLambdaFilterCriteriaInput(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const filters = isRecord(value) ? value["Filters"] : undefined;
+    if (!Array.isArray(filters)) {
+        throw new SimLambdaInvalidParameterValueException(`FilterCriteria carries a Filters list, and this one carries ${JSON.stringify(value)}`);
+    }
+    return { Filters: filters.map((filter) => ({ Pattern: patternIn(filter) })) };
+}
+/**
+ * The pattern one filter of a list carries.
+ */
+function patternIn(filter) {
+    const pattern = isRecord(filter) ? filter["Pattern"] : undefined;
+    if (pattern !== undefined && typeof pattern !== "string") {
+        throw new SimLambdaInvalidParameterValueException("A filter in FilterCriteria carries a Pattern string, and this one " +
+            `carries ${JSON.stringify(pattern)}`);
+    }
+    return pattern;
+}
+/**
+ * The filters a mapping delivers through, read from what a request asked for.
+ *
+ * A record is delivered when any one of the filters matches it, which is how
+ * real Lambda ORs a list of patterns together. A mapping with no criteria has
+ * none of these, and delivers everything.
+ *
+ * The patterns are EventBridge event patterns. Lambda documents its filter
+ * rules as EventBridge's own syntax, so simulated EventBridge's matcher is what
+ * evaluates them, down to the operators it refuses.
+ */
+export class SimLambdaFilterCriteria {
+    patterns;
+    constructor(patterns) {
+        this.patterns = patterns;
+    }
+    /**
+     * Read the criteria a request carries, refusing a pattern this simulation
+     * cannot evaluate.
+     *
+     * The refusal comes before the mapping exists, because a mapping created
+     * with a filter it cannot apply would deliver the wrong records rather than
+     * none.
+     */
+    static of(criteria, eventSourceKind) {
+        const filters = criteria?.Filters ?? [];
+        if (filters.length === 0) {
+            return undefined;
+        }
+        return new this(filters.map((filter) => patternOf(filter.Pattern, eventSourceKind)));
+    }
+    /**
+     * The criteria as Create, Get and List report them back.
+     */
+    configuration() {
+        return {
+            Filters: this.patterns.map((pattern) => ({ Pattern: pattern.source })),
+        };
+    }
+    /**
+     * Whether a record, as a pattern reads it, passes any of these filters.
+     */
+    matches(document) {
+        return this.patterns.some((pattern) => pattern.matches(document));
+    }
+}
+/**
+ * One filter's pattern, refused as a Lambda parameter rather than as an
+ * EventBridge one.
+ *
+ * The matcher is EventBridge's and says so when it refuses a pattern, and the
+ * caller here sent a Lambda request. The reason survives and the exception type
+ * changes.
+ */
+function patternOf(source, eventSourceKind) {
+    if (source === undefined || source === "") {
+        throw new SimLambdaInvalidParameterValueException("A filter in FilterCriteria carries a Pattern, and this one carries " +
+            "none");
+    }
+    refuseUnfilterableKeys(source, eventSourceKind);
+    try {
+        return SimEventPattern.of(source);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new SimLambdaInvalidParameterValueException(`FilterCriteria pattern ${source} cannot be evaluated. ${reason}`);
+    }
+}
+/**
+ * Refuse a pattern naming a key the event source does not filter on.
+ */
+function refuseUnfilterableKeys(source, eventSourceKind) {
+    if (eventSourceKind !== "sqs") {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        // An unparseable pattern is the matcher's refusal to make, in its own
+        // words, and it is about to make it.
+        return;
+    }
+    const named = isRecord(parsed) ? Object.keys(parsed) : [];
+    const unfilterable = named.filter((key) => key !== sqsFilterKey);
+    if (unfilterable.length > 0) {
+        throw new SimLambdaInvalidParameterValueException(`FilterCriteria on an SQS event source mapping filters on ${sqsFilterKey} alone, and this pattern names ${unfilterable.join(", ")}`);
+    }
+}

package/dist/service/lambda/event-source/filter/sim-lambda-filtered-delivery.d.ts

@@ -0,0 +1,27 @@
+import type { SimLambdaFilterCriteria } from "./sim-lambda-filter-criteria.js";
+interface SimLambdaFilteredDeliveryProperties<RecordType, Outcome> {
+    readonly criteria: SimLambdaFilterCriteria | undefined;
+    readonly records: readonly RecordType[];
+    /**
+     * What a pattern reads one record as, which is the source's translation.
+     */
+    readonly documentOf: (record: RecordType) => Record<string, unknown>;
+    /**
+     * What becomes of a batch the filters emptied.
+     */
+    readonly handled: () => Outcome;
+    /**
+     * Hand the records that matched to the function.
+     */
+    readonly invoke: (delivered: readonly RecordType[]) => Promise<Outcome>;
+}
+/**
+ * Deliver the records of a batch a mapping's filters let through.
+ *
+ * A batch the filters emptied is finished with and the function is never
+ * invoked, which is the one rule every source shares. What being finished with
+ * means is the source's own, and so is what a pattern reads a record as, so
+ * both are handed in.
+ */
+export declare function simLambdaFilteredDelivery<RecordType, Outcome>(properties: SimLambdaFilteredDeliveryProperties<RecordType, Outcome>): Promise<Outcome>;
+export {};

package/dist/service/lambda/event-source/filter/sim-lambda-filtered-delivery.js

@@ -0,0 +1,15 @@
+import { simLambdaFilteredRecords } from "./sim-lambda-filtered-records.js";
+/**
+ * Deliver the records of a batch a mapping's filters let through.
+ *
+ * A batch the filters emptied is finished with and the function is never
+ * invoked, which is the one rule every source shares. What being finished with
+ * means is the source's own, and so is what a pattern reads a record as, so
+ * both are handed in.
+ */
+export async function simLambdaFilteredDelivery(properties) {
+    const delivered = simLambdaFilteredRecords(properties.criteria, properties.records, properties.documentOf);
+    return delivered.length === 0
+        ? properties.handled()
+        : await properties.invoke(delivered);
+}