@kensio/yulin 0.1.0 → 0.1.1

package/src/service/dynamodb/command/put-item/put-item.iso.test.ts

@@ -1,354 +0,0 @@
-import { describe, it } from "vitest";
-import { SimAwsAccount } from "../../../organizations/sim-aws-account.js";
-import { CreateTableCommand, PutItemCommand } from "@aws-sdk/client-dynamodb";
-import {
-  assertBufferEqual,
-  assertIdentical,
-  assertInstanceOf,
-  assertNonNullable,
-  assertThrowsErrorAsync,
-  assertTrue,
-  assertStringIncludes,
-} from "@kensio/smartass";
-
-describe("DynamoDB PutItemCommand", () => {
-  it("puts new Item into DynamoDB Table, returns attributes", async () => {
-    const simAccount = new SimAwsAccount();
-    const simDynamoDb = simAccount.getDynamoDb();
-
-    await simDynamoDb.createTable(
-      new CreateTableCommand({
-        TableName: "FooTable",
-        KeySchema: [{ AttributeName: "userId", KeyType: "HASH" }],
-      }),
-    );
-
-    const putItemOutput = await simDynamoDb.putItem(
-      new PutItemCommand({
-        TableName: "FooTable",
-        Item: {
-          userId: { S: "4fad1110-e6dd-46ed-966b-356ba12f8102" },
-
-          // Scalars
-          userName: { S: "Foo McBar" },
-          favouriteNumber: { N: "42" },
-          likesPizza: { BOOL: true },
-          missingValue: { NULL: true },
-
-          // Binary
-          profilePicture: {
-            B: new Uint8Array([137, 80, 78, 71]), // "PNG" header bytes
-          },
-
-          // Sets
-          favouriteColours: { SS: ["purple", "red"] },
-          luckyNumbers: { NS: ["7", "13", "42"] },
-          binaryTags: {
-            BS: [new Uint8Array([1, 2, 3]), new Uint8Array([4, 5, 6])],
-          },
-
-          // List
-          shoppingList: {
-            L: [{ S: "milk" }, { S: "eggs" }],
-          },
-
-          // Map
-          address: {
-            M: {
-              street: { S: "123 High Street" },
-              city: { S: "London" },
-              postcode: { S: "AB1 2CD" },
-              coordinates: {
-                M: {
-                  lat: { N: "51.5" },
-                  lon: { N: "-0.1" },
-                },
-              },
-            },
-          },
-        },
-      }),
-    );
-
-    assertNonNullable(putItemOutput.Attributes);
-
-    // Scalars
-    assertIdentical(
-      putItemOutput.Attributes["userId"]?.S,
-      "4fad1110-e6dd-46ed-966b-356ba12f8102",
-    );
-    assertIdentical(putItemOutput.Attributes["userName"]?.S, "Foo McBar");
-    assertIdentical(putItemOutput.Attributes["favouriteNumber"]?.N, "42");
-    assertTrue(putItemOutput.Attributes["likesPizza"]?.BOOL);
-    assertTrue(putItemOutput.Attributes["missingValue"]?.NULL);
-
-    // Binary
-    assertBufferEqual(
-      putItemOutput.Attributes["profilePicture"]?.B,
-      new Uint8Array([137, 80, 78, 71]),
-    );
-
-    // Sets
-    assertIdentical(
-      putItemOutput.Attributes["favouriteColours"]?.SS?.[0],
-      "purple",
-    );
-
-    // List
-    assertIdentical(
-      putItemOutput.Attributes["shoppingList"]?.L?.[0]?.S,
-      "milk",
-    );
-
-    // Map
-    assertIdentical(
-      putItemOutput.Attributes["address"]?.M?.["street"]?.S,
-      "123 High Street",
-    );
-    assertIdentical(putItemOutput.Attributes["address"].M["city"]?.S, "London");
-    assertIdentical(
-      putItemOutput.Attributes["address"].M["postcode"]?.S,
-      "AB1 2CD",
-    );
-    assertIdentical(
-      putItemOutput.Attributes["address"].M["coordinates"]?.M?.["lat"]?.N,
-      "51.5",
-    );
-    assertIdentical(
-      putItemOutput.Attributes["address"].M["coordinates"].M["lon"]?.N,
-      "-0.1",
-    );
-
-    await simAccount.backgroundTasksComplete();
-  });
-
-  it("puts new Item into DynamoDB Table with partition key + sort key", async () => {
-    const simAccount = new SimAwsAccount();
-    const simDynamoDb = simAccount.getDynamoDb();
-
-    await simDynamoDb.createTable(
-      new CreateTableCommand({
-        TableName: "FooTable",
-        KeySchema: [
-          { AttributeName: "userId", KeyType: "HASH" },
-          { AttributeName: "orderId", KeyType: "RANGE" },
-        ],
-      }),
-    );
-
-    const putItemOutput = await simDynamoDb.putItem(
-      new PutItemCommand({
-        TableName: "FooTable",
-        Item: {
-          userId: { S: "06a3f1a5-df48-4951-8316-6c99ca1ec662" },
-          orderId: { S: "736dbd1c-e02a-4526-8534-0f1ab9314db8" },
-          somethingElse: { N: "12345" },
-        },
-      }),
-    );
-
-    assertNonNullable(putItemOutput.Attributes);
-    assertIdentical(
-      putItemOutput.Attributes["userId"]?.S,
-      "06a3f1a5-df48-4951-8316-6c99ca1ec662",
-    );
-    assertIdentical(
-      putItemOutput.Attributes["orderId"]?.S,
-      "736dbd1c-e02a-4526-8534-0f1ab9314db8",
-    );
-    assertIdentical(putItemOutput.Attributes["somethingElse"]?.N, "12345");
-  });
-
-  it("rejects when missing partition key", async () => {
-    const simAccount = new SimAwsAccount();
-    const simDynamoDb = simAccount.getDynamoDb();
-
-    await simDynamoDb.createTable(
-      new CreateTableCommand({
-        TableName: "FooTable",
-        KeySchema: [{ AttributeName: "userId", KeyType: "HASH" }],
-      }),
-    );
-
-    const error = await assertThrowsErrorAsync(async () => {
-      await simDynamoDb.putItem(
-        new PutItemCommand({
-          TableName: "FooTable",
-          Item: {
-            orderId: { S: "da9ee033-2a2c-4b1e-942d-3f96f4ecdf06" },
-            somethingElse: { N: "12345" },
-          },
-        }),
-      );
-    });
-
-    assertInstanceOf(error, Error);
-    assertStringIncludes(
-      error.message,
-      "DynamoDB Item partition key userId must be defined",
-    );
-  });
-
-  it("rejects when missing sort key", async () => {
-    const simAccount = new SimAwsAccount();
-    const simDynamoDb = simAccount.getDynamoDb();
-
-    await simDynamoDb.createTable(
-      new CreateTableCommand({
-        TableName: "FooTable",
-        KeySchema: [
-          { AttributeName: "userId", KeyType: "HASH" },
-          { AttributeName: "orderId", KeyType: "RANGE" },
-        ],
-      }),
-    );
-
-    const error = await assertThrowsErrorAsync(async () => {
-      await simDynamoDb.putItem(
-        new PutItemCommand({
-          TableName: "FooTable",
-          Item: {
-            userId: { S: "24ed2ef9-4276-457c-8c9b-a317bd788084" },
-            somethingElse: { N: "12345" },
-          },
-        }),
-      );
-    });
-
-    assertInstanceOf(error, Error);
-    assertStringIncludes(
-      error.message,
-      "DynamoDB Item sort key orderId is undefined",
-    );
-  });
-
-  it("rejects on invalid partition key type", async () => {
-    const simAccount = new SimAwsAccount();
-    const simDynamoDb = simAccount.getDynamoDb();
-
-    await simDynamoDb.createTable(
-      new CreateTableCommand({
-        TableName: "FooTable",
-        KeySchema: [{ AttributeName: "userId", KeyType: "HASH" }],
-      }),
-    );
-
-    const error = await assertThrowsErrorAsync(async () => {
-      await simDynamoDb.putItem(
-        new PutItemCommand({
-          TableName: "FooTable",
-          Item: {
-            userId: { BOOL: true },
-          },
-        }),
-      );
-    });
-
-    assertInstanceOf(error, Error);
-    assertStringIncludes(
-      error.message,
-      "DynamoDB Item partition key userId must be string or number",
-    );
-  });
-
-  it("rejects on invalid sort key type", async () => {
-    const simAccount = new SimAwsAccount();
-    const simDynamoDb = simAccount.getDynamoDb();
-
-    await simDynamoDb.createTable(
-      new CreateTableCommand({
-        TableName: "FooTable",
-        KeySchema: [
-          { AttributeName: "userId", KeyType: "HASH" },
-          { AttributeName: "orderId", KeyType: "RANGE" },
-        ],
-      }),
-    );
-
-    const error = await assertThrowsErrorAsync(async () => {
-      await simDynamoDb.putItem(
-        new PutItemCommand({
-          TableName: "FooTable",
-          Item: {
-            userId: { S: "ff8cc151-1b17-4d8e-8f98-ad631b6aefa7" },
-            orderId: { BOOL: true },
-          },
-        }),
-      );
-    });
-
-    assertInstanceOf(error, Error);
-    assertStringIncludes(
-      error.message,
-      "DynamoDB Item sort key orderId must be string or number",
-    );
-  });
-
-  it("rejects undefined table name", async () => {
-    const simAccount = new SimAwsAccount();
-    const simDynamoDb = simAccount.getDynamoDb();
-
-    const error = await assertThrowsErrorAsync(async () => {
-      await simDynamoDb.putItem(
-        new PutItemCommand({
-          TableName: undefined,
-          Item: {
-            userId: { S: "57bec277-9f94-4671-a592-d1c81df9860e" },
-          },
-        }),
-      );
-    });
-
-    assertInstanceOf(error, Error);
-    assertStringIncludes(
-      error.message,
-      "PutItemCommand.input.TableName is required",
-    );
-  });
-
-  it("rejects non-existent table", async () => {
-    const simAccount = new SimAwsAccount();
-    const simDynamoDb = simAccount.getDynamoDb();
-
-    const error = await assertThrowsErrorAsync(async () => {
-      await simDynamoDb.putItem(
-        new PutItemCommand({
-          TableName: "FooTable",
-          Item: {
-            userId: { S: "6aaaba1a-cfe8-449c-8a7b-760e4f8025cb" },
-          },
-        }),
-      );
-    });
-
-    assertInstanceOf(error, Error);
-    assertStringIncludes(error.message, "No DynamoDB Table named FooTable");
-  });
-
-  it("rejects missing item", async () => {
-    const simAccount = new SimAwsAccount();
-    const simDynamoDb = simAccount.getDynamoDb();
-
-    await simDynamoDb.createTable(
-      new CreateTableCommand({
-        TableName: "FooTable",
-        KeySchema: [{ AttributeName: "userId", KeyType: "HASH" }],
-      }),
-    );
-
-    const error = await assertThrowsErrorAsync(async () => {
-      await simDynamoDb.putItem(
-        new PutItemCommand({
-          TableName: "FooTable",
-          Item: undefined,
-        }),
-      );
-    });
-
-    assertInstanceOf(error, Error);
-    assertStringIncludes(
-      error.message,
-      "PutItemCommand.input.Item is required",
-    );
-  });
-});

