@nikovirtala/typesafe-dynamodb 0.0.0 → 0.0.2

package/README.md

@@ -1,32 +1,30 @@
-# typesafe-dynamodb
+# @nikovirtala/typesafe-dynamodb
 
-[![npm version](https://badge.fury.io/js/typesafe-dynamodb.svg)](https://badge.fury.io/js/typesafe-dynamodb)
+[![npm version](https://badge.fury.io/js/@nikovirtala%2Ftypesafe-dynamodb.svg)](https://badge.fury.io/js/@nikovirtala%2Ftypesafe-dynamodb)
 
-`typesafe-dynamodb` is a type-only library which replaces the type signatures of the AWS SDK's DynamoDB client. It substitutes `getItem`, `putItem`, `deleteItem` and `query` API methods with type-safe alternatives that are aware of the data in your tables and also adaptive to the semantics of the API request, e.g. by validating `ExpressionAttributeNames` and `ExpressionAttributeValues` contain all the values used in a `ConditionExpression` string, or by understanding the effect of a `ProjectionExpression` on the returned data type.
+`@nikovirtala/typesafe-dynamodb` is a fork of `typesafe-dynamodb` (a type-only library which replaces the type signatures of the AWS SDK v3's DynamoDB client) with schema validation based on [zod](https://zod.dev).
 
-The end goal is to provide types that have total understanding of the AWS DynamoDB API and enable full utilization of the TypeScript type system for modeling complex DynamoDB tables, such as the application of union types and template string literals for single-table designs.
+It substitutes `getItem`, `putItem`, `deleteItem` and `query` API methods with type-safe and schema validated alternatives that are aware of the data in your tables and also adaptive to the semantics of the API request, e.g. by validating `ExpressionAttributeNames` and `ExpressionAttributeValues` contain all the values used in a `ConditionExpression` string, or by understanding the effect of a `ProjectionExpression` on the returned data type.
+
+The end goal is to provide types and validation that have total understanding of the AWS DynamoDB API and enable full utilization of the TypeScript type system for modeling complex DynamoDB Tables, such as the application of union types and template string literals for single-table designs without forgetting runtime safety.
 
 ![typesafe putItem ConditionExpression](img/put-item-expression.gif)
 
 ## Installation
 
 ```
-npm install --save-dev typesafe-dynamodb
+npm install --save-dev @nikovirtala/typesafe-dynamodb
 ```
 
 ## Usage
 
-This library contains type definitions for both AWS SDK v2 (`aws-sdk`) and AWS SDK v3 (`@aws-sdk/client-dynamodb`);
-
-### AWS SDK v2
+This library contains type definitions for AWS SDK v3 (`@aws-sdk/client-dynamodb`).
 
-To use `typesafe-dynamodb` with the AWS SDK v2, there is no need to change anything about your existing runtime code. It is purely type definitions, so you only need to cast an instance of `AWS.DynamoDB` to the `TypeSafeDynamoDBv2<T, HashKey, RangeKey>` interface and use the client as normal, except now you can enjoy a dynamic, type-safe experience in your IDE instead.
+### AWS SDK v3
 
-```ts
-import { DynamoDB } from "aws-sdk";
+#### Option 1 - DynamoDB
 
-const client = new DynamoDB();
-```
+`DynamoDB` is a convenient way of using the DynamoDB API, except it is not optimized for tree-shaking (for that, see Option 2).
 
 Start by declaring a standard TypeScript interface which describes the structure of data in your DynamoDB Table:
 
@@ -40,25 +38,7 @@ interface Record {
 }
 ```
 
-Then, cast the `DynamoDB` client instance to `TypeSafeDynamoDB`;
-
-```ts
-import { TypeSafeDynamoDBv2 } from "typesafe-dynamodb/lib/client-v2";
-
-const typesafeClient: TypeSafeDynamoDBv2<Record, "key", "sort"> = client;
-```
-
-`"key"` is the name of the Hash Key attribute, and `"sort"` is the name of the Range Key attribute.
-
-Finally, use the client as you normally would, except now with intelligent type hints and validations.
-
-### AWS SDK v3
-
-#### Option 1 - DynamoDB (similar to SDK v2)
-
-`DynamoDB` is an almost identical implementation to the AWS SDK v2, except with minor changes such as returning a `Promise` by default. It is a convenient way of using the DynamoDB API, except it is not optimized for tree-shaking (for that, see Option 2).
-
-To override the types, follow a similar method to v2, except by importing TypeSafeDynamoDBv3 (instead of v2):
+Then, cast the `DynamoDB` client instance to `TypeSafeDynamoDBv3`:
 
 ```ts
 import { DynamoDB } from "@aws-sdk/client-dynamodb";
@@ -68,6 +48,10 @@ const client = new DynamoDB({..});
 const typesafeClient: TypeSafeDynamoDBv3<Record, "key", "sort"> = client;
 ```
 
+`"key"` is the name of the Hash Key attribute, and `"sort"` is the name of the Range Key attribute.
+
+Finally, use the client as you normally would, except now with intelligent type hints and validations.
+
 #### Option 2 - DynamoDBClient (a Command-Response interface optimized for tree-shaking)
 
 `DynamoDBClient` is a generic interface with a single method, `send`. To invoke an API, call `send` with an instance of the API's corresponding `Command`.
@@ -96,26 +80,7 @@ await client.send(
 
 ### Document Client
 
-Both the AWS SDK v2 and v3 provide a javascript-friendly interface called the `DocumentClient`. Instead of using the AttributeValue format, such as `{ S: "hello" }` or `{ N: "123" }`, the `DocumentClient` enables you to use native javascript types, e.g. `"hello"` or `123`.
-
-#### AWS SDK V2
-
-For the SDK V2 client, cast it to `TypeSafeDocumentClientV2`.
-
-See: https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html
-
-```ts
-import { DynamoDB } from "aws-sdk";
-import { TypeSafeDocumentClientV2 } from "typesafe-dynamodb/lib/document-client-v2";
-
-const table = new DynamoDB.DocumentClient() as TypeSafeDocumentClientV2<
-  MyItem,
-  "pk",
-  "sk"
->;
-```
-
-#### AWS SDK V3
+The AWS SDK v3 provides a javascript-friendly interface called the `DocumentClient`. Instead of using the AttributeValue format, such as `{ S: "hello" }` or `{ N: "123" }`, the `DocumentClient` enables you to use native javascript types, e.g. `"hello"` or `123`.
 
 When defining your Command types, use the corresponding `TypeSafe*DocumentCommand` type, for example `TypeSafeGetDocumentCommand` instead of `TypeSafeGetItemCommand`:
 
@@ -135,7 +100,7 @@ import { TypeSafeGetDocumentCommand } from "typesafe-dynamodb/lib/get-document-c
 const MyGetItemCommand = TypeSafeGetDocumentCommand<MyType, "key", "sort">();
 ```
 
-For the SDK V3 client, cast it to `TypeSafeDynamoDBv3`.
+For the SDK V3 client, cast it to `TypeSafeDocumentClientV3`:
 
 ```ts
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
@@ -145,7 +110,7 @@ import { TypeSafeDocumentClientV3 } from "typesafe-dynamodb/lib/document-client-
 const client = new DynamoDBClient({});
 
 const docClient = DynamoDBDocumentClient.from(
-  client
+  client,
 ) as TypeSafeDocumentClientV3<MyType, "key", "sort">;
 ```
 
@@ -171,7 +136,7 @@ Same for the `Item` in the response:
 
 ### Single Table Design
 
-Below are two `interface` declarations, representing two types of data stored in a single DynamoDB table - `User` and `Order`. Single table design in DynamoDB is achieved by creating "composite keys", e.g. `USER#${UserID}`. In TypeScript, we use template literal types to encode this in the Type System.
+Below are two `interface` declarations, representing two types of data stored in a single DynamoDB Table - `User` and `Order`. Single table design in DynamoDB is achieved by creating "composite keys", e.g. `USER#${UserID}`. In TypeScript, we use template literal types to encode this in the Type System.
 
 ```ts
 interface User<UserID extends string = string> {
@@ -186,7 +151,7 @@ interface User<UserID extends string = string> {
 
 interface Order<
   UserID extends string = string,
-  OrderID extends string = string
+  OrderID extends string = string,
 > {
   PK: `USER#${UserID}`;
   SK: `ORDER#${OrderID}`;
@@ -224,6 +189,41 @@ export async function handle(
 
 The event's type is derived from the data type and the the `StreamViewType`, e.g. `"NEW_IMAGE" | "OLD_IMAGE" | "KEYS_ONLY" | "NEW_AND_OLD_IMAGES"`.
 
+### Schema-Validated DynamoDBStreamEvent
+
+Validate DynamoDB stream events at runtime using Zod schemas:
+
+```ts
+import { z } from "zod";
+import { validateStreamEvent } from "typesafe-dynamodb";
+import type { DynamoDBStreamEvent } from "typesafe-dynamodb/lib/stream-event";
+
+const UserSchema = z.object({
+  PK: z.string(),
+  SK: z.string(),
+  name: z.string(),
+  email: z.string().email(),
+});
+
+type User = z.infer<typeof UserSchema>;
+
+export async function handle(
+  event: DynamoDBStreamEvent<User, "PK", "SK", "NEW_AND_OLD_IMAGES">,
+) {
+  try {
+    const validatedEvent = validateStreamEvent(event, UserSchema);
+    // Process validated stream records
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error("Schema validation failed:", error.issues);
+    }
+    throw error;
+  }
+}
+```
+
+The `validateStreamEvent` function validates both `NewImage` and `OldImage` data against your Zod schema, ensuring runtime type safety for your stream processing logic.
+
 ### Filter result with ProjectionExpression
 
 The `ProjectionExpression` field is parsed and applied to filter the returned type of `getItem` and `query`.

package/examples/schema-validated-delete-document.ts

@@ -0,0 +1,63 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { z } from "zod";
+import { SchemaValidatedDocumentClient } from "../src/schema-validated-document-client";
+import { SchemaValidatedDeleteDocumentCommand } from "../src/schema-validated-delete-document-command";
+
+const UserSchema = z.object({
+  pk: z.templateLiteral(["USER", "#", z.uuid()]),
+  sk: z.literal("METADATA"),
+  userId: z.string(),
+  email: z.string().email(),
+  name: z.string(),
+  age: z.number().min(0),
+  preferences: z.object({
+    theme: z.enum(["light", "dark"]),
+    notifications: z.boolean(),
+  }),
+});
+
+type User = z.infer<typeof UserSchema>;
+
+const client = new DynamoDBClient({ region: "eu-west-1" });
+const documentClient = DynamoDBDocumentClient.from(client);
+const schemaValidatedDocumentClient = new SchemaValidatedDocumentClient(
+  documentClient,
+);
+
+const DeleteUserCommand = SchemaValidatedDeleteDocumentCommand<
+  User,
+  "pk",
+  "sk"
+>(UserSchema);
+
+async function deleteUserDocumentExample() {
+  try {
+    const result = await schemaValidatedDocumentClient.send(
+      new DeleteUserCommand({
+        TableName: "Users",
+        Key: {
+          pk: "USER#00000000-0000-0000-0000-000000000000",
+          sk: "METADATA",
+        },
+        ConditionExpression: "attribute_exists(pk)",
+        ReturnValues: "ALL_OLD",
+      }),
+      UserSchema,
+    );
+
+    if (result.Attributes) {
+      console.log("Deleted user:", result.Attributes);
+      return result.Attributes;
+    }
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error("Schema validation failed:", error.issues);
+    } else {
+      console.error("DynamoDB error:", error);
+    }
+    throw error;
+  }
+}
+
+export { deleteUserDocumentExample, UserSchema };

package/examples/schema-validated-get-document.ts

@@ -0,0 +1,59 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { z } from "zod";
+import { SchemaValidatedDocumentClient } from "../src/schema-validated-document-client";
+import { SchemaValidatedGetDocumentCommand } from "../src/schema-validated-get-document-command";
+
+const UserSchema = z.object({
+  pk: z.templateLiteral(["USER", "#", z.uuid()]),
+  sk: z.literal("METADATA"),
+  userId: z.string(),
+  email: z.string().email(),
+  name: z.string(),
+  age: z.number().min(0),
+  preferences: z.object({
+    theme: z.enum(["light", "dark"]),
+    notifications: z.boolean(),
+  }),
+});
+
+type User = z.infer<typeof UserSchema>;
+
+const client = new DynamoDBClient({ region: "eu-west-1" });
+const documentClient = DynamoDBDocumentClient.from(client);
+const schemaValidatedDocumentClient = new SchemaValidatedDocumentClient(
+  documentClient,
+);
+
+const GetUserCommand = SchemaValidatedGetDocumentCommand<User, "pk", "sk">(
+  UserSchema,
+);
+
+async function getUserDocumentExample() {
+  try {
+    const result = await schemaValidatedDocumentClient.send(
+      new GetUserCommand({
+        TableName: "Users",
+        Key: {
+          pk: "USER#00000000-0000-0000-0000-000000000000",
+          sk: "METADATA",
+        },
+      }),
+      UserSchema,
+    );
+
+    if (result.Item) {
+      console.log("Validated user:", result.Item);
+      return result.Item;
+    }
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error("Schema validation failed:", error.issues);
+    } else {
+      console.error("DynamoDB error:", error);
+    }
+    throw error;
+  }
+}
+
+export { getUserDocumentExample, UserSchema };

package/examples/schema-validated-put-document.ts

@@ -0,0 +1,64 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { z } from "zod";
+import { SchemaValidatedDocumentClient } from "../src/schema-validated-document-client";
+import { SchemaValidatedPutDocumentCommand } from "../src/schema-validated-put-document-command";
+
+const UserSchema = z.object({
+  pk: z.templateLiteral(["USER", "#", z.uuid()]),
+  sk: z.literal("METADATA"),
+  userId: z.string(),
+  email: z.string().email(),
+  name: z.string(),
+  age: z.number().min(0),
+  preferences: z.object({
+    theme: z.enum(["light", "dark"]),
+    notifications: z.boolean(),
+  }),
+});
+
+type User = z.infer<typeof UserSchema>;
+
+const client = new DynamoDBClient({ region: "eu-west-1" });
+const documentClient = DynamoDBDocumentClient.from(client);
+const schemaValidatedDocumentClient = new SchemaValidatedDocumentClient(
+  documentClient,
+);
+
+const PutUserCommand = SchemaValidatedPutDocumentCommand<User>(UserSchema);
+
+async function putUserDocumentExample() {
+  try {
+    const result = await schemaValidatedDocumentClient.send(
+      new PutUserCommand({
+        TableName: "Users",
+        Item: {
+          pk: "USER#00000000-0000-0000-0000-000000000000",
+          sk: "METADATA",
+          userId: "user123",
+          email: "user@example.com",
+          name: "John Doe",
+          age: 30,
+          preferences: {
+            theme: "dark",
+            notifications: true,
+          },
+        },
+        ConditionExpression: "attribute_not_exists(pk)",
+      }),
+      UserSchema,
+    );
+
+    console.log("User created successfully:", result);
+    return result;
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error("Schema validation failed:", error.issues);
+    } else {
+      console.error("DynamoDB error:", error);
+    }
+    throw error;
+  }
+}
+
+export { putUserDocumentExample, UserSchema };

package/examples/schema-validated-query-document.ts

@@ -0,0 +1,69 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { z } from "zod";
+import { SchemaValidatedDocumentClient } from "../src/schema-validated-document-client";
+import { SchemaValidatedQueryDocumentCommand } from "../src/schema-validated-query-document-command";
+
+const OrderSchema = z.object({
+  pk: z.templateLiteral(["USER", "#", z.uuid()]),
+  sk: z.templateLiteral(["ORDER", "#", z.string()]),
+  userId: z.string(),
+  orderId: z.string(),
+  status: z.enum(["PLACED", "SHIPPED", "DELIVERED"]),
+  amount: z.number().min(0),
+  items: z.array(
+    z.object({
+      productId: z.string(),
+      quantity: z.number().min(1),
+      price: z.number().min(0),
+    }),
+  ),
+  createdAt: z.string().datetime(),
+});
+
+type Order = z.infer<typeof OrderSchema>;
+
+const client = new DynamoDBClient({ region: "eu-west-1" });
+const documentClient = DynamoDBDocumentClient.from(client);
+const schemaValidatedDocumentClient = new SchemaValidatedDocumentClient(
+  documentClient,
+);
+
+const QueryOrdersCommand =
+  SchemaValidatedQueryDocumentCommand<Order>(OrderSchema);
+
+async function queryUserOrdersExample() {
+  try {
+    const result = await schemaValidatedDocumentClient.send(
+      new QueryOrdersCommand({
+        TableName: "Orders",
+        KeyConditionExpression:
+          "pk = :userId AND begins_with(sk, :orderPrefix)",
+        FilterExpression: "#status = :status",
+        ExpressionAttributeNames: {
+          "#status": "status",
+        },
+        ExpressionAttributeValues: {
+          ":userId": "USER#00000000-0000-0000-0000-000000000000",
+          ":orderPrefix": "ORDER#",
+          ":status": "SHIPPED",
+        },
+      }),
+      OrderSchema,
+    );
+
+    if (result.Items) {
+      console.log("Validated orders:", result.Items);
+      return result.Items;
+    }
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error("Schema validation failed:", error.issues);
+    } else {
+      console.error("DynamoDB error:", error);
+    }
+    throw error;
+  }
+}
+
+export { queryUserOrdersExample, OrderSchema };

package/examples/schema-validated-scan-document.ts

@@ -0,0 +1,57 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { z } from "zod";
+import { SchemaValidatedDocumentClient } from "../src/schema-validated-document-client";
+import { SchemaValidatedScanDocumentCommand } from "../src/schema-validated-scan-document-command";
+
+const UserSchema = z.object({
+  pk: z.templateLiteral(["USER", "#", z.uuid()]),
+  sk: z.literal("METADATA"),
+  userId: z.string(),
+  email: z.string().email(),
+  name: z.string(),
+  age: z.number().min(0),
+  preferences: z.object({
+    theme: z.enum(["light", "dark"]),
+    notifications: z.boolean(),
+  }),
+});
+
+type User = z.infer<typeof UserSchema>;
+
+const client = new DynamoDBClient({ region: "eu-west-1" });
+const documentClient = DynamoDBDocumentClient.from(client);
+const schemaValidatedDocumentClient = new SchemaValidatedDocumentClient(
+  documentClient,
+);
+
+const ScanUsersCommand = SchemaValidatedScanDocumentCommand<User>(UserSchema);
+
+async function scanUsersDocumentExample() {
+  try {
+    const result = await schemaValidatedDocumentClient.send(
+      new ScanUsersCommand({
+        TableName: "Users",
+        FilterExpression: "age > :minAge",
+        ExpressionAttributeValues: {
+          ":minAge": 18,
+        },
+      }),
+      UserSchema,
+    );
+
+    if (result.Items) {
+      console.log("Validated users:", result.Items);
+      return result.Items;
+    }
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error("Schema validation failed:", error.issues);
+    } else {
+      console.error("DynamoDB error:", error);
+    }
+    throw error;
+  }
+}
+
+export { scanUsersDocumentExample, UserSchema };

package/examples/schema-validated-stream-event.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { validateStreamEvent } from "../src/schema-validated-stream-event";
+import type { DynamoDBStreamEvent } from "../src/stream-event";
+
+const UserSchema = z.object({
+  pk: z.templateLiteral(["USER", "#", z.string()]),
+  sk: z.literal("PROFILE"),
+  userId: z.string(),
+  email: z.string().email(),
+  name: z.string(),
+  age: z.number().min(0),
+  preferences: z.object({
+    theme: z.enum(["light", "dark"]),
+    notifications: z.boolean(),
+  }),
+});
+
+type User = z.infer<typeof UserSchema>;
+
+export async function handleUserStreamEvent(
+  event: DynamoDBStreamEvent<User, "pk", "sk", "NEW_AND_OLD_IMAGES">,
+) {
+  try {
+    const validatedEvent = validateStreamEvent(event, UserSchema);
+
+    for (const record of validatedEvent.Records) {
+      console.log(`Processing ${record.eventName} event for ${record.eventID}`);
+
+      if (record.dynamodb?.NewImage) {
+        console.log("New user data validated successfully");
+      }
+
+      if (record.dynamodb?.OldImage) {
+        console.log("Old user data validated successfully");
+      }
+
+      switch (record.eventName) {
+        case "INSERT":
+          console.log("User created");
+          break;
+        case "MODIFY":
+          console.log("User updated");
+          break;
+        case "REMOVE":
+          console.log("User deleted");
+          break;
+      }
+    }
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error("Schema validation failed:", error.issues);
+      throw new Error(`Invalid stream data: ${error.message}`);
+    } else {
+      console.error("Stream processing error:", error);
+      throw error;
+    }
+  }
+}
+
+export { UserSchema };

