Class DynamoDB

table

• table(name: string, partitionKey: string, sortKey?: string): {
      batch: {
          read: ((keys: {
              partition: string;
              sort?: string;
          }[]) => Promise<Item[]>);
          write: ((operations: BatchWriteOperation[]) => Promise<void>);
      };
      delete: ((partition: string, sort?: string) => Promise<void>);
      get: ((partition: string, sort?: string) => Promise<undefined | AttributeMap>);
      getByPrefix: ((partition: string, sort: string) => Promise<undefined | ItemList>);
      getPartitionPage: ((partition: string, limit: number, cursor?: string, sort?: SortOrder, filterKey?: string, filterValue?: string, filterExclude?: boolean) => Promise<{
          cursor: string;
          items: {
              cursor: string;
              item: AttributeMap;
          }[];
          more: boolean;
      }>);
      getPartitions: ((partition: string) => Promise<{
          items: Item[];
      }>);
      index: ((indexName: string, indexPartitionKey: string) => {
          getPartitionPage: ((partition: string, limit: number, cursor?: string, sort?: SortOrder) => Promise<{
              cursor: string;
              items: {
                  cursor: string;
                  item: AttributeMap;
              }[];
              more: boolean;
          }>);
          getPartitions: ((partition: string) => Promise<{
              items: Item[];
          }>);
      });
      put: ((item: object) => Promise<void>);
      queryByExpression: ((keyCondition: string, ExpressionAttributeValues: Record<string, string>, ExpressionAttributeNames: Record<string, string>) => Promise<Item[]>);
  }