package/src/service/dynamodb/dynamodb.ts

@@ -1,60 +0,0 @@
-import type {
-  CreateTableCommand,
-  CreateTableOutput,
-  DescribeTableCommand,
-  DescribeTableOutput,
-  ListTablesCommand,
-  ListTablesOutput,
-  PutItemCommand,
-  PutItemCommandOutput,
-} from "@aws-sdk/client-dynamodb";
-import type {
-  DynamoDbTableName,
-  SimDynamoDbTable,
-} from "./table/dynamodb-table.js";
-import { CreateTableCommandHandler } from "./command/create-table/create-table.handler.js";
-import type { BackgroundScheduler } from "../../util/background/background.js";
-import { ListTablesCommandHandler } from "./command/list-tables/list-tables.handler.js";
-import { DescribeTableCommandHandler } from "./command/describe-table/describe-table.handler.js";
-import { PutItemCommandHandler } from "./command/put-item/put-item.handler.js";
-
-/**
- * Simulated DynamoDB. Handles SDK commands. Emulates AWS behaviour and state.
- */
-export class SimDynamoDb {
-  private readonly tables = new Map<DynamoDbTableName, SimDynamoDbTable>();
-
-  constructor(private readonly background: BackgroundScheduler) {}
-
-  /**
-   * Handle a Create Table Command from the SDK.
-   */
-  async createTable(cmd: CreateTableCommand): Promise<CreateTableOutput> {
-    const handler = new CreateTableCommandHandler(this.tables, this.background);
-    return await handler.handle(cmd);
-  }
-
-  /**
-   * Handle a List Tables Command from the SDK.
-   */
-  async listTables(cmd: ListTablesCommand): Promise<ListTablesOutput> {
-    const handler = new ListTablesCommandHandler(this.tables);
-    return await handler.handle(cmd);
-  }
-
-  /**
-   * Handle a Describe Table Command from the SDK.
-   */
-  async describeTable(cmd: DescribeTableCommand): Promise<DescribeTableOutput> {
-    const handler = new DescribeTableCommandHandler(this.tables);
-    return await handler.handle(cmd);
-  }
-
-  /**
-   * Handle a Put Item Command from the SDK.
-   */
-  async putItem(cmd: PutItemCommand): Promise<PutItemCommandOutput> {
-    const handler = new PutItemCommandHandler(this.tables);
-    return await handler.handle(cmd);
-  }
-}

