@model-ts/dynamodb 4.1.0 → 4.2.1

package/src/__test__/in-memory.spec.test.ts

@@ -0,0 +1,283 @@
+import * as t from "io-ts"
+import { model } from "@model-ts/core"
+import { Client } from "../client"
+import { getProvider } from "../provider"
+import { createSandbox, Sandbox } from "../sandbox"
+import { NotSupportedError } from "../errors"
+import { IN_MEMORY_SPEC } from "../in-memory/spec"
+
+const CODEC = t.type({
+  id: t.string,
+  group: t.string,
+  value: t.number,
+})
+
+const withInMemory = async <T>(
+  run: (ctx: {
+    client: Client
+    sandbox: Sandbox
+    Item: any
+  }) => Promise<T>
+): Promise<T> => {
+  const previous = process.env.EXPERIMENTAL_DYNAMODB_IN_MEMORY
+  process.env.EXPERIMENTAL_DYNAMODB_IN_MEMORY = "1"
+
+  const client = new Client({ tableName: "table" })
+  const provider = getProvider(client)
+
+  class Item extends model("Item", CODEC, provider) {
+    get PK() {
+      return `PK#${this.group}`
+    }
+
+    get SK() {
+      return `SK#${String(this.value).padStart(3, "0")}`
+    }
+
+    get GSI2PK() {
+      return `GSI2PK#${this.group}`
+    }
+
+    get GSI2SK() {
+      return `GSI2SK#${this.id}`
+    }
+  }
+
+  const sandbox = await createSandbox(client)
+
+  try {
+    return await run({ client, sandbox, Item })
+  } finally {
+    await sandbox.destroy()
+
+    if (typeof previous === "undefined")
+      delete process.env.EXPERIMENTAL_DYNAMODB_IN_MEMORY
+    else process.env.EXPERIMENTAL_DYNAMODB_IN_MEMORY = previous
+  }
+}
+
+describe("in-memory spec", () => {
+  test("locks projection and index scope", () => {
+    expect(IN_MEMORY_SPEC.projection).toBe("ALL")
+    expect(IN_MEMORY_SPEC.excludedIndexes).toEqual(["GSI1"])
+    expect(IN_MEMORY_SPEC.indexes.includes("primary")).toBe(true)
+    expect(IN_MEMORY_SPEC.indexes.includes("GSI2")).toBe(true)
+    expect(IN_MEMORY_SPEC.indexes.includes("GSI19")).toBe(true)
+    expect(IN_MEMORY_SPEC.indexes.includes("GSI1" as any)).toBe(false)
+  })
+
+  test("throws deterministic NotSupportedError for unsupported method", async () => {
+    await withInMemory(async ({ client }) => {
+      await expect(
+        (client.documentClient as any).transactGet({}).promise()
+      ).rejects.toMatchObject({
+        name: "NotSupportedError",
+        code: "NotSupportedError",
+        method: "transactGet",
+        featurePath: "transactGet",
+      })
+    })
+  })
+
+  test("rejects GSI1 with deterministic NotSupportedError", async () => {
+    await withInMemory(async ({ client, Item }) => {
+      await new Item({ id: "1", group: "g", value: 1 }).put()
+
+      await expect(
+        client.documentClient
+          .query({
+            TableName: client.tableName,
+            IndexName: "GSI1",
+            KeyConditionExpression: "PK = :pk",
+            ExpressionAttributeValues: { ":pk": "PK#g" },
+          })
+          .promise()
+      ).rejects.toMatchObject({
+        name: "NotSupportedError",
+        code: "NotSupportedError",
+        method: "query",
+        featurePath: "query.IndexName",
+      })
+    })
+  })
+
+  test("keeps GSI membership in sync after update/removal", async () => {
+    await withInMemory(async ({ client, Item }) => {
+      const item = await new Item({ id: "42", group: "test", value: 42 }).put()
+
+      const before = await client.documentClient
+        .query({
+          TableName: client.tableName,
+          IndexName: "GSI2",
+          KeyConditionExpression: "GSI2PK = :pk",
+          ExpressionAttributeValues: { ":pk": "GSI2PK#test" },
+        })
+        .promise()
+
+      expect(before.Count).toBe(1)
+
+      await Item.updateRaw(
+        { PK: item.PK, SK: item.SK },
+        { GSI2PK: null, GSI2SK: null } as any
+      )
+
+      const after = await client.documentClient
+        .query({
+          TableName: client.tableName,
+          IndexName: "GSI2",
+          KeyConditionExpression: "GSI2PK = :pk",
+          ExpressionAttributeValues: { ":pk": "GSI2PK#test" },
+        })
+        .promise()
+
+      expect(after.Count).toBe(0)
+    })
+  })
+
+  test("supports if_not_exists in update expressions", async () => {
+    await withInMemory(async ({ client, Item }) => {
+      const item = await new Item({ id: "100", group: "expr", value: 1 }).put()
+
+      const first = await client.documentClient
+        .update({
+          TableName: client.tableName,
+          Key: { PK: item.PK, SK: item.SK },
+          UpdateExpression: "SET #count = if_not_exists(#count, :zero) + :inc",
+          ExpressionAttributeNames: { "#count": "count" },
+          ExpressionAttributeValues: { ":zero": 0, ":inc": 2 },
+          ReturnValues: "ALL_NEW",
+        })
+        .promise()
+
+      expect(first.Attributes?.count).toBe(2)
+
+      const second = await client.documentClient
+        .update({
+          TableName: client.tableName,
+          Key: { PK: item.PK, SK: item.SK },
+          UpdateExpression: "SET #count = if_not_exists(#count, :zero) + :inc",
+          ExpressionAttributeNames: { "#count": "count" },
+          ExpressionAttributeValues: { ":zero": 0, ":inc": 3 },
+          ReturnValues: "ALL_NEW",
+        })
+        .promise()
+
+      expect(second.Attributes?.count).toBe(5)
+    })
+  })
+
+  test("supports list_append and filter functions", async () => {
+    await withInMemory(async ({ client, Item }) => {
+      const item = await new Item({ id: "200", group: "expr", value: 2 }).put()
+
+      await client.documentClient
+        .update({
+          TableName: client.tableName,
+          Key: { PK: item.PK, SK: item.SK },
+          UpdateExpression:
+            "SET #tags = list_append(if_not_exists(#tags, :empty), :more)",
+          ExpressionAttributeNames: { "#tags": "tags" },
+          ExpressionAttributeValues: { ":empty": [], ":more": ["a", "b"] },
+          ReturnValues: "ALL_NEW",
+        })
+        .promise()
+
+      const filtered = await client.documentClient
+        .scan({
+          TableName: client.tableName,
+          FilterExpression:
+            "contains(#tags, :tag) and attribute_type(#id, :t) and size(#id) > :min",
+          ExpressionAttributeNames: { "#tags": "tags", "#id": "id" },
+          ExpressionAttributeValues: { ":tag": "a", ":t": "S", ":min": 1 },
+        })
+        .promise()
+
+      expect(filtered.Count).toBe(1)
+      expect(filtered.Items?.[0]?.id).toBe("200")
+    })
+  })
+
+  test("supports document paths with list indexes in condition expressions", async () => {
+    await withInMemory(async ({ client }) => {
+      await client.documentClient
+        .put({
+          TableName: client.tableName,
+          Item: {
+            PK: "PK#expr",
+            SK: "SK#300",
+            id: "300",
+            group: "expr",
+            value: 3,
+            tenancy: {
+              mailboxes: [{ inboxId: "inbox-1" }],
+            },
+          },
+        })
+        .promise()
+
+      const updated = await client.documentClient
+        .update({
+          TableName: client.tableName,
+          Key: { PK: "PK#expr", SK: "SK#300" },
+          ConditionExpression: "tenancy.mailboxes[0].inboxId = :inboxId",
+          UpdateExpression: "SET #value = :next",
+          ExpressionAttributeNames: { "#value": "value" },
+          ExpressionAttributeValues: { ":inboxId": "inbox-1", ":next": 4 },
+          ReturnValues: "ALL_NEW",
+        })
+        .promise()
+
+      expect(updated.Attributes?.value).toBe(4)
+
+      const updatedWithNames = await client.documentClient
+        .update({
+          TableName: client.tableName,
+          Key: { PK: "PK#expr", SK: "SK#300" },
+          ConditionExpression: "#tenancy.#mailboxes[0].#inboxId = :inboxId",
+          UpdateExpression: "SET #value = :next",
+          ExpressionAttributeNames: {
+            "#value": "value",
+            "#tenancy": "tenancy",
+            "#mailboxes": "mailboxes",
+            "#inboxId": "inboxId",
+          },
+          ExpressionAttributeValues: { ":inboxId": "inbox-1", ":next": 5 },
+          ReturnValues: "ALL_NEW",
+        })
+        .promise()
+
+      expect(updatedWithNames.Attributes?.value).toBe(5)
+    })
+  })
+
+  test("is deterministic for repeated seeded runs", async () => {
+    const execute = async () =>
+      withInMemory(async ({ client, sandbox, Item }) => {
+        const order = [7, 1, 9, 2, 8, 3, 6, 4, 5, 0]
+
+        await Promise.all(
+          order.map((value) =>
+            new Item({ id: String(value), group: "det", value }).put()
+          )
+        )
+
+        const page = await client.documentClient
+          .query({
+            TableName: client.tableName,
+            KeyConditionExpression: "PK = :pk",
+            ExpressionAttributeValues: { ":pk": "PK#det" },
+          })
+          .promise()
+
+        return {
+          snapshot: await sandbox.snapshot(),
+          queryKeys: (page.Items ?? []).map((entry) => `${entry.PK}::${entry.SK}`),
+        }
+      })
+
+    const first = await execute()
+    const second = await execute()
+
+    expect(second).toEqual(first)
+  })
+})

