@kensio/yulin 1.21.3 → 1.21.4

package/dist/service/cognito/user-pool/idp/sim-cognito-attribute-mapping.d.ts

@@ -1,3 +1,4 @@
+import type { SimCognitoAttributeDataTypeValue } from "../schema/sim-cognito-attribute-data-type.js";
 import type { SimCognitoUserPoolSchema } from "../schema/sim-cognito-user-pool-schema.js";
 import type { SimCognitoAttributeType } from "../user/sim-cognito-user-attributes.js";
 import type { SimCognitoExternalUser } from "./sim-cognito-external-user.js";
@@ -25,6 +26,10 @@ export declare class SimCognitoAttributeMapping {
      * This mapping as a described provider reports it.
      */
     toOutput(): SimCognitoAttributeMappingType;
+    /**
+     * The pool attribute types one provider claim is mapped onto.
+     */
+    dataTypesForClaim(claimName: string): readonly SimCognitoAttributeDataTypeValue[];
     /**
      * The attributes an external user's claims map onto.
      */

package/dist/service/cognito/user-pool/idp/sim-cognito-attribute-mapping.js

@@ -20,6 +20,23 @@ export class SimCognitoAttributeMapping {
     toOutput() {
         return { ...this.mapping };
     }
+    /**
+     * The pool attribute types one provider claim is mapped onto.
+     */
+    dataTypesForClaim(claimName) {
+        return Object.entries(this.mapping).flatMap(([attributeName, mappedClaimName]) => {
+            if (mappedClaimName !== claimName) {
+                return [];
+            }
+            const attribute = this.schema.find(attributeName);
+            return attribute === undefined
+                ? []
+                : [
+                    attribute.toOutput()
+                        .AttributeDataType,
+                ];
+        });
+    }
     /**
      * The attributes an external user's claims map onto.
      */

package/dist/service/cognito/user-pool/idp/sim-cognito-presented-external-user.d.ts

@@ -16,13 +16,13 @@ export declare const simCognitoClaimFieldPrefix = "claim_";
  */
 export declare function simCognitoMappedClaimNames(provider: SimCognitoUserPoolIdentityProvider): readonly string[];
 /**
- * What one claim field is pre-filled with, so that the page signs a user in
- * when nobody edits it.
+ * What one claim field is pre-filled with, so the page signs a user in when
+ * nobody edits it.
  *
- * An address has to look like one, because a pool that verifies or aliases by
- * email holds it to that. Everything else is a name as far as this knows.
+ * The pool attribute type decides the shape. A string claim whose name refers
+ * to an email address uses the reserved address.
  */
-export declare function simCognitoDefaultClaim(claimName: string): string;
+export declare function simCognitoDefaultClaim(provider: SimCognitoUserPoolIdentityProvider, claimName: string): string;
 /**
  * The subject the page pre-fills, which says on its face where it came from.
  */

package/dist/service/cognito/user-pool/idp/sim-cognito-presented-external-user.js

@@ -28,16 +28,32 @@ export function simCognitoMappedClaimNames(provider) {
     return [...new Set(Object.values(provider.attributeMapping.toOutput()))];
 }
 /**
- * What one claim field is pre-filled with, so that the page signs a user in
- * when nobody edits it.
+ * What one claim field is pre-filled with, so the page signs a user in when
+ * nobody edits it.
  *
- * An address has to look like one, because a pool that verifies or aliases by
- * email holds it to that. Everything else is a name as far as this knows.
+ * The pool attribute type decides the shape. A string claim whose name refers
+ * to an email address uses the reserved address.
  */
-export function simCognitoDefaultClaim(claimName) {
-    return claimName.toLowerCase().includes("email")
-        ? defaultAddress
-        : defaultClaimValue;
+export function simCognitoDefaultClaim(provider, claimName) {
+    const dataType = provider.attributeMapping
+        .dataTypesForClaim(claimName)
+        .find((mappedType) => mappedType !== "String") ?? "String";
+    switch (dataType) {
+        case "Boolean": {
+            return "true";
+        }
+        case "DateTime": {
+            return "1970-01-01T00:00:00.000Z";
+        }
+        case "Number": {
+            return "0";
+        }
+        case "String": {
+            return claimName.toLowerCase().includes("email")
+                ? defaultAddress
+                : defaultClaimValue;
+        }
+    }
 }
 /**
  * The subject the page pre-fills, which says on its face where it came from.

package/dist/service/dynamodb/command/query/sim-dynamodb-query-expressions.d.ts

@@ -1,23 +1,26 @@
 import type { SimDynamoDbFilter } from "../../expression/filter/sim-dynamodb-filter.js";
 import type { SimDynamoDbKeyConditionTerms } from "../../expression/key-condition/sim-dynamodb-key-condition-terms.js";
+import type { SimDynamoDbProjection } from "../../expression/projection/sim-dynamodb-projection.js";
 import type { SimQueryCommandInput } from "./query.command.js";
 /**
- * What a query's expressions say, once both have been read.
+ * What a query's expressions say, once all three have been read.
  */
 export interface SimDynamoDbQueryExpressions {
     readonly terms: SimDynamoDbKeyConditionTerms;
     readonly filter: SimDynamoDbFilter | undefined;
+    readonly projection: SimDynamoDbProjection | undefined;
 }
 /**
- * Read both expressions of a query against one set of placeholders.
+ * Read every expression of a query against one set of placeholders.
  *
  * `ExpressionAttributeNames` and `ExpressionAttributeValues` are shared between
- * them, so they are checked once both have been read. A placeholder used by
- * either counts as used, and one used by neither is refused.
+ * the key condition, the filter and the projection, so they are checked once
+ * all three have been read. A placeholder used by any one of them counts as
+ * used, and one used by none is refused.
  *
- * Both are read before the table is reached, so an expression DynamoDB would
- * refuse is refused whether or not the table is there. What is left is the part
- * that needs the key schema, which each of them is held to once the table has
- * been found.
+ * All three are read before the table is reached, so an expression DynamoDB
+ * would refuse is refused whether or not the table is there. What is left is
+ * the part that needs the key schema, which each of them is held to once the
+ * table has been found.
  */
 export declare function readSimDynamoDbQueryExpressions(input: SimQueryCommandInput): SimDynamoDbQueryExpressions;

package/dist/service/dynamodb/command/query/sim-dynamodb-query-expressions.js

@@ -1,24 +1,27 @@
 import { parseSimDynamoDbFilter } from "../../expression/filter/sim-dynamodb-filter-expression.js";
 import { readSimDynamoDbKeyCondition } from "../../expression/key-condition/sim-dynamodb-key-condition-expression.js";
+import { parseSimDynamoDbProjection } from "../../expression/projection/sim-dynamodb-projection-expression.js";
 import { SimDynamoDbExpressionParameters } from "../../expression/sim-dynamodb-expression-parameters.js";
 /**
- * Read both expressions of a query against one set of placeholders.
+ * Read every expression of a query against one set of placeholders.
  *
  * `ExpressionAttributeNames` and `ExpressionAttributeValues` are shared between
- * them, so they are checked once both have been read. A placeholder used by
- * either counts as used, and one used by neither is refused.
+ * the key condition, the filter and the projection, so they are checked once
+ * all three have been read. A placeholder used by any one of them counts as
+ * used, and one used by none is refused.
  *
- * Both are read before the table is reached, so an expression DynamoDB would
- * refuse is refused whether or not the table is there. What is left is the part
- * that needs the key schema, which each of them is held to once the table has
- * been found.
+ * All three are read before the table is reached, so an expression DynamoDB
+ * would refuse is refused whether or not the table is there. What is left is
+ * the part that needs the key schema, which each of them is held to once the
+ * table has been found.
  */
 export function readSimDynamoDbQueryExpressions(input) {
     const parameters = new SimDynamoDbExpressionParameters(input);
     const terms = readSimDynamoDbKeyCondition(input, parameters);
     const filter = filterIn(input.FilterExpression, parameters);
+    const projection = projectionIn(input.ProjectionExpression, parameters);
     parameters.assertAllUsed();
-    return { terms, filter };
+    return { terms, filter, projection };
 }
 /**
  * Read the filter a query drops read items by, if it names one.
@@ -29,3 +32,12 @@ function filterIn(expression, parameters) {
     }
     return parseSimDynamoDbFilter(expression, parameters);
 }
+/**
+ * Read the parts of an item a query answers with, if it names them.
+ */
+function projectionIn(expression, parameters) {
+    if (expression === undefined) {
+        return undefined;
+    }
+    return parseSimDynamoDbProjection(expression, parameters);
+}

package/dist/service/dynamodb/command/query/sim-dynamodb-query.js

@@ -46,6 +46,7 @@ export class SimDynamoDbQuery {
         // waits for the view the same way the key condition does.
         expressions.filter?.assertNamesNoKeyAttribute(view.keySchema);
         expressions.filter?.assertNamesOnlyCarried(view);
+        expressions.projection?.assertNamesOnlyCarried(view);
         // The token names an item of the collection being read, so it can only be
         // checked once that collection is known.
         const after = readSimDynamoDbQueryStartKey({
@@ -65,6 +66,7 @@ export class SimDynamoDbQuery {
             ...new SimDynamoDbReadAnswer({
                 page,
                 filter: expressions.filter,
+                projection: expressions.projection,
                 select,
                 view,
             }).fields(),

package/dist/service/dynamodb/command/query/sim-dynamodb-unsimulated-query-input.js

@@ -9,7 +9,6 @@ import { SimDynamoDbUnsimulatedInput } from "../item/sim-dynamodb-unsimulated-in
  */
 export function refuseUnsimulatedQueryInput(input) {
     const unsimulated = new SimDynamoDbUnsimulatedInput("Query");
-    unsimulated.refuse(input.ProjectionExpression !== undefined, "ProjectionExpression", "answering with whole items where part of them was asked for");
     unsimulated.refuse((input.AttributesToGet ?? []).length > 0, "AttributesToGet", "answering with whole items where part of them was asked for");
     unsimulated.refuseNamed(input.KeyConditions, "KeyConditions", "reading a key condition written the way KeyConditionExpression replaced");
     unsimulated.refuseNamed(input.QueryFilter, "QueryFilter", "answering with the items a legacy filter would have dropped");

package/dist/service/dynamodb/command/read/sim-dynamodb-read-answer.d.ts

@@ -1,4 +1,5 @@
 import type { SimDynamoDbFilter } from "../../expression/filter/sim-dynamodb-filter.js";
+import type { SimDynamoDbProjection } from "../../expression/projection/sim-dynamodb-projection.js";
 import type { SimDynamoDbReadView } from "../../table/sim-dynamodb-read-view.js";
 import type { SimDynamoDbAttributeValue } from "../item/item.types.js";
 import type { SimDynamoDbItemPage } from "../item/sim-dynamodb-item-page.js";
@@ -15,6 +16,7 @@ export interface SimDynamoDbReadFields {
 interface SimDynamoDbReadAnswerProperties {
     readonly page: SimDynamoDbItemPage;
     readonly filter: SimDynamoDbFilter | undefined;
+    readonly projection: SimDynamoDbProjection | undefined;
     readonly select: SimDynamoDbSelect;
     readonly view: SimDynamoDbReadView;
 }
@@ -35,6 +37,7 @@ export declare class SimDynamoDbReadAnswer {
     private readonly kept;
     private readonly scannedCount;
     private readonly lastEvaluatedKey;
+    private readonly projection;
     private readonly select;
     private readonly view;
     constructor(properties: SimDynamoDbReadAnswerProperties);
@@ -49,10 +52,17 @@ export declare class SimDynamoDbReadAnswer {
     /**
      * One item as the read answers with it.
      *
-     * A read asking for whole items answers with the whole item. Anything else is
-     * cut to what the view carries, so a read of an index answers with the
-     * attributes that index projects rather than with everything. A read of the
-     * table cuts nothing either way.
+     * A `ProjectionExpression` names the attributes it wants, so it is applied to
+     * the whole item and the view is not asked to cut one first. On a global
+     * secondary index that changes nothing, since every path the projection names
+     * has already been checked against what the index projects. On a local
+     * secondary index it is what fetches an unprojected attribute from the base
+     * table, which is what real DynamoDB does for the same read.
+     *
+     * Without a projection, a read asking for whole items answers with the whole
+     * item, and anything else is cut to what the view carries. That is how a read
+     * of an index answers with the attributes that index projects rather than
+     * with everything. A read of the table cuts nothing either way.
      */
     private answered;
 }

package/dist/service/dynamodb/command/read/sim-dynamodb-read-answer.js

@@ -15,6 +15,7 @@ export class SimDynamoDbReadAnswer {
     kept;
     scannedCount;
     lastEvaluatedKey;
+    projection;
     select;
     view;
     constructor(properties) {
@@ -22,6 +23,7 @@ export class SimDynamoDbReadAnswer {
         this.scannedCount = evaluated.length;
         this.kept = properties.filter?.applyTo(evaluated) ?? evaluated;
         this.lastEvaluatedKey = properties.page.lastEvaluatedKey;
+        this.projection = properties.projection;
         this.select = properties.select;
         this.view = properties.view;
     }
@@ -50,12 +52,22 @@ export class SimDynamoDbReadAnswer {
     /**
      * One item as the read answers with it.
      *
-     * A read asking for whole items answers with the whole item. Anything else is
-     * cut to what the view carries, so a read of an index answers with the
-     * attributes that index projects rather than with everything. A read of the
-     * table cuts nothing either way.
+     * A `ProjectionExpression` names the attributes it wants, so it is applied to
+     * the whole item and the view is not asked to cut one first. On a global
+     * secondary index that changes nothing, since every path the projection names
+     * has already been checked against what the index projects. On a local
+     * secondary index it is what fetches an unprojected attribute from the base
+     * table, which is what real DynamoDB does for the same read.
+     *
+     * Without a projection, a read asking for whole items answers with the whole
+     * item, and anything else is cut to what the view carries. That is how a read
+     * of an index answers with the attributes that index projects rather than
+     * with everything. A read of the table cuts nothing either way.
      */
     answered(item) {
+        if (this.projection !== undefined) {
+            return this.projection.apply(item);
+        }
         if (this.select.wholeItems) {
             return item;
         }

package/dist/service/dynamodb/command/read/sim-dynamodb-table-read.fixture.d.ts

@@ -0,0 +1,17 @@
+import type { SimDynamoDb } from "../../sim-dynamodb.js";
+import type { SimQueryCommandInput, SimQueryCommandOutput } from "../query/query.command.js";
+import type { SimScanCommandInput } from "../scan/scan.command.js";
+/**
+ * One way of reading a table, against `simDynamoDbStockedTableFactory`.
+ *
+ * A query carries a key condition of its own, so what a test writes is added to
+ * that rather than replacing it.
+ */
+export interface SimDynamoDbTableRead {
+    readonly operation: string;
+    readonly read: (simDynamoDb: SimDynamoDb, input: SimQueryCommandInput & SimScanCommandInput) => Promise<SimQueryCommandOutput>;
+}
+/**
+ * Every way of reading a table, for a test that iterates them.
+ */
+export declare const simDynamoDbTableReads: readonly SimDynamoDbTableRead[];

package/dist/service/dynamodb/command/read/sim-dynamodb-table-read.fixture.js

@@ -0,0 +1,39 @@
+/**
+ * Test support for checking one rule on both of the operations it governs.
+ *
+ * `Select`, `ProjectionExpression` and the rest of the read parameters mean the
+ * same thing to a Query and to a Scan, and a rule proved on one of them says
+ * nothing about the other. Tests of those iterate this rather than being
+ * written twice.
+ *
+ * These helpers drive the simulator through structural command shapes rather
+ * than real SDK command objects, because this is source rather than a test
+ * file. The colocated tests cover SDK-shaped input.
+ */
+/**
+ * The values a query's own key condition needs, whatever the test adds.
+ */
+const keyConditionValues = { ":customer": { S: "c-1" } };
+/**
+ * Every way of reading a table, for a test that iterates them.
+ */
+export const simDynamoDbTableReads = [
+    {
+        operation: "Query",
+        read: async (simDynamoDb, input) => simDynamoDb.query({
+            input: {
+                TableName: "OrdersTable",
+                KeyConditionExpression: "customerId = :customer",
+                ...input,
+                ExpressionAttributeValues: {
+                    ...keyConditionValues,
+                    ...input.ExpressionAttributeValues,
+                },
+            },
+        }),
+    },
+    {
+        operation: "Scan",
+        read: async (simDynamoDb, input) => simDynamoDb.scan({ input: { TableName: "OrdersTable", ...input } }),
+    },
+];

package/dist/service/dynamodb/command/scan/sim-dynamodb-scan-expressions.d.ts

@@ -0,0 +1,28 @@
+import type { SimDynamoDbFilter } from "../../expression/filter/sim-dynamodb-filter.js";
+import type { SimDynamoDbProjection } from "../../expression/projection/sim-dynamodb-projection.js";
+import type { SimScanCommandInput } from "./scan.command.js";
+/**
+ * What a scan's expressions say, once both have been read.
+ */
+export interface SimDynamoDbScanExpressions {
+    readonly filter: SimDynamoDbFilter | undefined;
+    readonly projection: SimDynamoDbProjection | undefined;
+}
+/**
+ * Read both expressions of a scan against one set of placeholders.
+ *
+ * `ExpressionAttributeNames` and `ExpressionAttributeValues` are shared between
+ * the filter and the projection, so they are checked once both have been read.
+ * A placeholder used by either counts as used, and one used by neither is
+ * refused.
+ *
+ * A scan that names neither expression is a different refusal. There is nothing
+ * for a placeholder to be unused in, which is the wording real DynamoDB uses
+ * for a request carrying parameters and no expression at all.
+ *
+ * Both are read before the table is reached, so an expression DynamoDB would
+ * refuse is refused whether or not the table is there. What is left is which
+ * attributes the view being read carries, which each of them is held to once
+ * the table has been found.
+ */
+export declare function readSimDynamoDbScanExpressions(input: SimScanCommandInput): SimDynamoDbScanExpressions;

package/dist/service/dynamodb/command/scan/sim-dynamodb-scan-expressions.js

@@ -0,0 +1,50 @@
+import { parseSimDynamoDbFilter } from "../../expression/filter/sim-dynamodb-filter-expression.js";
+import { parseSimDynamoDbProjection } from "../../expression/projection/sim-dynamodb-projection-expression.js";
+import { SimDynamoDbExpressionParameters } from "../../expression/sim-dynamodb-expression-parameters.js";
+/**
+ * Read both expressions of a scan against one set of placeholders.
+ *
+ * `ExpressionAttributeNames` and `ExpressionAttributeValues` are shared between
+ * the filter and the projection, so they are checked once both have been read.
+ * A placeholder used by either counts as used, and one used by neither is
+ * refused.
+ *
+ * A scan that names neither expression is a different refusal. There is nothing
+ * for a placeholder to be unused in, which is the wording real DynamoDB uses
+ * for a request carrying parameters and no expression at all.
+ *
+ * Both are read before the table is reached, so an expression DynamoDB would
+ * refuse is refused whether or not the table is there. What is left is which
+ * attributes the view being read carries, which each of them is held to once
+ * the table has been found.
+ */
+export function readSimDynamoDbScanExpressions(input) {
+    if (input.FilterExpression === undefined &&
+        input.ProjectionExpression === undefined) {
+        SimDynamoDbExpressionParameters.assertNoneWithout(input);
+        return { filter: undefined, projection: undefined };
+    }
+    const parameters = new SimDynamoDbExpressionParameters(input);
+    const filter = filterIn(input.FilterExpression, parameters);
+    const projection = projectionIn(input.ProjectionExpression, parameters);
+    parameters.assertAllUsed();
+    return { filter, projection };
+}
+/**
+ * Read the filter a scan drops read items by, if it names one.
+ */
+function filterIn(expression, parameters) {
+    if (expression === undefined) {
+        return undefined;
+    }
+    return parseSimDynamoDbFilter(expression, parameters);
+}
+/**
+ * Read the parts of an item a scan answers with, if it names them.
+ */
+function projectionIn(expression, parameters) {
+    if (expression === undefined) {
+        return undefined;
+    }
+    return parseSimDynamoDbProjection(expression, parameters);
+}

package/dist/service/dynamodb/command/scan/sim-dynamodb-scan.js

@@ -1,8 +1,8 @@
-import { readSimDynamoDbFilter } from "../../expression/filter/sim-dynamodb-filter-expression.js";
 import { SimDynamoDbItemPage } from "../item/sim-dynamodb-item-page.js";
 import { SimDynamoDbReadAnswer } from "../read/sim-dynamodb-read-answer.js";
 import { assertSimDynamoDbConsistentReadAnswerable } from "../read/sim-dynamodb-consistent-read.js";
 import { SimDynamoDbSelect } from "../read/sim-dynamodb-select.js";
+import { readSimDynamoDbScanExpressions } from "./sim-dynamodb-scan-expressions.js";
 import { readSimDynamoDbScanSegment } from "./sim-dynamodb-scan-segment-input.js";
 import { readSimDynamoDbScanStartKey } from "./sim-dynamodb-scan-start-key.js";
 import { refuseUnsimulatedScanInput } from "./sim-dynamodb-unsimulated-scan-input.js";
@@ -33,12 +33,12 @@ export class SimDynamoDbScan {
         // for at all.
         const select = SimDynamoDbSelect.from(input);
         refuseUnsimulatedScanInput(input);
-        // The segment and the filter are read before the table is reached, so
+        // The segment and the expressions are read before the table is reached, so
         // input DynamoDB would refuse is refused whether or not the table is
         // there. A scan narrows nothing, so unlike a query its filter may name any
         // attribute, including a key attribute, and needs no key schema to check.
         const segment = readSimDynamoDbScanSegment(input);
-        const filter = readSimDynamoDbFilter(input);
+        const expressions = readSimDynamoDbScanExpressions(input);
         const table = this.access.required("dynamodb:Scan", input.TableName, options?.caller);
         // What is being read is settled here: the table, or one of its indexes.
         const view = table.view(input.IndexName);
@@ -47,7 +47,8 @@ export class SimDynamoDbScan {
         // two index kinds is being read, so it waits for the view.
         assertSimDynamoDbConsistentReadAnswerable(input, view);
         select.assertAnswerableBy(view);
-        filter?.assertNamesOnlyCarried(view);
+        expressions.filter?.assertNamesOnlyCarried(view);
+        expressions.projection?.assertNamesOnlyCarried(view);
         // The token names a place in this view's scan order, so it can only be
         // checked once that order is known.
         const after = readSimDynamoDbScanStartKey({
@@ -62,7 +63,13 @@ export class SimDynamoDbScan {
             view,
         });
         return {
-            ...new SimDynamoDbReadAnswer({ page, filter, select, view }).fields(),
+            ...new SimDynamoDbReadAnswer({
+                page,
+                filter: expressions.filter,
+                projection: expressions.projection,
+                select,
+                view,
+            }).fields(),
             $metadata: {},
         };
     }

package/dist/service/dynamodb/command/scan/sim-dynamodb-unsimulated-scan-input.d.ts

@@ -8,8 +8,8 @@ import type { SimScanCommandInput } from "./scan.command.js";
  * application reading the page.
  *
  * `ExpressionAttributeNames` and `ExpressionAttributeValues` are not among
- * them. They are the placeholders of the `FilterExpression`, and a request
- * carrying them with no expression to use them in is a ValidationException the
- * way it is on AWS.
+ * them. They are the placeholders of the `FilterExpression` and the
+ * `ProjectionExpression`, and a request carrying them with neither expression
+ * to use them in is a ValidationException the way it is on AWS.
  */
 export declare function refuseUnsimulatedScanInput(input: SimScanCommandInput): void;

package/dist/service/dynamodb/command/scan/sim-dynamodb-unsimulated-scan-input.js

@@ -8,13 +8,12 @@ import { SimDynamoDbUnsimulatedInput } from "../item/sim-dynamodb-unsimulated-in
  * application reading the page.
  *
  * `ExpressionAttributeNames` and `ExpressionAttributeValues` are not among
- * them. They are the placeholders of the `FilterExpression`, and a request
- * carrying them with no expression to use them in is a ValidationException the
- * way it is on AWS.
+ * them. They are the placeholders of the `FilterExpression` and the
+ * `ProjectionExpression`, and a request carrying them with neither expression
+ * to use them in is a ValidationException the way it is on AWS.
  */
 export function refuseUnsimulatedScanInput(input) {
     const unsimulated = new SimDynamoDbUnsimulatedInput("Scan");
-    unsimulated.refuse(input.ProjectionExpression !== undefined, "ProjectionExpression", "answering with whole items where part of them was asked for");
     unsimulated.refuse((input.AttributesToGet ?? []).length > 0, "AttributesToGet", "answering with whole items where part of them was asked for");
     unsimulated.refuseNamed(input.ScanFilter, "ScanFilter", "answering with the items a legacy filter would have dropped");
     unsimulated.refuse(input.ConditionalOperator !== undefined, "ConditionalOperator", "joining the legacy conditions it applies to");

package/dist/service/dynamodb/expression/filter/sim-dynamodb-filter-expression.d.ts

@@ -1,23 +1,12 @@
-import type { SimDynamoDbExpressionParameterInput } from "../sim-dynamodb-expression-parameters.js";
-import { SimDynamoDbExpressionParameters } from "../sim-dynamodb-expression-parameters.js";
+import type { SimDynamoDbExpressionParameters } from "../sim-dynamodb-expression-parameters.js";
 import { SimDynamoDbFilter } from "./sim-dynamodb-filter.js";
-interface SimDynamoDbFilterRequest extends SimDynamoDbExpressionParameterInput {
-    readonly FilterExpression?: string | undefined;
-}
-/**
- * Read the filter a read drops items by, if it names one.
- *
- * A request with no FilterExpression answers with every item it read, so there
- * is nothing to drop by.
- */
-export declare function readSimDynamoDbFilter(request: SimDynamoDbFilterRequest): SimDynamoDbFilter | undefined;
 /**
  * Read one FilterExpression against placeholders that have already been
  * gathered.
  *
- * A query carries a key condition alongside its filter, and both draw on the
- * same `ExpressionAttributeNames` and `ExpressionAttributeValues`, so the
- * placeholders are checked once both expressions have been read.
+ * Every read that can carry a filter can carry another expression alongside it,
+ * and they draw on the same `ExpressionAttributeNames` and
+ * `ExpressionAttributeValues`, so the placeholders are gathered by the caller
+ * and checked once every expression has been read.
  */
 export declare function parseSimDynamoDbFilter(expression: string, parameters: SimDynamoDbExpressionParameters): SimDynamoDbFilter;
-export {};

package/dist/service/dynamodb/expression/filter/sim-dynamodb-filter-expression.js

@@ -1,31 +1,14 @@
 import { simDynamoDbConditionParser } from "../condition/sim-dynamodb-condition-grammar.js";
-import { SimDynamoDbExpressionParameters } from "../sim-dynamodb-expression-parameters.js";
 import { SimDynamoDbFilter } from "./sim-dynamodb-filter.js";
 const expressionName = "FilterExpression";
-/**
- * Read the filter a read drops items by, if it names one.
- *
- * A request with no FilterExpression answers with every item it read, so there
- * is nothing to drop by.
- */
-export function readSimDynamoDbFilter(request) {
-    const expression = request.FilterExpression;
-    if (expression === undefined) {
-        SimDynamoDbExpressionParameters.assertNoneWithout(request);
-        return undefined;
-    }
-    const parameters = new SimDynamoDbExpressionParameters(request);
-    const filter = parseSimDynamoDbFilter(expression, parameters);
-    parameters.assertAllUsed();
-    return filter;
-}
 /**
  * Read one FilterExpression against placeholders that have already been
  * gathered.
  *
- * A query carries a key condition alongside its filter, and both draw on the
- * same `ExpressionAttributeNames` and `ExpressionAttributeValues`, so the
- * placeholders are checked once both expressions have been read.
+ * Every read that can carry a filter can carry another expression alongside it,
+ * and they draw on the same `ExpressionAttributeNames` and
+ * `ExpressionAttributeValues`, so the placeholders are gathered by the caller
+ * and checked once every expression has been read.
  */
 export function parseSimDynamoDbFilter(expression, parameters) {
     const parser = simDynamoDbConditionParser(expressionName, expression, parameters);

package/dist/service/dynamodb/expression/projection/sim-dynamodb-projection-expression.d.ts

@@ -1,4 +1,5 @@
 import type { SimDynamoDbExpressionParameterInput } from "../sim-dynamodb-expression-parameters.js";
+import { SimDynamoDbExpressionParameters } from "../sim-dynamodb-expression-parameters.js";
 import { SimDynamoDbProjection } from "./sim-dynamodb-projection.js";
 interface SimDynamoDbProjectionRequest extends SimDynamoDbExpressionParameterInput {
     readonly ProjectionExpression?: string | undefined;
@@ -8,6 +9,20 @@ interface SimDynamoDbProjectionRequest extends SimDynamoDbExpressionParameterInp
  *
  * A request with no ProjectionExpression asks for the whole item, so there is
  * nothing to project.
+ *
+ * This is the form for a request whose projection is its only expression, which
+ * is every read that names one item or a list of them. A query or a scan can
+ * carry a filter alongside its projection, and reads both against one set of
+ * placeholders through `parseSimDynamoDbProjection`.
  */
 export declare function readSimDynamoDbProjection(request: SimDynamoDbProjectionRequest): SimDynamoDbProjection | undefined;
+/**
+ * Read one ProjectionExpression against placeholders that have already been
+ * gathered.
+ *
+ * A query carries a key condition and may carry a filter alongside its
+ * projection, and all three draw on the same `ExpressionAttributeNames`, so the
+ * placeholders are checked once every expression has been read.
+ */
+export declare function parseSimDynamoDbProjection(expression: string, parameters: SimDynamoDbExpressionParameters): SimDynamoDbProjection;
 export {};