package/src/service/dynamodb/item/dynamodb-item-attribute.iso.test.ts

@@ -1,19 +0,0 @@
-import { describe, it } from "vitest";
-import {
-  assertInstanceOf,
-  assertStringIncludes,
-  assertThrowsError,
-} from "@kensio/smartass";
-import { DynamoDBItemAttribute } from "./dynamodb-item-attribute.js";
-
-describe("DynamoDB Item Attribute", () => {
-  it("rejects unrecognised attribute type", () => {
-    const error = assertThrowsError(() => {
-      // @ts-expect-error testing invalid DDB attribute type key
-      DynamoDBItemAttribute.fromAttributeValue({ BAD: "foobar" });
-    });
-
-    assertInstanceOf(error, Error);
-    assertStringIncludes(error.message, "Unsupported AttributeValue type");
-  });
-});

package/src/service/dynamodb/item/dynamodb-item-attribute.ts

@@ -1,116 +0,0 @@
-import type { AttributeValue } from "@aws-sdk/client-dynamodb";
-
-export type DynamoDBAttrType =
-  | boolean
-  | null
-  | number
-  | string
-  | Uint8Array
-  | Set<string>
-  | Set<number>
-  | Set<Uint8Array>
-  | DynamoDBAttrType[]
-  | { [key: string]: DynamoDBAttrType };
-
-/**
- * A single attribute of a DynamoDB Item.
- */
-export class DynamoDBItemAttribute {
-  constructor(readonly value: DynamoDBAttrType) {}
-
-  /**
-   * Convert a DynamoDB AttributeValue structure to a DynamoDBItemAttribute
-   * instance.
-   */
-  static fromAttributeValue(value: AttributeValue): DynamoDBItemAttribute {
-    if (value.BOOL !== undefined) {
-      return new DynamoDBItemAttribute(value.BOOL);
-    }
-    if (value.NULL !== undefined) {
-      return new DynamoDBItemAttribute(null);
-    }
-    if (value.S !== undefined) {
-      return new DynamoDBItemAttribute(value.S);
-    }
-    if (value.N !== undefined) {
-      return new DynamoDBItemAttribute(Number(value.N));
-    }
-    if (value.B !== undefined) {
-      return new DynamoDBItemAttribute(value.B);
-    }
-    if (value.SS !== undefined) {
-      return new DynamoDBItemAttribute(new Set(value.SS));
-    }
-    if (value.NS !== undefined) {
-      return new DynamoDBItemAttribute(new Set(value.NS.map(Number)));
-    }
-    if (value.BS !== undefined) {
-      return new DynamoDBItemAttribute(new Set(value.BS));
-    }
-    if (value.L !== undefined) {
-      return new DynamoDBItemAttribute(
-        value.L.map((el) => DynamoDBItemAttribute.fromAttributeValue(el).value),
-      );
-    }
-    if (value.M !== undefined) {
-      return new DynamoDBItemAttribute(
-        Object.fromEntries(
-          Object.entries(value.M).map(([key, val]) => [
-            key,
-            DynamoDBItemAttribute.fromAttributeValue(val).value,
-          ]),
-        ),
-      );
-    }
-    throw new Error(
-      `Unsupported AttributeValue type: ${JSON.stringify(value)}`,
-    );
-  }
-
-  /**
-   * Convert this DynamoDBItemAttribute to a DynamoDB AttributeValue structure.
-   */
-  toAttributeValue(): AttributeValue {
-    const value = this.value;
-
-    if (value === null) {
-      return { NULL: true };
-    }
-    if (typeof value === "string") {
-      return { S: value };
-    }
-    if (typeof value === "number") {
-      return { N: String(value) };
-    }
-    if (typeof value === "boolean") {
-      return { BOOL: value };
-    }
-    if (ArrayBuffer.isView(value)) {
-      return { B: value };
-    }
-    if (Array.isArray(value)) {
-      return {
-        L: value.map((el) => new DynamoDBItemAttribute(el).toAttributeValue()),
-      };
-    }
-    if (value instanceof Set) {
-      const firstValue = value.values().next().value;
-      if (firstValue !== undefined && ArrayBuffer.isView(firstValue)) {
-        return { BS: [...value] as Uint8Array[] };
-      }
-      if (typeof firstValue === "number") {
-        return { NS: [...value].map(String) };
-      }
-      return { SS: [...value] as string[] };
-    }
-
-    return {
-      M: Object.fromEntries(
-        Object.entries(value).map(([key, val]) => [
-          key,
-          new DynamoDBItemAttribute(val).toAttributeValue(),
-        ]),
-      ),
-    };
-  }
-}