package/examples/schema-validated-update-document.ts

@@ -0,0 +1,75 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { z } from "zod";
+import { SchemaValidatedDocumentClient } from "../src/schema-validated-document-client";
+import { SchemaValidatedUpdateDocumentCommand } from "../src/schema-validated-update-document-command";
+
+const UserSchema = z.object({
+  pk: z.templateLiteral(["USER", "#", z.uuid()]),
+  sk: z.literal("METADATA"),
+  userId: z.string(),
+  email: z.string().email(),
+  name: z.string(),
+  age: z.number().min(0),
+  preferences: z.object({
+    theme: z.enum(["light", "dark"]),
+    notifications: z.boolean(),
+  }),
+});
+
+type User = z.infer<typeof UserSchema>;
+
+const client = new DynamoDBClient({ region: "eu-west-1" });
+const documentClient = DynamoDBDocumentClient.from(client);
+const schemaValidatedDocumentClient = new SchemaValidatedDocumentClient(
+  documentClient,
+);
+
+const UpdateUserCommand = SchemaValidatedUpdateDocumentCommand<
+  User,
+  "pk",
+  "sk"
+>(UserSchema);
+
+async function updateUserDocumentExample() {
+  try {
+    const result = await schemaValidatedDocumentClient.send(
+      new UpdateUserCommand({
+        TableName: "Users",
+        Key: {
+          pk: "USER#00000000-0000-0000-0000-000000000000",
+          sk: "METADATA",
+        },
+        UpdateExpression:
+          "SET #name = :name, #age = :age, #preferences.#theme = :theme",
+        ExpressionAttributeNames: {
+          "#name": "name",
+          "#age": "age",
+          "#preferences": "preferences",
+          "#theme": "theme",
+        },
+        ExpressionAttributeValues: {
+          ":name": "John Doe",
+          ":age": 30,
+          ":theme": "dark",
+        },
+        ReturnValues: "ALL_NEW",
+      }),
+      UserSchema,
+    );
+
+    if (result.Attributes) {
+      console.log("Updated user:", result.Attributes);
+      return result.Attributes;
+    }
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      console.error("Schema validation failed:", error.issues);
+    } else {
+      console.error("DynamoDB error:", error);
+    }
+    throw error;
+  }
+}
+
+export { updateUserDocumentExample, UserSchema };

