feature: Indexes with sort keys

Add the ability to add sort keys to indexes and querying with those
sort keys as well.

.gitignore

@@ -10,3 +10,4 @@ coverage/
 .tern-port
 lib
 .npmrc
+.vscode

README.md

@@ -302,6 +302,8 @@ indexes.
 Indexes should be created as a part of your table creation but need to be defined with Omanyd so
 they can be used at run time correctly.
 
+Indexes must have a hash key but can also have a sort key.
+
 ```ts
 import Omanyd from "omanyd";
 import Joi from "joi";

src/index.test.ts

@@ -737,6 +737,117 @@ describe("omanyd", () => {
       ).rejects.toThrow(/No index found with name: 'ValueIndex'/);
     });
   });
+  describe("index with sort keys", () => {
+    it("should be able to define and retrieve by that index", async () => {
+      interface Thing {
+        id: string;
+        email: string;
+        anotherField: string;
+      }
+      const ThingStore = Omanyd.define<Thing>({
+        name: "indexSKQuery",
+        hashKey: "id",
+        schema: Joi.object({
+          id: Omanyd.types.id(),
+          email: Joi.string().required(),
+          anotherField: Joi.string().required(),
+        }),
+        indexes: [
+          {
+            name: "ValueIndex",
+            type: "global",
+            hashKey: "email",
+            sortKey: "anotherField",
+          },
+        ],
+      });
+
+      await Omanyd.createTables();
+
+      const savedItem1 = await ThingStore.create({
+        email: "hello@world.com",
+        anotherField: "1",
+      });
+      const savedItem2 = await ThingStore.create({
+        email: "hello@world.com",
+        anotherField: "2",
+      });
+
+      const readItem1 = await ThingStore.getByIndex(
+        "ValueIndex",
+        "hello@world.com",
+        "1"
+      );
+
+      const readItem2 = await ThingStore.getByIndex(
+        "ValueIndex",
+        "hello@world.com",
+        "2"
+      );
+
+      expect(savedItem1).toStrictEqual(readItem1);
+      expect(savedItem2).toStrictEqual(readItem2);
+
+      expect(savedItem1).not.toStrictEqual(readItem2);
+      expect(savedItem2).not.toStrictEqual(readItem1);
+    });
+
+    it("should return null if the item is not found", async () => {
+      interface Thing {
+        id: string;
+        email: string;
+        anotherField: string;
+      }
+      const ThingStore = Omanyd.define<Thing>({
+        name: "indexSKQueryNotFound",
+        hashKey: "id",
+        schema: Joi.object({
+          id: Omanyd.types.id(),
+          email: Joi.string().required(),
+          anotherField: Joi.string().required(),
+        }),
+        indexes: [
+          {
+            name: "ValueIndex",
+            type: "global",
+            hashKey: "email",
+            sortKey: "anotherField",
+          },
+        ],
+      });
+
+      await Omanyd.createTables();
+
+      const readItem = await ThingStore.getByIndex(
+        "ValueIndex",
+        "hello@world.com",
+        "1"
+      );
+
+      expect(readItem).toBeNull();
+    });
+
+    it("should throw if the index does not exist", async () => {
+      interface Thing {
+        id: string;
+        email: string;
+      }
+      const ThingStore = Omanyd.define<Thing>({
+        name: "indexSKNotDefined",
+        hashKey: "id",
+        schema: Joi.object({
+          id: Omanyd.types.id(),
+          email: Joi.string().required(),
+        }),
+      });
+
+      await Omanyd.createTables();
+
+      await expect(async () =>
+        ThingStore.getByIndex("ValueIndex", "hello@world.com")
+      ).rejects.toThrow(/No index found with name: 'ValueIndex'/);
+    });
+  });
 
   describe("clearTables", () => {
     it("should clear all the data in the existing tables", async () => {

src/index.ts

@@ -75,8 +75,12 @@ export function define<T>(options: Options) {
       return validated as unknown[] as T[];
     },
 
-    async getByIndex(name: string, hashKey: string): Promise<T | null> {
-      const res = await t.getByIndex(name, hashKey);
+    async getByIndex(
+      name: string,
+      hashKey: string,
+      sortKey?: string
+    ): Promise<T | null> {
+      const res = await t.getByIndex(name, hashKey, sortKey);
       if (res === null) {
         return res;
       }

src/table.ts

@@ -40,6 +40,9 @@ export default class Table {
             AttributeName: index.hashKey,
             KeyType: "HASH",
           },
+          ...(index.sortKey
+            ? [{ AttributeName: index.sortKey, KeyType: "RANGE" }]
+            : []),
         ],
         Projection: {
           ProjectionType: "ALL",
@@ -55,10 +58,21 @@ export default class Table {
     ];
 
     if (this.options.indexes) {
-      const indexDefinitions = this.options.indexes.map((index) => ({
-        AttributeName: index.hashKey,
-        AttributeType: "S",
-      }));
+      const indexDefinitions = this.options.indexes.flatMap((index) => {
+        const indexDefinitions = [
+          {
+            AttributeName: index.hashKey,
+            AttributeType: "S",
+          },
+        ];
+        if (index.sortKey) {
+          indexDefinitions.push({
+            AttributeName: index.sortKey,
+            AttributeType: "S",
+          });
+        }
+        return indexDefinitions;
+      });
       attributeDefinitions = attributeDefinitions.concat(indexDefinitions);
     }
 
@@ -248,28 +262,48 @@ export default class Table {
 
   async getByIndex(
     indexName: string,
-    value: string
+    hashKey: string,
+    sortKey?: string
   ): Promise<PlainObject | null> {
     const indexDefintion = (this.options.indexes ?? []).find(
       (index) => index.name === indexName
     );
     if (!indexDefintion) {
       throw new Error(`No index found with name: '${indexName}'`);
     }
+    if (sortKey && !indexDefintion.sortKey) {
+      throw new Error("Index does not have a sort key but one was provided");
+    }
+    if (!sortKey && indexDefintion.sortKey) {
+      throw new Error("Index has a sort key but one was not provided");
+    }
+
+    const keyConditionExpression = [`${indexDefintion.hashKey} = :hashKey`];
+    if (sortKey) {
+      keyConditionExpression.push(`${indexDefintion.sortKey} = :sortKey`);
+    }
+
     return new Promise((res, rej) => {
       this.dynamoDB.query(
         {
           TableName: this.options.name,
           IndexName: indexDefintion.name,
-          KeyConditionExpression: `${indexDefintion.hashKey} = :hashKey`,
+          KeyConditionExpression: keyConditionExpression.join(" AND "),
           ExpressionAttributeValues: {
             ":hashKey": this.serializer.toDynamoValue(
-              value,
+              hashKey,
               getItemSchemaFromObjectSchema(
                 this.options.schema,
                 indexDefintion.hashKey
               )
             )!,
+            ":sortKey": this.serializer.toDynamoValue(
+              sortKey,
+              getItemSchemaFromObjectSchema(
+                this.options.schema,
+                indexDefintion.sortKey!
+              )
+            )!,
           },
         },
         (err, data) => {

src/types.ts

@@ -23,6 +23,7 @@ export interface Options {
     name: string;
     type: "global";
     hashKey: string;
+    sortKey?: string;
   }[];
   allowNameClash?: boolean;
 }