package/src/service/dynamodb/item/dynamodb-item.ts

@@ -1,39 +0,0 @@
-import type { AttributeValue } from "@aws-sdk/client-dynamodb";
-import { DynamoDBItemAttribute } from "./dynamodb-item-attribute.js";
-
-/**
- * A single Item in a DynamoDB Table.
- */
-export class DynamoDbItem {
-  constructor(
-    readonly attributes: Record<string, DynamoDBItemAttribute> = {},
-  ) {}
-
-  /**
-   * Convert an AttributeValue structure to a DynamoDbItem instance.
-   */
-  static fromAttributeValues(
-    attributeValues: Record<string, AttributeValue>,
-  ): DynamoDbItem {
-    return new DynamoDbItem(
-      Object.fromEntries(
-        Object.entries(attributeValues).map(([key, value]) => [
-          key,
-          DynamoDBItemAttribute.fromAttributeValue(value),
-        ]),
-      ),
-    );
-  }
-
-  /**
-   * Convert this DynamoDbItem to an AttributeValue structure.
-   */
-  toAttributeValues(): Record<string, AttributeValue> {
-    return Object.fromEntries(
-      Object.entries(this.attributes).map(([key, value]) => [
-        key,
-        value.toAttributeValue(),
-      ]),
-    );
-  }
-}

