Merge pull request #12 from mindler-olli/support-contains-function

Support contains function
woltsu · Mar 18, 2024 · f60af20 · f60af20
2 parents 63a388b + 8c677d5
commit f60af20
Show file tree

Hide file tree

Showing 11 changed files with 136 additions and 22 deletions.
diff --git a/README.md b/README.md
@@ -1,6 +1,6 @@
 # Tsynamo
 
-Type-safe DynamoDB query builder! Inspired by [Kysely](https://github.com/kysely-org/kysely/tree/master).
+Type-friendly DynamoDB query builder! Inspired by [Kysely](https://github.com/kysely-org/kysely/tree/master).
 
 Usable with AWS SDK v3 `DynamoDBDocumentClient`.
 

diff --git a/src/nodes/containsFunctionExpression.ts b/src/nodes/containsFunctionExpression.ts
@@ -0,0 +1,5 @@
+export type ContainsFunctionExpression = {
+  readonly kind: "ContainsFunctionExpression";
+  readonly key: string;
+  readonly value: unknown;
+};
diff --git a/src/nodes/filterExpressionJoinTypeNode.ts b/src/nodes/filterExpressionJoinTypeNode.ts
@@ -2,6 +2,7 @@ import { AttributeExistsFunctionExpression } from "./attributeExistsFunctionExpr
 import { AttributeNotExistsFunctionExpression } from "./attributeNotExistsFunctionExpression";
 import { BeginsWithFunctionExpression } from "./beginsWithFunctionExpression";
 import { BetweenConditionExpression } from "./betweenConditionExpression";
+import { ContainsFunctionExpression } from "./containsFunctionExpression";
 import { FilterExpressionComparatorExpressions } from "./filterExpressionComparatorExpression";
 import { FilterExpressionNode } from "./filterExpressionNode";
 import { FilterExpressionNotExpression } from "./filterExpressionNotExpression";
@@ -17,6 +18,7 @@ export type FilterExpressionJoinTypeNode = {
     | AttributeExistsFunctionExpression
     | AttributeNotExistsFunctionExpression
     | BetweenConditionExpression
-    | BeginsWithFunctionExpression;
+    | BeginsWithFunctionExpression
+    | ContainsFunctionExpression;
   readonly joinType: JoinType;
 };
diff --git a/src/nodes/operands.ts b/src/nodes/operands.ts
@@ -1,10 +1,11 @@
 export type BetweenExpression = "BETWEEN";
 
-// TODO: Support "contains", "size", and "attribute_type" functions
+// TODO: Support "size" and "attribute_type" functions
 export type FunctionExpression =
   | "attribute_exists"
   | "attribute_not_exists"
-  | "begins_with";
+  | "begins_with"
+  | "contains";
 
 export type NotExpression = "NOT";
 

diff --git a/src/queryBuilders/__snapshots__/queryQueryBuilder.integration.test.ts.snap b/src/queryBuilders/__snapshots__/queryQueryBuilder.integration.test.ts.snap
@@ -12,6 +12,20 @@ exports[`QueryQueryBuilder > handles a FilterExpression that takes attributes fr
 ]
 `;
 
+exports[`QueryQueryBuilder > handles a FilterExpression that uses CONTAINS function 1`] = `
+[
+  {
+    "dataTimestamp": 996,
+    "someBoolean": false,
+    "somethingElse": -9,
+    "tags": [
+      "testTag",
+    ],
+    "userId": "313",
+  },
+]
+`;
+
 exports[`QueryQueryBuilder > handles a FilterExpression that uses attribute_exists and attribute_not_exists 1`] = `
 [
   {

diff --git a/src/queryBuilders/getItemQueryBuilder.ts b/src/queryBuilders/getItemQueryBuilder.ts
@@ -1,15 +1,14 @@
-import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
 import { GetNode } from "../nodes/getNode";
+import { QueryCompiler } from "../queryCompiler";
 import {
-  DeepPartial,
+  ExecuteOutput,
   ObjectFullPaths,
   PickPk,
   PickSkRequired,
   SelectAttributes,
-  StripKeys,
 } from "../typeHelpers";
 import { preventAwait } from "../util/preventAwait";
-import { QueryCompiler } from "../queryCompiler";
 
 export interface GetQueryBuilderInterface<DDB, Table extends keyof DDB, O> {
   keys<Keys extends PickPk<DDB[Table]> & PickSkRequired<DDB[Table]>>(
@@ -22,7 +21,7 @@ export interface GetQueryBuilderInterface<DDB, Table extends keyof DDB, O> {
     attributes: A
   ): GetQueryBuilderInterface<DDB, Table, SelectAttributes<DDB[Table], A>>;
 
-  execute(): Promise<StripKeys<DeepPartial<O>> | undefined>;
+  execute(): Promise<ExecuteOutput<O> | undefined>;
 }
 
 export class GetQueryBuilder<DDB, Table extends keyof DDB, O extends DDB[Table]>
@@ -77,10 +76,10 @@ export class GetQueryBuilder<DDB, Table extends keyof DDB, O extends DDB[Table]>
     }) as any;
   }
 
-  execute = async (): Promise<StripKeys<DeepPartial<O>> | undefined> => {
+  execute = async (): Promise<ExecuteOutput<O> | undefined> => {
     const command = this.#props.queryCompiler.compile(this.#props.node);
     const item = await this.#props.ddbClient.send(command);
-    return (item.Item as StripKeys<DeepPartial<O>>) ?? undefined;
+    return (item.Item as ExecuteOutput<O>) ?? undefined;
   };
 }
 

diff --git a/src/queryBuilders/queryQueryBuilder.integration.test.ts b/src/queryBuilders/queryQueryBuilder.integration.test.ts
@@ -136,22 +136,22 @@ describe("QueryQueryBuilder", () => {
   });
 
   it("handles a FilterExpression that uses attribute_exists and attribute_not_exists", async () => {
-    let data = await tsynamoClient
+    const data = await tsynamoClient
       .query("myTable")
       .keyCondition("userId", "=", "123")
       .filterExpression("nested.nestedString", "attribute_exists")
       .execute();
 
     expect(data).toMatchSnapshot();
 
-    data = await tsynamoClient
+    const data2 = await tsynamoClient
       .query("myTable")
       .keyCondition("userId", "=", "123")
       .filterExpression("nested.nestedString", "attribute_not_exists")
       .attributes(["userId", "nested"])
       .execute();
 
-    expect(data).toMatchSnapshot();
+    expect(data2).toMatchSnapshot();
   });
 
   it("handles a FilterExpression that uses begins_with", async () => {
@@ -171,6 +171,7 @@ describe("QueryQueryBuilder", () => {
 
     expect(data).toMatchSnapshot();
   });
+
   it("handles a FilterExpression that takes attributes from cats array", async () => {
     let data = await tsynamoClient
       .query("myOtherTable")
@@ -181,4 +182,14 @@ describe("QueryQueryBuilder", () => {
 
     expect(data).toMatchSnapshot();
   });
+
+  it("handles a FilterExpression that uses CONTAINS function", async () => {
+    const data = await tsynamoClient
+      .query("myTable")
+      .keyCondition("userId", "=", "313")
+      .filterExpression("tags", "contains", "testTag")
+      .execute();
+
+    expect(data).toMatchSnapshot();
+  });
 });
diff --git a/src/queryBuilders/queryQueryBuilder.ts b/src/queryBuilders/queryQueryBuilder.ts
@@ -1,11 +1,10 @@
-import { DynamoDBDocumentClient, QueryCommand } from "@aws-sdk/lib-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
 import { AttributeExistsFunctionExpression } from "../nodes/attributeExistsFunctionExpression";
 import { AttributeNotExistsFunctionExpression } from "../nodes/attributeNotExistsFunctionExpression";
 import {
   FilterExpressionJoinTypeNode,
   JoinType,
 } from "../nodes/filterExpressionJoinTypeNode";
-import { FilterExpressionNode } from "../nodes/filterExpressionNode";
 import {
   BetweenExpression,
   FilterConditionComparators,
@@ -16,7 +15,7 @@ import {
 import { QueryNode } from "../nodes/queryNode";
 import { QueryCompiler } from "../queryCompiler";
 import {
-  DeepPartial,
+  ExecuteOutput,
   GetFromPath,
   ObjectFullPaths,
   ObjectKeyPaths,
@@ -29,7 +28,7 @@ import {
 import { preventAwait } from "../util/preventAwait";
 
 export interface QueryQueryBuilderInterface<DDB, Table extends keyof DDB, O> {
-  execute(): Promise<StripKeys<DeepPartial<O>>[] | undefined>;
+  execute(): Promise<ExecuteOutput<O>[] | undefined>;
 
   /**
    * keyCondition methods
@@ -77,13 +76,23 @@ export interface QueryQueryBuilderInterface<DDB, Table extends keyof DDB, O> {
     >
   ): QueryQueryBuilderInterface<DDB, Table, O>;
 
-  // begins_with function expression
+  // BEGINS_WITH function expression
   filterExpression<Key extends ObjectKeyPaths<PickNonKeys<DDB[Table]>>>(
     key: Key,
     expr: Extract<FunctionExpression, "begins_with">,
     substr: string
   ): QueryQueryBuilderInterface<DDB, Table, O>;
 
+  // CONTAINS function expression
+  filterExpression<
+    Key extends ObjectKeyPaths<PickNonKeys<DDB[Table]>>,
+    Property extends GetFromPath<DDB[Table], Key> & unknown[]
+  >(
+    key: Key,
+    expr: Extract<FunctionExpression, "contains">,
+    value: StripKeys<Property>[number]
+  ): QueryQueryBuilderInterface<DDB, Table, O>;
+
   // BETWEEN expression
   filterExpression<Key extends ObjectKeyPaths<PickNonKeys<DDB[Table]>>>(
     key: Key,
@@ -134,6 +143,16 @@ export interface QueryQueryBuilderInterface<DDB, Table extends keyof DDB, O> {
     substr: string
   ): QueryQueryBuilderInterface<DDB, Table, O>;
 
+  // CONTAINS function expression
+  orFilterExpression<
+    Key extends ObjectKeyPaths<PickNonKeys<DDB[Table]>>,
+    Property extends GetFromPath<DDB[Table], Key> & unknown[]
+  >(
+    key: Key,
+    expr: Extract<FunctionExpression, "contains">,
+    value: StripKeys<Property>[number]
+  ): QueryQueryBuilderInterface<DDB, Table, O>;
+
   // BETWEEN expression
   orFilterExpression<Key extends ObjectKeyPaths<PickNonKeys<DDB[Table]>>>(
     key: Key,
@@ -202,6 +221,15 @@ export interface QueryQueryBuilderInterfaceWithOnlyFilterOperations<
     substr: string
   ): QueryQueryBuilderInterfaceWithOnlyFilterOperations<DDB, Table, O>;
 
+  filterExpression<
+    Key extends ObjectKeyPaths<PickNonKeys<DDB[Table]>>,
+    Property extends GetFromPath<DDB[Table], Key> & unknown[]
+  >(
+    key: Key,
+    expr: Extract<FunctionExpression, "contains">,
+    value: StripKeys<Property>[number]
+  ): QueryQueryBuilderInterfaceWithOnlyFilterOperations<DDB, Table, O>;
+
   filterExpression<Key extends ObjectKeyPaths<PickNonKeys<DDB[Table]>>>(
     key: Key,
     expr: BetweenExpression,
@@ -245,6 +273,15 @@ export interface QueryQueryBuilderInterfaceWithOnlyFilterOperations<
     substr: string
   ): QueryQueryBuilderInterfaceWithOnlyFilterOperations<DDB, Table, O>;
 
+  orFilterExpression<
+    Key extends ObjectKeyPaths<PickNonKeys<DDB[Table]>>,
+    Property extends GetFromPath<DDB[Table], Key> & unknown[]
+  >(
+    key: Key,
+    expr: Extract<FunctionExpression, "contains">,
+    value: StripKeys<Property>[number]
+  ): QueryQueryBuilderInterfaceWithOnlyFilterOperations<DDB, Table, O>;
+
   orFilterExpression<Key extends ObjectKeyPaths<PickNonKeys<DDB[Table]>>>(
     key: Key,
     expr: BetweenExpression,
@@ -287,6 +324,11 @@ type FilterExprArgs<
       >
     ]
   | [key: Key, func: Extract<FunctionExpression, "begins_with">, substr: string]
+  | [
+      key: Key,
+      expr: Extract<FunctionExpression, "contains">,
+      value: StripKeys<GetFromPath<DDB[Table], Key>>
+    ]
   | [
       key: Key,
       expr: BetweenExpression,
@@ -421,6 +463,27 @@ export class QueryQueryBuilder<
           },
         },
       });
+    } else if (args[1] === "contains") {
+      const [key, expr, value] = args;
+
+      return new QueryQueryBuilder<DDB, Table, O>({
+        ...this.#props,
+        node: {
+          ...this.#props.node,
+          filterExpression: {
+            ...this.#props.node.filterExpression,
+            expressions: this.#props.node.filterExpression.expressions.concat({
+              kind: "FilterExpressionJoinTypeNode",
+              expr: {
+                kind: "ContainsFunctionExpression",
+                key,
+                value,
+              },
+              joinType,
+            }),
+          },
+        },
+      });
     } else if (
       args[1] === "attribute_exists" ||
       args[1] === "attribute_not_exists"
@@ -631,10 +694,10 @@ export class QueryQueryBuilder<
     }) as any;
   }
 
-  execute = async (): Promise<StripKeys<DeepPartial<O>>[] | undefined> => {
+  execute = async (): Promise<ExecuteOutput<O>[] | undefined> => {
     const command = this.#props.queryCompiler.compile(this.#props.node);
     const result = await this.#props.ddbClient.send(command);
-    return (result.Items as StripKeys<DeepPartial<O>>[]) ?? undefined;
+    return (result.Items as ExecuteOutput<O>[]) ?? undefined;
   };
 }
 

diff --git a/src/queryCompiler/queryCompiler.ts b/src/queryCompiler/queryCompiler.ts
@@ -88,7 +88,7 @@ export class QueryCompiler {
       ConsistentRead: consistentReadNode?.enabled,
       ProjectionExpression: ProjectionExpression,
       ExpressionAttributeNames:
-        attributeNames.size > 0
+        attributeNames.size > 0 || ExpressionAttributeNames
           ? {
               ...Object.fromEntries(attributeNames),
               ...ExpressionAttributeNames,
@@ -228,6 +228,12 @@ export class QueryCompiler {
         filterExpressionAttributeValues.set(attributeValue, expr.substr);
         break;
       }
+
+      case "ContainsFunctionExpression": {
+        res += `contains(${attributeName}, ${attributeValue})`;
+        filterExpressionAttributeValues.set(attributeValue, expr.value);
+        break;
+      }
     }
 
     return res;

diff --git a/src/typeHelpers.ts b/src/typeHelpers.ts
@@ -99,6 +99,11 @@ export type DeepPartial<T> = {
     ? DeepPartial<T[P]>
     : T[P];
 };
+
+export type ExecuteOutput<O> = StripKeys<
+  PickPk<O> & PickSkRequired<O> & DeepPartial<O>
+>;
+
 type IntersectionToSingleObject<T> = T extends infer U
   ? { [K in keyof U]: U[K] }
   : never;

diff --git a/test/testFixture.ts b/test/testFixture.ts
@@ -22,6 +22,7 @@ export interface DDB {
         nestedNestedBoolean: boolean;
       };
     };
+    tags: string[];
   };
   myOtherTable: {
     userId: PartitionKey<string>;
@@ -216,4 +217,11 @@ export const TEST_DATA = [
       },
     },
   },
+  {
+    userId: "313",
+    dataTimestamp: 996,
+    somethingElse: -9,
+    someBoolean: false,
+    tags: ["testTag"],
+  },
 ] as const;