@kensio/yulin 0.44.0 → 0.45.0

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-operands.d.ts

@@ -0,0 +1,49 @@
+import type { SimDynamoDbValue } from "../../item/sim-dynamodb-value.js";
+import type { SimDynamoDbExpressionPlaceholders } from "../sim-dynamodb-expression-placeholders.js";
+import type { SimDynamoDbExpressionTokens } from "../sim-dynamodb-expression-tokens.js";
+import { type SimDynamoDbKeyConditionRefusals } from "./sim-dynamodb-key-condition-refusals.js";
+interface SimDynamoDbKeyConditionOperandsProperties {
+    readonly tokens: SimDynamoDbExpressionTokens;
+    readonly names: SimDynamoDbExpressionPlaceholders<string>;
+    readonly values: SimDynamoDbExpressionPlaceholders<SimDynamoDbValue>;
+    readonly refusals: SimDynamoDbKeyConditionRefusals;
+}
+/**
+ * The three pieces every key condition term is built from: the key attribute,
+ * the comparator, and the value.
+ *
+ * They are read here rather than in the parser, so the parser stays the shape a
+ * key condition is allowed to take.
+ */
+export declare class SimDynamoDbKeyConditionOperands {
+    private readonly tokens;
+    private readonly names;
+    private readonly values;
+    private readonly refusals;
+    constructor(properties: SimDynamoDbKeyConditionOperandsProperties);
+    /**
+     * Read the name of the key attribute a term names.
+     *
+     * A key attribute is a top-level attribute, so this reads one token rather
+     * than a document path: a key is scalar, and nothing in the closed grammar
+     * dereferences one.
+     */
+    attributeName(): string;
+    /**
+     * Read the value a term compares against, which is always supplied.
+     *
+     * Key conditions have no literals, so every value arrives through
+     * `ExpressionAttributeValues`.
+     */
+    value(): SimDynamoDbValue;
+    /**
+     * Read the comparator between a key attribute and a value.
+     */
+    comparator(): string;
+    /**
+     * The attribute a name token stands for, which may be a placeholder.
+     */
+    private nameOf;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-key-condition-operands.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-operands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-operands.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-operands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,4CAA4C,CAAC;AACpG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAExF,OAAO,EAEL,KAAK,+BAA+B,EACrC,MAAM,0CAA0C,CAAC;AAgBlD,UAAU,yCAAyC;IACjD,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,iCAAiC,CAAC,MAAM,CAAC,CAAC;IAC1D,QAAQ,CAAC,MAAM,EAAE,iCAAiC,CAAC,gBAAgB,CAAC,CAAC;IACrE,QAAQ,CAAC,QAAQ,EAAE,+BAA+B,CAAC;CACpD;AAED;;;;;;GAMG;AACH,qBAAa,+BAA+B;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA4C;IAClE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsD;IAC7E,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAE3D,YAAY,UAAU,EAAE,yCAAyC,EAKhE;IAED;;;;;;OAMG;IACH,aAAa,IAAI,MAAM,CAetB;IAED;;;;;OAKG;IACH,KAAK,IAAI,gBAAgB,CAWxB;IAED;;OAEG;IACH,UAAU,IAAI,MAAM,CAWnB;IAED;;OAEG;IACH,OAAO,CAAC,MAAM;CAOf"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-operands.js

@@ -0,0 +1,86 @@
+import { simDynamoDbKeyConditionError } from "./sim-dynamodb-key-condition-error.js";
+import { simDynamoDbBeginsWithName, } from "./sim-dynamodb-key-condition-refusals.js";
+/**
+ * The comparators a key condition puts between a key attribute and a value.
+ *
+ * `<>` is not among them. A query reads a contiguous run of the sort key, and
+ * "everything except this one" is not one.
+ */
+const keyComparators = new Set([
+    "=",
+    "<",
+    "<=",
+    ">",
+    ">=",
+]);
+/**
+ * The three pieces every key condition term is built from: the key attribute,
+ * the comparator, and the value.
+ *
+ * They are read here rather than in the parser, so the parser stays the shape a
+ * key condition is allowed to take.
+ */
+export class SimDynamoDbKeyConditionOperands {
+    tokens;
+    names;
+    values;
+    refusals;
+    constructor(properties) {
+        this.tokens = properties.tokens;
+        this.names = properties.names;
+        this.values = properties.values;
+        this.refusals = properties.refusals;
+    }
+    /**
+     * Read the name of the key attribute a term names.
+     *
+     * A key attribute is a top-level attribute, so this reads one token rather
+     * than a document path: a key is scalar, and nothing in the closed grammar
+     * dereferences one.
+     */
+    attributeName() {
+        const token = this.tokens.next("a key attribute name");
+        if (token.kind !== "name" && token.kind !== "namePlaceholder") {
+            throw simDynamoDbKeyConditionError(`syntax error; a key attribute name was expected, but ` +
+                `'${token.text}' was given`);
+        }
+        const attributeName = this.nameOf(token.kind, token.text);
+        this.refusals.assertNotNested(attributeName);
+        return attributeName;
+    }
+    /**
+     * Read the value a term compares against, which is always supplied.
+     *
+     * Key conditions have no literals, so every value arrives through
+     * `ExpressionAttributeValues`.
+     */
+    value() {
+        const token = this.tokens.next("a value placeholder");
+        if (token.kind !== "valuePlaceholder") {
+            throw simDynamoDbKeyConditionError(`a key condition compares a key attribute against a value from ` +
+                `ExpressionAttributeValues, and '${token.text}' is not one`);
+        }
+        return this.values.required(token.text);
+    }
+    /**
+     * Read the comparator between a key attribute and a value.
+     */
+    comparator() {
+        const token = this.tokens.next("a comparator");
+        if (token.kind !== "symbol" || !keyComparators.has(token.text)) {
+            throw simDynamoDbKeyConditionError(`'${token.text}' is not a key condition operator. A key condition ` +
+                `uses =, <, <=, >, >=, BETWEEN or ${simDynamoDbBeginsWithName}.`);
+        }
+        return token.text;
+    }
+    /**
+     * The attribute a name token stands for, which may be a placeholder.
+     */
+    nameOf(kind, text) {
+        if (kind === "name") {
+            return text;
+        }
+        return this.names.required(text);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-key-condition-operands.js.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-operands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-operands.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-operands.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EACL,yBAAyB,GAE1B,MAAM,0CAA0C,CAAC;AAElD;;;;;GAKG;AACH,MAAM,cAAc,GAAwB,IAAI,GAAG,CAAC;IAClD,GAAG;IACH,GAAG;IACH,IAAI;IACJ,GAAG;IACH,IAAI;CACL,CAAC,CAAC;AASH;;;;;;GAMG;AACH,MAAM,OAAO,+BAA+B;IACzB,MAAM,CAA8B;IACpC,KAAK,CAA4C;IACjD,MAAM,CAAsD;IAC5D,QAAQ,CAAkC;IAE3D,YAAY,UAAqD;QAC/D,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;IACtC,CAAC;IAED;;;;;;OAMG;IACH,aAAa;QACX,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;QAEvD,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,IAAI,KAAK,CAAC,IAAI,KAAK,iBAAiB,EAAE,CAAC;YAC9D,MAAM,4BAA4B,CAChC,uDAAuD;gBACrD,IAAI,KAAK,CAAC,IAAI,aAAa,CAC9B,CAAC;QACJ,CAAC;QAED,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QAE1D,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC;QAE7C,OAAO,aAAa,CAAC;IACvB,CAAC;IAED;;;;;OAKG;IACH,KAAK;QACH,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QAEtD,IAAI,KAAK,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;YACtC,MAAM,4BAA4B,CAChC,gEAAgE;gBAC9D,mCAAmC,KAAK,CAAC,IAAI,cAAc,CAC9D,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IAED;;OAEG;IACH,UAAU;QACR,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;QAE/C,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAC/D,MAAM,4BAA4B,CAChC,IAAI,KAAK,CAAC,IAAI,qDAAqD;gBACjE,oCAAoC,yBAAyB,GAAG,CACnE,CAAC;QACJ,CAAC;QAED,OAAO,KAAK,CAAC,IAAI,CAAC;IACpB,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,IAAY,EAAE,IAAY;QACvC,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;YACpB,OAAO,IAAI,CAAC;QACd,CAAC;QAED,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;CACF"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-parser.d.ts

@@ -0,0 +1,51 @@
+import type { SimDynamoDbValue } from "../../item/sim-dynamodb-value.js";
+import type { SimDynamoDbExpressionPlaceholders } from "../sim-dynamodb-expression-placeholders.js";
+import type { SimDynamoDbExpressionTokens } from "../sim-dynamodb-expression-tokens.js";
+import type { SimDynamoDbKeyConditionTerm } from "./sim-dynamodb-key-condition-term.js";
+interface SimDynamoDbKeyConditionParserProperties {
+    readonly tokens: SimDynamoDbExpressionTokens;
+    readonly names: SimDynamoDbExpressionPlaceholders<string>;
+    readonly values: SimDynamoDbExpressionPlaceholders<SimDynamoDbValue>;
+}
+/**
+ * Reads a KeyConditionExpression into the terms it is made of.
+ *
+ * This is deliberately not the general condition grammar. A key condition is
+ * one equality on the partition key, optionally joined by AND to one sort key
+ * condition, and nothing else. Sharing the condition parser would let a query
+ * accept `OR`, which real DynamoDB refuses, and that is the kind of divergence
+ * that passes here and fails on deploy.
+ *
+ * Which attribute is the partition key and which is the sort key is not known
+ * here, since that is a property of the table rather than of the expression.
+ * This reads the terms, and `SimDynamoDbKeyConditionTerms` holds them to the
+ * key schema once the table has been reached.
+ */
+export declare class SimDynamoDbKeyConditionParser {
+    private readonly tokens;
+    private readonly refusals;
+    private readonly operands;
+    constructor(properties: SimDynamoDbKeyConditionParserProperties);
+    /**
+     * Read the whole expression, refusing anything left over after it.
+     */
+    parse(): readonly SimDynamoDbKeyConditionTerm[];
+    /**
+     * Read one term, which is either a prefix call or a key attribute put
+     * against one or two values.
+     */
+    private term;
+    /**
+     * Read a key attribute put against one value, or between two of them.
+     */
+    private comparison;
+    /**
+     * Read `sortKey BETWEEN :lower AND :upper`.
+     *
+     * The AND here belongs to BETWEEN rather than joining two terms, which is why
+     * the range is read inside a term rather than beside one.
+     */
+    private between;
+}
+export {};
+//# sourceMappingURL=sim-dynamodb-key-condition-parser.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-parser.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,4CAA4C,CAAC;AACpG,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAMxF,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAExF,UAAU,uCAAuC;IAC/C,QAAQ,CAAC,MAAM,EAAE,2BAA2B,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,iCAAiC,CAAC,MAAM,CAAC,CAAC;IAC1D,QAAQ,CAAC,MAAM,EAAE,iCAAiC,CAAC,gBAAgB,CAAC,CAAC;CACtE;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,6BAA6B;IACxC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAE3D,YAAY,UAAU,EAAE,uCAAuC,EAW9D;IAED;;OAEG;IACH,KAAK,IAAI,SAAS,2BAA2B,EAAE,CAU9C;IAED;;;OAGG;IACH,OAAO,CAAC,IAAI;IAcZ;;OAEG;IACH,OAAO,CAAC,UAAU;IAclB;;;;;OAKG;IACH,OAAO,CAAC,OAAO;CAUhB"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-parser.js

@@ -0,0 +1,91 @@
+import { SimDynamoDbBeginsWithKeyTerm } from "./sim-dynamodb-begins-with-key-term.js";
+import { SimDynamoDbBetweenKeyTerm } from "./sim-dynamodb-between-key-term.js";
+import { SimDynamoDbComparisonKeyTerm } from "./sim-dynamodb-comparison-key-term.js";
+import { SimDynamoDbKeyConditionOperands } from "./sim-dynamodb-key-condition-operands.js";
+import { SimDynamoDbKeyConditionRefusals } from "./sim-dynamodb-key-condition-refusals.js";
+/**
+ * Reads a KeyConditionExpression into the terms it is made of.
+ *
+ * This is deliberately not the general condition grammar. A key condition is
+ * one equality on the partition key, optionally joined by AND to one sort key
+ * condition, and nothing else. Sharing the condition parser would let a query
+ * accept `OR`, which real DynamoDB refuses, and that is the kind of divergence
+ * that passes here and fails on deploy.
+ *
+ * Which attribute is the partition key and which is the sort key is not known
+ * here, since that is a property of the table rather than of the expression.
+ * This reads the terms, and `SimDynamoDbKeyConditionTerms` holds them to the
+ * key schema once the table has been reached.
+ */
+export class SimDynamoDbKeyConditionParser {
+    tokens;
+    refusals;
+    operands;
+    constructor(properties) {
+        const refusals = new SimDynamoDbKeyConditionRefusals(properties.tokens);
+        this.tokens = properties.tokens;
+        this.refusals = refusals;
+        this.operands = new SimDynamoDbKeyConditionOperands({
+            tokens: properties.tokens,
+            names: properties.names,
+            values: properties.values,
+            refusals,
+        });
+    }
+    /**
+     * Read the whole expression, refusing anything left over after it.
+     */
+    parse() {
+        const terms = [this.term()];
+        while (this.tokens.takeKeyword("AND")) {
+            terms.push(this.term());
+        }
+        this.refusals.assertNothingFollows();
+        return terms;
+    }
+    /**
+     * Read one term, which is either a prefix call or a key attribute put
+     * against one or two values.
+     */
+    term() {
+        this.refusals.assertNoLogicalOperator();
+        this.refusals.assertNoBracket();
+        if (this.refusals.takesBeginsWith()) {
+            return SimDynamoDbBeginsWithKeyTerm.read({
+                tokens: this.tokens,
+                operands: this.operands,
+            });
+        }
+        return this.comparison();
+    }
+    /**
+     * Read a key attribute put against one value, or between two of them.
+     */
+    comparison() {
+        const attributeName = this.operands.attributeName();
+        if (this.tokens.takeKeyword("BETWEEN")) {
+            return this.between(attributeName);
+        }
+        return new SimDynamoDbComparisonKeyTerm({
+            attributeName,
+            operator: this.operands.comparator(),
+            value: this.operands.value(),
+        });
+    }
+    /**
+     * Read `sortKey BETWEEN :lower AND :upper`.
+     *
+     * The AND here belongs to BETWEEN rather than joining two terms, which is why
+     * the range is read inside a term rather than beside one.
+     */
+    between(attributeName) {
+        const lower = this.operands.value();
+        this.tokens.expectKeyword("AND");
+        return new SimDynamoDbBetweenKeyTerm({
+            attributeName,
+            lower,
+            upper: this.operands.value(),
+        });
+    }
+}
+//# sourceMappingURL=sim-dynamodb-key-condition-parser.js.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-parser.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-parser.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AACtF,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AACrF,OAAO,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAC3F,OAAO,EAAE,+BAA+B,EAAE,MAAM,0CAA0C,CAAC;AAS3F;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,6BAA6B;IACvB,MAAM,CAA8B;IACpC,QAAQ,CAAkC;IAC1C,QAAQ,CAAkC;IAE3D,YAAY,UAAmD;QAC7D,MAAM,QAAQ,GAAG,IAAI,+BAA+B,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QAExE,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;QAChC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,QAAQ,GAAG,IAAI,+BAA+B,CAAC;YAClD,MAAM,EAAE,UAAU,CAAC,MAAM;YACzB,KAAK,EAAE,UAAU,CAAC,KAAK;YACvB,MAAM,EAAE,UAAU,CAAC,MAAM;YACzB,QAAQ;SACT,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK;QACH,MAAM,KAAK,GAAkC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QAE3D,OAAO,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;YACtC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QAC1B,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,oBAAoB,EAAE,CAAC;QAErC,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACK,IAAI;QACV,IAAI,CAAC,QAAQ,CAAC,uBAAuB,EAAE,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,CAAC;QAEhC,IAAI,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,EAAE,CAAC;YACpC,OAAO,4BAA4B,CAAC,IAAI,CAAC;gBACvC,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;aACxB,CAAC,CAAC;QACL,CAAC;QAED,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC;IAED;;OAEG;IACK,UAAU;QAChB,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,aAAa,EAAE,CAAC;QAEpD,IAAI,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;YACvC,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC;QACrC,CAAC;QAED,OAAO,IAAI,4BAA4B,CAAC;YACtC,aAAa;YACb,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE;YACpC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;SAC7B,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,OAAO,CAAC,aAAqB;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACpC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAEjC,OAAO,IAAI,yBAAyB,CAAC;YACnC,aAAa;YACb,KAAK;YACL,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE;SAC7B,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-refusals.d.ts

@@ -0,0 +1,53 @@
+import type { SimDynamoDbExpressionTokens } from "../sim-dynamodb-expression-tokens.js";
+/**
+ * The one function a key condition takes, read in lower case as real DynamoDB
+ * reads it.
+ */
+export declare const simDynamoDbBeginsWithName = "begins_with";
+/**
+ * What a key condition is refused for being, rather than for what it says.
+ *
+ * These are the shapes the general condition grammar takes and a key condition
+ * does not. They are a group of their own because each is about telling a
+ * caller which part of that grammar has no place here, rather than about
+ * building anything.
+ */
+export declare class SimDynamoDbKeyConditionRefusals {
+    private readonly tokens;
+    constructor(tokens: SimDynamoDbExpressionTokens);
+    /**
+     * Refuse the boolean operators a key condition has no place for.
+     *
+     * `OR` and `NOT` are reserved words in an expression, so an attribute of
+     * either name is written as a placeholder and never arrives here.
+     */
+    assertNoLogicalOperator(): void;
+    /**
+     * Refuse a bracketed term.
+     *
+     * Brackets group a condition, and there is nothing here to group: the shape
+     * of a key condition is fixed. Refusing them is stricter than real DynamoDB,
+     * and is recorded in the Limitations section of the usage docs.
+     */
+    assertNoBracket(): void;
+    /**
+     * Whether the next term is a `begins_with` call, refusing any other function.
+     *
+     * A function name followed by anything but an opening bracket is an ordinary
+     * attribute name, since none of these words is reserved.
+     */
+    takesBeginsWith(): boolean;
+    /**
+     * Refuse a term dereferencing the attribute it names.
+     */
+    assertNotNested(attributeName: string): void;
+    /**
+     * Refuse anything left over after the last term of an expression.
+     */
+    assertNothingFollows(): void;
+    /**
+     * The name of the function the next term calls, if it calls one.
+     */
+    private calledFunction;
+}
+//# sourceMappingURL=sim-dynamodb-key-condition-refusals.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-refusals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-refusals.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-refusals.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAGxF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,gBAAgB,CAAC;AAYvD;;;;;;;GAOG;AACH,qBAAa,+BAA+B;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8B;IAErD,YAAY,MAAM,EAAE,2BAA2B,EAE9C;IAED;;;;;OAKG;IACH,uBAAuB,IAAI,IAAI,CAkB9B;IAED;;;;;;OAMG;IACH,eAAe,IAAI,IAAI,CAStB;IAED;;;;;OAKG;IACH,eAAe,IAAI,OAAO,CAgBzB;IAED;;OAEG;IACH,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAS3C;IAED;;OAEG;IACH,oBAAoB,IAAI,IAAI,CAU3B;IAED;;OAEG;IACH,OAAO,CAAC,cAAc;CASvB"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-refusals.js

@@ -0,0 +1,116 @@
+import { simDynamoDbKeyConditionError } from "./sim-dynamodb-key-condition-error.js";
+/**
+ * The one function a key condition takes, read in lower case as real DynamoDB
+ * reads it.
+ */
+export const simDynamoDbBeginsWithName = "begins_with";
+/**
+ * The boolean operators a key condition has no place for.
+ */
+const refusedKeywords = new Set(["OR", "NOT"]);
+/**
+ * The symbols that dereference the attribute before them.
+ */
+const dereferenceSymbols = new Set([".", "["]);
+/**
+ * What a key condition is refused for being, rather than for what it says.
+ *
+ * These are the shapes the general condition grammar takes and a key condition
+ * does not. They are a group of their own because each is about telling a
+ * caller which part of that grammar has no place here, rather than about
+ * building anything.
+ */
+export class SimDynamoDbKeyConditionRefusals {
+    tokens;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    /**
+     * Refuse the boolean operators a key condition has no place for.
+     *
+     * `OR` and `NOT` are reserved words in an expression, so an attribute of
+     * either name is written as a placeholder and never arrives here.
+     */
+    assertNoLogicalOperator() {
+        const token = this.tokens.peek();
+        if (token?.kind !== "name") {
+            return;
+        }
+        const word = token.text.toUpperCase();
+        if (!refusedKeywords.has(word)) {
+            return;
+        }
+        throw simDynamoDbKeyConditionError(`${word} is not part of a key condition. A key condition tests the ` +
+            `partition key for equality, and may add one sort key condition ` +
+            `after AND.`);
+    }
+    /**
+     * Refuse a bracketed term.
+     *
+     * Brackets group a condition, and there is nothing here to group: the shape
+     * of a key condition is fixed. Refusing them is stricter than real DynamoDB,
+     * and is recorded in the Limitations section of the usage docs.
+     */
+    assertNoBracket() {
+        const token = this.tokens.peek();
+        if (token?.kind === "symbol" && token.text === "(") {
+            throw simDynamoDbKeyConditionError(`a key condition takes no brackets: it is one partition key ` +
+                `equality, optionally with one sort key condition after AND`);
+        }
+    }
+    /**
+     * Whether the next term is a `begins_with` call, refusing any other function.
+     *
+     * A function name followed by anything but an opening bracket is an ordinary
+     * attribute name, since none of these words is reserved.
+     */
+    takesBeginsWith() {
+        const called = this.calledFunction();
+        if (called === undefined) {
+            return false;
+        }
+        if (called !== simDynamoDbBeginsWithName) {
+            throw simDynamoDbKeyConditionError(`${called} is not a key condition function. ` +
+                `${simDynamoDbBeginsWithName} is the only one a sort key condition ` +
+                `uses.`);
+        }
+        return true;
+    }
+    /**
+     * Refuse a term dereferencing the attribute it names.
+     */
+    assertNotNested(attributeName) {
+        const token = this.tokens.peek();
+        if (token?.kind === "symbol" && dereferenceSymbols.has(token.text)) {
+            throw simDynamoDbKeyConditionError(`${attributeName} is followed by '${token.text}', and a key condition ` +
+                `names a top-level attribute: a key is scalar and cannot be nested`);
+        }
+    }
+    /**
+     * Refuse anything left over after the last term of an expression.
+     */
+    assertNothingFollows() {
+        this.assertNoLogicalOperator();
+        const remaining = this.tokens.peek();
+        if (remaining !== undefined) {
+            throw simDynamoDbKeyConditionError(`syntax error; '${remaining.text}' follows a complete key condition`);
+        }
+    }
+    /**
+     * The name of the function the next term calls, if it calls one.
+     */
+    calledFunction() {
+        const token = this.tokens.peek();
+        if (token?.kind !== "name" || !opensBracket(this.tokens.peek(1))) {
+            return undefined;
+        }
+        return token.text;
+    }
+}
+/**
+ * Whether a token is the bracket that makes the name before it a call.
+ */
+function opensBracket(token) {
+    return token?.kind === "symbol" && token.text === "(";
+}
+//# sourceMappingURL=sim-dynamodb-key-condition-refusals.js.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-refusals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-refusals.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-refusals.ts"],"names":[],"mappings":"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"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-term.d.ts

@@ -0,0 +1,34 @@
+import type { SimDynamoDbScalarAttributeType } from "../../command/table/table.types.js";
+import type { SimDynamoDbValue } from "../../item/sim-dynamodb-value.js";
+/**
+ * One test a key condition makes against one key attribute.
+ *
+ * A key condition is a closed grammar rather than a general condition, so there
+ * are only three of these: a comparison, a range, and a prefix. Each is its own
+ * class, since what they refuse and how they read a value differ.
+ */
+export interface SimDynamoDbKeyConditionTerm {
+    /** The attribute this term names, before anything knows if it is a key. */
+    readonly attributeName: string;
+    /** How the term was written, for a refusal to name it. */
+    readonly operator: string;
+    /**
+     * Whether a key value is inside what this term asks for.
+     */
+    holdsFor(value: SimDynamoDbValue): boolean;
+    /**
+     * Refuse a term that cannot be applied to the key attribute it names.
+     */
+    assertUsableOn(type: SimDynamoDbScalarAttributeType): void;
+}
+/**
+ * Refuse a value of a type the table did not declare for a key attribute.
+ *
+ * A key attribute has exactly one type, so a condition comparing it against
+ * another type can never hold for any item. Real DynamoDB refuses the request,
+ * and so does this: answering with nothing instead would read as an item
+ * collection that happens to be empty, which is a test passing here on a query
+ * that fails on deploy.
+ */
+export declare function assertSimDynamoDbKeyValueType(attributeName: string, value: SimDynamoDbValue, type: SimDynamoDbScalarAttributeType): void;
+//# sourceMappingURL=sim-dynamodb-key-condition-term.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-term.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-term.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-term.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oCAAoC,CAAC;AAEzF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAEzE;;;;;;GAMG;AACH,MAAM,WAAW,2BAA2B;IAC1C,2EAA2E;IAC3E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAAC;IAE3C;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,8BAA8B,GAAG,IAAI,CAAC;CAC5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,8BAA8B,GACnC,IAAI,CAQN"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-term.js

@@ -0,0 +1,18 @@
+import { SimDynamoDbValidationException } from "../../error/dynamodb.error.js";
+/**
+ * Refuse a value of a type the table did not declare for a key attribute.
+ *
+ * A key attribute has exactly one type, so a condition comparing it against
+ * another type can never hold for any item. Real DynamoDB refuses the request,
+ * and so does this: answering with nothing instead would read as an item
+ * collection that happens to be empty, which is a test passing here on a query
+ * that fails on deploy.
+ */
+export function assertSimDynamoDbKeyValueType(attributeName, value, type) {
+    if (value.kind !== type) {
+        throw new SimDynamoDbValidationException(`One or more parameter values were invalid: Condition parameter type ` +
+            `does not match schema type. The key attribute ${attributeName} is ` +
+            `${type}, and the key condition compares it against ${value.kind}.`);
+    }
+}
+//# sourceMappingURL=sim-dynamodb-key-condition-term.js.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-term.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-term.js","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-term.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,8BAA8B,EAAE,MAAM,+BAA+B,CAAC;AA2B/E;;;;;;;;GAQG;AACH,MAAM,UAAU,6BAA6B,CAC3C,aAAqB,EACrB,KAAuB,EACvB,IAAoC;IAEpC,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACxB,MAAM,IAAI,8BAA8B,CACtC,sEAAsE;YACpE,iDAAiD,aAAa,MAAM;YACpE,GAAG,IAAI,+CAA+C,KAAK,CAAC,IAAI,GAAG,CACtE,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-terms.d.ts

@@ -0,0 +1,52 @@
+import type { SimDynamoDbAttributeDefinitions } from "../../table/sim-dynamodb-attribute-definitions.js";
+import type { SimDynamoDbKeySchema } from "../../table/sim-dynamodb-key-schema.js";
+import { SimDynamoDbKeyCondition } from "./sim-dynamodb-key-condition.js";
+import type { SimDynamoDbKeyConditionTerm } from "./sim-dynamodb-key-condition-term.js";
+/**
+ * What a key condition needs to know about the table it names.
+ */
+export interface SimDynamoDbKeyConditionTable {
+    readonly keySchema: SimDynamoDbKeySchema;
+    readonly attributeDefinitions: SimDynamoDbAttributeDefinitions;
+}
+/**
+ * The terms one KeyConditionExpression was written as.
+ *
+ * The expression is read before the table is reached, so that a request real
+ * DynamoDB would refuse is refused whether or not the table exists. Which
+ * attribute is the partition key is a property of the table, so the rules that
+ * need it are applied here rather than in the parser, once the table is known.
+ */
+export declare class SimDynamoDbKeyConditionTerms {
+    private readonly terms;
+    constructor(terms: readonly SimDynamoDbKeyConditionTerm[]);
+    /**
+     * Read these terms against the key schema of the table the request names.
+     */
+    forTable(table: SimDynamoDbKeyConditionTable): SimDynamoDbKeyCondition;
+    /**
+     * Refuse a term naming anything but a key attribute.
+     *
+     * A query walks the primary key, so an attribute outside it has nothing to
+     * walk. Real DynamoDB refuses it rather than filtering by it, which is what
+     * `FilterExpression` is for.
+     */
+    private assertNameKeyAttributes;
+    /**
+     * The one partition key value this condition names an item collection by.
+     */
+    private partitionKeyValue;
+    /**
+     * The sort key condition, when the table has a sort key and one was written.
+     */
+    private sortKeyTerm;
+    /**
+     * The one term naming an attribute, refusing an expression naming it twice.
+     */
+    private single;
+    /**
+     * Build the refusal for a range operator applied to the partition key.
+     */
+    private partitionKeyOperatorError;
+}
+//# sourceMappingURL=sim-dynamodb-key-condition-terms.d.ts.map

package/dist/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-terms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-dynamodb-key-condition-terms.d.ts","sourceRoot":"","sources":["../../../../../src/service/dynamodb/expression/key-condition/sim-dynamodb-key-condition-terms.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACzG,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAG1E,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AAExF;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;IACzC,QAAQ,CAAC,oBAAoB,EAAE,+BAA+B,CAAC;CAChE;AAED;;;;;;;GAOG;AACH,qBAAa,4BAA4B;IACvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyC;IAE/D,YAAY,KAAK,EAAE,SAAS,2BAA2B,EAAE,EAExD;IAED;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,4BAA4B,GAAG,uBAAuB,CAYrE;IAED;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA6BzB;;OAEG;IACH,OAAO,CAAC,WAAW;IAmBnB;;OAEG;IACH,OAAO,CAAC,MAAM;IAgBd;;OAEG;IACH,OAAO,CAAC,yBAAyB;CASlC"}