• Get an object representing a DynamoDB table, which can then be used to perform operations on that table.

  Parameters

  • name: string

  • partitionKey: string

  • Optional sortKey: string

  Returns {
      batch: {
          read: ((keys: {
              partition: string;
              sort?: string;
          }[]) => Promise<Item[]>);
          write: ((operations: BatchWriteOperation[]) => Promise<void>);
      };
      delete: ((partition: string, sort?: string) => Promise<void>);
      get: ((partition: string, sort?: string) => Promise<undefined | AttributeMap>);
      getByPrefix: ((partition: string, sort: string) => Promise<undefined | ItemList>);
      getPartitionPage: ((partition: string, limit: number, cursor?: string, sort?: SortOrder, filterKey?: string, filterValue?: string, filterExclude?: boolean) => Promise<{
          cursor: string;
          items: {
              cursor: string;
              item: AttributeMap;
          }[];
          more: boolean;
      }>);
      getPartitions: ((partition: string) => Promise<{
          items: Item[];
      }>);
      index: ((indexName: string, indexPartitionKey: string) => {
          getPartitionPage: ((partition: string, limit: number, cursor?: string, sort?: SortOrder) => Promise<{
              cursor: string;
              items: {
                  cursor: string;
                  item: AttributeMap;
              }[];
              more: boolean;
          }>);
          getPartitions: ((partition: string) => Promise<{
              items: Item[];
          }>);
      });
      put: ((item: object) => Promise<void>);
      queryByExpression: ((keyCondition: string, ExpressionAttributeValues: Record<string, string>, ExpressionAttributeNames: Record<string, string>) => Promise<Item[]>);
  }

  • batch: {
        read: ((keys: {
            partition: string;
            sort?: string;
        }[]) => Promise<Item[]>);
        write: ((operations: BatchWriteOperation[]) => Promise<void>);
    }

    • read: ((keys: {
          partition: string;
          sort?: string;
      }[]) => Promise<Item[]>)

      • • (keys: {
              partition: string;
              sort?: string;
          }[]): Promise<Item[]>

        • Parameters

          • keys: {
                partition: string;
                sort?: string;
            }[]

          Returns Promise<Item[]>

    • write: ((operations: BatchWriteOperation[]) => Promise<void>)

      • • (operations: BatchWriteOperation[]): Promise<void>

        • Parameters

          • operations: BatchWriteOperation[]

          Returns Promise<void>

  • delete: ((partition: string, sort?: string) => Promise<void>)

    • • (partition: string, sort?: string): Promise<void>

      • Parameters

        • partition: string

        • Optional sort: string

        Returns Promise<void>

  • get: ((partition: string, sort?: string) => Promise<undefined | AttributeMap>)

    • • (partition: string, sort?: string): Promise<undefined | AttributeMap>

      • Parameters

        • partition: string

        • Optional sort: string

        Returns Promise<undefined | AttributeMap>

  • getByPrefix: ((partition: string, sort: string) => Promise<undefined | ItemList>)

    • • (partition: string, sort: string): Promise<undefined | ItemList>

      • Parameters

        • partition: string

        • sort: string

        Returns Promise<undefined | ItemList>

  • getPartitionPage: ((partition: string, limit: number, cursor?: string, sort?: SortOrder, filterKey?: string, filterValue?: string, filterExclude?: boolean) => Promise<{
        cursor: string;
        items: {
            cursor: string;
            item: AttributeMap;
        }[];
        more: boolean;
    }>)

    • • (partition: string, limit: number, cursor?: string, sort?: SortOrder, filterKey?: string, filterValue?: string, filterExclude?: boolean): Promise<{
            cursor: string;
            items: {
                cursor: string;
                item: AttributeMap;
            }[];
            more: boolean;
        }>

      • Parameters

        • partition: string

        • limit: number

        • Optional cursor: string

        • Optional sort: SortOrder

        • Optional filterKey: string

        • Optional filterValue: string

        • Optional filterExclude: boolean

        Returns Promise<{
            cursor: string;
            items: {
                cursor: string;
                item: AttributeMap;
            }[];
            more: boolean;
        }>

  • getPartitions: ((partition: string) => Promise<{
        items: Item[];
    }>)

    • • (partition: string): Promise<{
            items: Item[];
        }>

      • Parameters

        • partition: string

        Returns Promise<{
            items: Item[];
        }>

  • index: ((indexName: string, indexPartitionKey: string) => {
        getPartitionPage: ((partition: string, limit: number, cursor?: string, sort?: SortOrder) => Promise<{
            cursor: string;
            items: {
                cursor: string;
                item: AttributeMap;
            }[];
            more: boolean;
        }>);
        getPartitions: ((partition: string) => Promise<{
            items: Item[];
        }>);
    })

    • • (indexName: string, indexPartitionKey: string): {
            getPartitionPage: ((partition: string, limit: number, cursor?: string, sort?: SortOrder) => Promise<{
                cursor: string;
                items: {
                    cursor: string;
                    item: AttributeMap;
                }[];
                more: boolean;
            }>);
            getPartitions: ((partition: string) => Promise<{
                items: Item[];
            }>);
        }

      • Parameters

        • indexName: string

        • indexPartitionKey: string

        Returns {
            getPartitionPage: ((partition: string, limit: number, cursor?: string, sort?: SortOrder) => Promise<{
                cursor: string;
                items: {
                    cursor: string;
                    item: AttributeMap;
                }[];
                more: boolean;
            }>);
            getPartitions: ((partition: string) => Promise<{
                items: Item[];
            }>);
        }

        • getPartitionPage: ((partition: string, limit: number, cursor?: string, sort?: SortOrder) => Promise<{
              cursor: string;
              items: {
                  cursor: string;
                  item: AttributeMap;
              }[];
              more: boolean;
          }>)

          • • (partition: string, limit: number, cursor?: string, sort?: SortOrder): Promise<{
                  cursor: string;
                  items: {
                      cursor: string;
                      item: AttributeMap;
                  }[];
                  more: boolean;
              }>

            • Parameters

              • partition: string

              • limit: number

              • Optional cursor: string

              • Optional sort: SortOrder

              Returns Promise<{
                  cursor: string;
                  items: {
                      cursor: string;
                      item: AttributeMap;
                  }[];
                  more: boolean;
              }>

        • getPartitions: ((partition: string) => Promise<{
              items: Item[];
          }>)

          • • (partition: string): Promise<{
                  items: Item[];
              }>

            • Parameters

              • partition: string

              Returns Promise<{
                  items: Item[];
              }>

  • put: ((item: object) => Promise<void>)

    • • (item: object): Promise<void>

      • Parameters

        • item: object

        Returns Promise<void>

  • queryByExpression: ((keyCondition: string, ExpressionAttributeValues: Record<string, string>, ExpressionAttributeNames: Record<string, string>) => Promise<Item[]>)

    • • (keyCondition: string, ExpressionAttributeValues: Record<string, string>, ExpressionAttributeNames: Record<string, string>): Promise<Item[]>

      • Parameters

        • keyCondition: string

        • ExpressionAttributeValues: Record<string, string>

        • ExpressionAttributeNames: Record<string, string>

        Returns Promise<Item[]>