package/src/service/dynamodb/table/dynamodb-key-schema.ts

@@ -1,94 +0,0 @@
-import type { CreateTableInput, KeyType } from "@aws-sdk/client-dynamodb";
-import { assertDefined } from "../../../util/defined.js";
-import type { DynamoDbItem } from "../item/dynamodb-item.js";
-import type { DynamoDBAttrType } from "../item/dynamodb-item-attribute.js";
-
-type DynamoDbKey = string | number;
-
-/**
- * Extractor for DynamoDB KeySchema from CreateTableCommand input.
- *
- * https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_KeySchemaElement.html
- */
-export class DynamoDbKeySchema {
-  public readonly partitionKey: { AttributeName: string; KeyType: KeyType };
-
-  public readonly sortKey?: { AttributeName: string; KeyType: KeyType };
-
-  constructor(createTableInput: Pick<CreateTableInput, "KeySchema">) {
-    assertDefined(createTableInput.KeySchema, "createTableInput.KeySchema");
-
-    const partitionKeyElement = createTableInput.KeySchema.find(
-      (el) => el.KeyType === "HASH",
-    );
-    assertDefined(
-      partitionKeyElement,
-      '"CreateTableInput.KeySchema partition key (KeyType=HASH)',
-    );
-    assertDefined(
-      partitionKeyElement.AttributeName,
-      "Partition Key AttributeName",
-    );
-    assertDefined(partitionKeyElement.KeyType, "Partition Key KeyType");
-    this.partitionKey = {
-      AttributeName: partitionKeyElement.AttributeName,
-      KeyType: partitionKeyElement.KeyType,
-    };
-
-    const sortKeyElement = createTableInput.KeySchema.find(
-      (el) => el.KeyType === "RANGE",
-    );
-    if (sortKeyElement === undefined) {
-      return;
-    }
-    assertDefined(sortKeyElement.AttributeName, "Sort Key AttributeName");
-    assertDefined(sortKeyElement.KeyType, "Sort Key KeyType");
-    this.sortKey = {
-      AttributeName: sortKeyElement.AttributeName,
-      KeyType: sortKeyElement.KeyType,
-    };
-  }
-
-  /**
-   * Make a primary key string for an item based on this key schema.
-   */
-  makeItemKey(item: DynamoDbItem): string {
-    const partitionKeyAttr = item.attributes[this.partitionKey.AttributeName];
-    assertDefined(
-      partitionKeyAttr,
-      `DynamoDB Item partition key ${this.partitionKey.AttributeName}`,
-    );
-    const partitionKey = partitionKeyAttr.value;
-    if (!DynamoDbKeySchema.canBeDynamoDbKey(partitionKey)) {
-      throw new TypeError(
-        `DynamoDB Item partition key ${this.partitionKey.AttributeName} must be string or number`,
-      );
-    }
-
-    const keyParts: Record<string, DynamoDbKey> = { partitionKey };
-
-    if (this.sortKey?.AttributeName !== undefined) {
-      const sortKey = item.attributes[this.sortKey.AttributeName];
-      if (sortKey === undefined) {
-        throw new TypeError(
-          `DynamoDB Item sort key ${this.sortKey.AttributeName} is undefined`,
-        );
-      }
-      if (!DynamoDbKeySchema.canBeDynamoDbKey(sortKey.value)) {
-        throw new TypeError(
-          `DynamoDB Item sort key ${this.sortKey.AttributeName} must be string or number`,
-        );
-      }
-      keyParts[this.sortKey.AttributeName] = sortKey.value;
-    }
-
-    return JSON.stringify(keyParts);
-  }
-
-  /**
-   * Check if a given value can be used as a DynamoDB partition key or sort key.
-   */
-  static canBeDynamoDbKey(value: DynamoDBAttrType): value is DynamoDbKey {
-    return typeof value === "string" || typeof value === "number";
-  }
-}