package/src/client.ts

@@ -44,6 +44,7 @@ import {
   PaginationResult,
 } from "./pagination"
 import { GSI, GSI_NAMES, GSIPK, GSISK } from "./gsi"
+import { createInMemoryDocumentClient } from "./in-memory"
 
 export type QueryParams = Omit<
   DocumentClient.QueryInput,
@@ -110,7 +111,18 @@ export class Client {
     this.tableName = props?.tableName
     this.cursorEncryptionKey = props?.cursorEncryptionKey
     this.paginationOptions = props?.paginationOptions
-    this.documentClient = new DocumentClient(props)
+
+    const inMemoryRequested = process.env.EXPERIMENTAL_DYNAMODB_IN_MEMORY === "1"
+    if (inMemoryRequested && process.env.NODE_ENV !== "test") {
+      throw new Error(
+        `EXPERIMENTAL_DYNAMODB_IN_MEMORY=1 is only allowed when NODE_ENV is "test" (received "${process.env.NODE_ENV ?? "undefined"}").`
+      )
+    }
+
+    this.documentClient =
+      inMemoryRequested
+        ? (createInMemoryDocumentClient() as any as DocumentClient)
+        : new DocumentClient(props)
     this.dataLoader = new DataLoader<
       GetOperation<Decodable>,
       DynamoDBModelInstance,
@@ -160,6 +172,7 @@ export class Client {
     M extends DynamoDBModelConstructor<T>
   >({
     _model,
+    _operation,
     _deleted,
     item,
     IgnoreExistence,
@@ -200,6 +213,7 @@ export class Client {
 
   async get<M extends Decodable>({
     _model,
+    _operation,
     key,
     ...params
   }: GetOperation<M>): Promise<DecodableInstance<M>> {
@@ -272,7 +286,7 @@ export class Client {
   async updateRaw<M extends DynamoDBModelConstructor<any>>(
     operation: UpdateRawOperation<M>
   ): Promise<InstanceType<M>> {
-    const { _model, key, attributes, ...params } = operation
+    const { _model, _operation, key, attributes, ...params } = operation
 
     const {
       UpdateExpression,
@@ -831,8 +845,7 @@ export class Client {
   ): DocumentClient.TransactWriteItem => {
     switch (operation._operation) {
       case "put": {
-        const { _model, _deleted, item, IgnoreExistence, ...params } = operation
-        debugger
+        const { _model, _operation, _deleted, item, IgnoreExistence, ...params } = operation
         const encoded = (_model as M & DynamoDBInternals<M>).__dynamoDBEncode(
           item
         )

package/src/errors.ts

@@ -45,6 +45,29 @@ export class PaginationError extends Error {
   name = "PaginationError"
 }
 
+export class NotSupportedError extends Error {
+  name = "NotSupportedError"
+  code = "NotSupportedError"
+  method: string
+  featurePath: string
+  reason: string
+
+  constructor({
+    method,
+    featurePath,
+    reason,
+  }: {
+    method: string
+    featurePath: string
+    reason: string
+  }) {
+    super(reason)
+    this.method = method
+    this.featurePath = featurePath
+    this.reason = reason
+  }
+}
+
 export type DynamoDBError =
   | KeyExistsError
   | ItemNotFoundError
@@ -52,3 +75,4 @@ export type DynamoDBError =
   | BulkWriteTransactionError
   | BulkWriteRollbackError
   | PaginationError
+  | NotSupportedError