package/lib/client-v3.d.ts

@@ -1,7 +1,5 @@
 import type { DynamoDB, ReturnValue as DynamoDBReturnValue } from "@aws-sdk/client-dynamodb";
 import { MetadataBearer } from "@aws-sdk/types";
-import { ProjectionExpression } from "aws-sdk/clients/dynamodb";
-import { Callback } from "./callback";
 import { DeleteItemInput, DeleteItemOutput } from "./delete-item";
 import { GetItemInput, GetItemOutput } from "./get-item";
 import { JsonFormat } from "./json-format";
@@ -12,15 +10,11 @@ import { ScanInput, ScanOutput } from "./scan";
 import { UpdateItemInput, UpdateItemOutput } from "./update-item";
 export interface TypeSafeDynamoDBv3<Item extends object, PartitionKey extends keyof Item, RangeKey extends keyof Item | undefined = undefined> extends Omit<DynamoDB, "getItem" | "deleteItem" | "putItem" | "updateItem" | "query" | "scan"> {
     getItem<Key extends TableKey<Item, PartitionKey, RangeKey, JsonFormat.AttributeValue>, AttributesToGet extends keyof Item | undefined = undefined, ProjectionExpression extends string | undefined = undefined>(params: GetItemInput<Item, PartitionKey, RangeKey, Key, AttributesToGet, ProjectionExpression, JsonFormat.AttributeValue>): Promise<GetItemOutput<Item, PartitionKey, RangeKey, Key, AttributesToGet, ProjectionExpression, JsonFormat.AttributeValue> & MetadataBearer>;
-    getItem<Key extends TableKey<Item, PartitionKey, RangeKey, JsonFormat.AttributeValue>, AttributesToGet extends keyof Item | undefined = undefined, ProjectionExpression extends string | undefined = undefined>(params: GetItemInput<Item, PartitionKey, RangeKey, Key, AttributesToGet, ProjectionExpression, JsonFormat.AttributeValue>, callback: Callback<GetItemOutput<Item, PartitionKey, RangeKey, Key, AttributesToGet, ProjectionExpression, JsonFormat.AttributeValue> & MetadataBearer, any>): void;
     deleteItem<Key extends TableKey<Item, PartitionKey, RangeKey, JsonFormat.AttributeValue>, ConditionExpression extends string | undefined, ReturnValue extends DynamoDBReturnValue = "NONE">(params: DeleteItemInput<Item, PartitionKey, RangeKey, Key, ConditionExpression, ReturnValue, JsonFormat.AttributeValue>): Promise<DeleteItemOutput<Item, ReturnValue, JsonFormat.AttributeValue> & MetadataBearer>;
-    deleteItem<Key extends TableKey<Item, PartitionKey, RangeKey, JsonFormat.AttributeValue>, ConditionExpression extends string | undefined, ReturnValue extends DynamoDBReturnValue = "NONE">(params: DeleteItemInput<Item, PartitionKey, RangeKey, Key, ConditionExpression, ReturnValue, JsonFormat.AttributeValue>, callback: Callback<DeleteItemOutput<Item, ReturnValue, JsonFormat.AttributeValue> & MetadataBearer, any>): void;
     putItem<ConditionExpression extends string | undefined, ReturnValue extends DynamoDBReturnValue = "NONE">(params: PutItemInput<Item, ConditionExpression, ReturnValue, JsonFormat.AttributeValue>): Promise<PutItemOutput<Item, ReturnValue, JsonFormat.AttributeValue> & MetadataBearer>;
-    putItem<ConditionExpression extends string | undefined, ReturnValue extends DynamoDBReturnValue = "NONE">(params: PutItemInput<Item, ConditionExpression, ReturnValue, JsonFormat.AttributeValue>, callback: Callback<PutItemOutput<Item, ReturnValue, JsonFormat.AttributeValue> & MetadataBearer, any>): void;
     updateItem<Key extends TableKey<Item, PartitionKey, RangeKey, JsonFormat.AttributeValue>, UpdateExpression extends string, ConditionExpression extends string | undefined, ReturnValue extends DynamoDBReturnValue = "NONE">(params: UpdateItemInput<Item, PartitionKey, RangeKey, Key, UpdateExpression, ConditionExpression, ReturnValue, JsonFormat.AttributeValue>): Promise<UpdateItemOutput<Item, PartitionKey, RangeKey, Key, ReturnValue, JsonFormat.AttributeValue> & MetadataBearer>;
-    updateItem<Key extends TableKey<Item, PartitionKey, RangeKey, JsonFormat.AttributeValue>, UpdateExpression extends string, ConditionExpression extends string | undefined, ReturnValue extends DynamoDBReturnValue = "NONE">(params: UpdateItemInput<Item, PartitionKey, RangeKey, Key, UpdateExpression, ConditionExpression, ReturnValue, JsonFormat.AttributeValue>, callback?: Callback<UpdateItemOutput<Item, PartitionKey, RangeKey, Key, ReturnValue, JsonFormat.AttributeValue> & MetadataBearer, any>): void;
+    updateItem<Key extends TableKey<Item, PartitionKey, RangeKey, JsonFormat.AttributeValue>, UpdateExpression extends string, ConditionExpression extends string | undefined, ReturnValue extends DynamoDBReturnValue = "NONE">(params: UpdateItemInput<Item, PartitionKey, RangeKey, Key, UpdateExpression, ConditionExpression, ReturnValue, JsonFormat.AttributeValue>): Promise<UpdateItemOutput<Item, PartitionKey, RangeKey, Key, ReturnValue, JsonFormat.AttributeValue> & MetadataBearer>;
     query<KeyConditionExpression extends string | undefined = undefined, FilterExpression extends string | undefined = undefined, ProjectionExpression extends string | undefined = undefined, AttributesToGet extends keyof Item | undefined = undefined>(params: QueryInput<Item, KeyConditionExpression, FilterExpression, ProjectionExpression, AttributesToGet, JsonFormat.AttributeValue>): Promise<QueryOutput<Item, AttributesToGet, JsonFormat.AttributeValue> & MetadataBearer>;
-    query<KeyConditionExpression extends string | undefined = undefined, FilterExpression extends string | undefined = undefined, AttributesToGet extends keyof Item | undefined = undefined>(params: QueryInput<Item, KeyConditionExpression, FilterExpression, ProjectionExpression, AttributesToGet, JsonFormat.AttributeValue>, callback: Callback<QueryOutput<Item, AttributesToGet, JsonFormat.AttributeValue> & MetadataBearer, any>): void;
     scan<FilterExpression extends string | undefined = undefined, ProjectionExpression extends string | undefined = undefined, AttributesToGet extends keyof Item | undefined = undefined>(params: ScanInput<Item, FilterExpression, ProjectionExpression, AttributesToGet, JsonFormat.Document>): Promise<ScanOutput<Item, AttributesToGet, JsonFormat.AttributeValue> & MetadataBearer>;
-    scan<FilterExpression extends string | undefined = undefined, ProjectionExpression extends string | undefined = undefined, AttributesToGet extends keyof Item | undefined = undefined>(params: ScanInput<Item, FilterExpression, ProjectionExpression, AttributesToGet, JsonFormat.AttributeValue>, callback?: Callback<ScanOutput<Item, AttributesToGet, JsonFormat.AttributeValue> & MetadataBearer, any>): void;
+    scan<FilterExpression extends string | undefined = undefined, ProjectionExpression extends string | undefined = undefined, AttributesToGet extends keyof Item | undefined = undefined>(params: ScanInput<Item, FilterExpression, ProjectionExpression, AttributesToGet, JsonFormat.AttributeValue>): Promise<ScanOutput<Item, AttributesToGet, JsonFormat.AttributeValue> & MetadataBearer>;
 }