triangle-utils 1.0.0

package/dynamodb.js

@@ -0,0 +1,287 @@
+import config from "../config.js"
+import { DynamoDB } from "@aws-sdk/client-dynamodb"
+
+var dynamodb = new DynamoDB({ region: config.region })
+
+function convert_output(dynamoobject) {
+    if (dynamoobject.S !== undefined) {
+        return dynamoobject.S
+    } else if (dynamoobject.BOOL !== undefined) {
+        return dynamoobject.BOOL
+    } else if (dynamoobject.N !== undefined) {
+        return Number(dynamoobject.N)
+    } else if (dynamoobject.L !== undefined) {
+        return dynamoobject.L.map(a => convert_output(a))
+    } else if (dynamoobject.SS !== undefined) {
+        return new Set(dynamoobject.SS)
+    } else if (dynamoobject.M !== undefined) {
+        return Object.fromEntries(Object.entries(dynamoobject.M).map(([key, value]) => [key, convert_output(value)]))
+    }
+    return undefined
+}
+
+function convert_input(input) {
+    if (typeof input === typeof "") {
+        return { S : input }
+    } else if (typeof input === typeof true) {
+        return { BOOL : input }
+    } else if (typeof input === typeof 3.2) {
+        return { N : input.toString() }
+    } else if (Array.isArray(input)) {
+        return { L : input.map(a => convert_input(a)) }
+    } else if (input instanceof Set) {
+        return { SS : Array.from(input) }
+    } else if (typeof input === typeof {}) {
+        return {
+            M : Object.fromEntries(Object.entries(input)
+                .filter(([key, value]) => value !== undefined && value !== null && key !== "")
+                .map(([key, value]) => [key, convert_input(value)]))
+        }
+    }
+    return undefined
+}
+
+async function paginate(request, f) {
+    const items = []
+    let last_eval_key = undefined
+    while (true) {
+        const response = last_eval_key !== undefined ? (
+            await f({...request, ExclusiveStartKey : last_eval_key })
+        ) : (
+            await f(request)
+        )
+        const new_items = response.Items.map(item => convert_output({ M : item }))
+        items.push(...new_items)
+        if (response.LastEvaluatedKey === undefined) {
+            return items
+        }
+        last_eval_key = response.LastEvaluatedKey
+    }
+}
+
+export async function scan(table, attribute_names = [], filters = {}) {
+    const request = Object.fromEntries(Object.entries({
+        TableName : table,
+        ExpressionAttributeNames : Object.fromEntries((Object.keys(filters).concat(attribute_names)).map(attribute_name => ["#" + attribute_name, attribute_name])),
+        ExpressionAttributeValues : Object.fromEntries(Object.entries(filters).map(([attribute_name, attribute_value]) => [":" + attribute_name, convert_input(attribute_value)])),
+        FilterExpression : Object.keys(filters).map(attribute_name => "#" + attribute_name + " = :" + attribute_name).join(","),
+        ProjectionExpression : attribute_names.map(attribute_name => "#" + attribute_name).join(", ")
+    }).filter(([field, value]) => value !== undefined && Object.keys(value).length !== 0))
+    return await paginate(request, (request) => dynamodb.scan(request))
+}
+
+export async function get(table, key, consistent=false) {
+    const item = await dynamodb.getItem({
+        ConsistentRead : consistent,
+        TableName : table,
+        Key : convert_input(key).M
+    })
+        .then(response => response.Item)
+    if (item === undefined) {
+        return undefined
+    }
+    return convert_output({ M : item })
+}
+
+export async function get_max(table, primary_key) {
+    if (Object.keys(primary_key).length !== 1) {
+        return undefined
+    }
+    const request = {
+        TableName : table,
+        ExpressionAttributeNames: {
+            "#a": Object.keys(primary_key)[0]
+        },
+        ExpressionAttributeValues: {
+            ":a": convert_input(Object.values(primary_key)[0])
+        },
+        KeyConditionExpression: "#a = :a",
+        Limit : 1,
+        ScanIndexForward : false
+    }
+    const items = await dynamodb.query(request)
+        .then(response => response.Items)
+    if (items[0] === undefined) {
+        return undefined
+    }
+    return convert_output({ M : items[0] })
+}
+
+
+
+export async function query(table, primary_key, reverse=false) {
+    if (Object.keys(primary_key).length !== 1) {
+        return undefined
+    }
+    const request = {
+        TableName : table,
+        ExpressionAttributeNames: {
+            "#a": Object.keys(primary_key)[0]
+        },
+        ExpressionAttributeValues: {
+            ":a": convert_input(Object.values(primary_key)[0])
+        },
+        KeyConditionExpression: "#a = :a",
+        ScanIndexForward : !reverse
+    }
+    return await paginate(request, (request) => dynamodb.query(request))
+}
+
+export async function query_prefix(table, primary_key, secondary_key_prefix, reverse=false) {
+    if (Object.keys(primary_key).length !== 1 || Object.keys(secondary_key_prefix).length !== 1) {
+        return undefined
+    }
+    const request = {
+        TableName : table,
+        ExpressionAttributeNames: {
+            "#a": Object.keys(primary_key)[0],
+            "#b": Object.keys(secondary_key_prefix)[0]
+        },
+        ExpressionAttributeValues: {
+            ":a": convert_input(Object.values(primary_key)[0]),
+            ":b": convert_input(Object.values(secondary_key_prefix)[0])
+        },
+        KeyConditionExpression: "#a = :a AND begins_with(#b, :b)",
+        ScanIndexForward : !reverse
+    }
+    return await paginate(request, (request) => dynamodb.query(request))
+}
+
+export async function query_range(table, primary_key, secondary_key_range, reverse=false) {
+    if (Object.keys(primary_key).length !== 1 || Object.keys(secondary_key_range).length !== 1 || Object.values(secondary_key_range)[0].length !== 2) {
+        return undefined
+    }
+    const request = {
+        TableName : table,
+        ExpressionAttributeNames: {
+            "#a": Object.keys(primary_key)[0],
+            "#b": Object.keys(secondary_key_range)[0]
+        },
+        ExpressionAttributeValues: {
+            ":a": convert_input(Object.values(primary_key)[0]),
+            ":b1": convert_input(Object.values(secondary_key_range)[0][0]),
+            ":b2": convert_input(Object.values(secondary_key_range)[0][1])
+        },
+        KeyConditionExpression: "#a = :a AND (#b BETWEEN :b1 AND :b2)",
+        ScanIndexForward : !reverse
+    }
+    return await paginate(request, (request) => dynamodb.query(request))
+}
+
+export async function set(table, key, attributes) {
+    return await dynamodb.updateItem({
+        TableName : table,
+        Key : convert_input(key).M,
+        UpdateExpression: "set " + Object.keys(attributes)
+            .filter(attribute_name => !Object.keys(key).includes(attribute_name))
+            .filter(attribute_name => attributes[attribute_name] !== undefined)
+            .map(attribute_name => "#" + attribute_name + " = :" + attribute_name
+        ).join(", "),
+        ExpressionAttributeNames: Object.fromEntries(Object.keys(attributes)
+            .filter(attribute_name => !Object.keys(key).includes(attribute_name))
+            .filter(attribute_name => attributes[attribute_name] !== undefined)
+            .map(attribute_name => ["#" + attribute_name, attribute_name]
+        )),
+        ExpressionAttributeValues: Object.fromEntries(Object.entries(attributes)
+            .filter(([attribute_name, attribute_value]) => !Object.keys(key).includes(attribute_name))
+            .filter(([attribute_name, attribute_value]) => attribute_value !== undefined)
+            .map(([attribute_name, attribute_value]) => [":" + attribute_name, convert_input(attribute_value)]
+        ))
+    })
+}
+
+export async function append(table, key, attributes) {
+    return await dynamodb.updateItem({
+        TableName : table,
+        Key : convert_input(key).M,
+        UpdateExpression: "set " + Object.keys(attributes)
+            .filter(attribute_name => attributes[attribute_name] !== undefined)
+            .map(attribute_name => "#" + attribute_name + " = list_append(#" + attribute_name + ", :" + attribute_name + ")").join(", "),
+        ExpressionAttributeNames: Object.fromEntries(Object.keys(attributes)
+            .filter(attribute_name => attributes[attribute_name] !== undefined)
+            .map(attribute_name => ["#" + attribute_name, attribute_name]
+        )),
+        ExpressionAttributeValues: Object.fromEntries(Object.entries(attributes)
+            .filter(([attribute_name, attribute_value]) => attribute_value !== undefined)
+            .map(([attribute_name, attribute_value]) => [":" + attribute_name, convert_input(attribute_value)]
+        ))
+    })
+}
+
+export async function add(table, key, attributes) {
+    const item = await get(table, key, true)
+    const new_attributes = {}
+    for (const [attribute, values] of Object.entries(attributes)) {
+        if (item[attribute] === undefined) {
+            continue
+        }
+        const new_values = values.filter(value => !item[attribute].includes(value))
+        if (new_values.length > 0) {
+            new_attributes[attribute] = new_values
+        }
+    }
+    if (Object.values(new_attributes).flat().length === 0) {
+        return undefined
+    }
+    return await append(table, key, attributes)
+}
+
+export async function remove(table, key, attributes) {
+    return await dynamodb.updateItem({
+        TableName : table,
+        Key : convert_input(key).M,
+        UpdateExpression: "remove " + attributes
+            .map(attribute_name => "#" + attribute_name).join(", "),
+        ExpressionAttributeNames: Object.fromEntries(attributes
+            .map(attribute_name => ["#" + attribute_name, attribute_name]
+        ))
+    })
+}
+
+export async function create(table, key, attributes = {}) {
+    const item = await get(table, key)
+    if (item !== undefined) {
+        return undefined
+    }
+    return await dynamodb.putItem({
+        TableName : table,
+        Item : { ...convert_input(key).M, ...convert_input(attributes).M }
+    })
+}
+
+export async function del(table, key) {
+    return await dynamodb.deleteItem({
+        TableName: table,
+        Key: Object.fromEntries(Object.keys(key).map(key_name => [key_name, convert_input(key[key_name])]))
+    })
+}
+
+export async function duplicate_attribute(table, attribute_name, new_attribute_name) {
+    const table_key_names = await dynamodb.describeTable({
+        TableName : table
+    }).then(metadata => metadata.Table.KeySchema.map(key => key.AttributeName))
+    const items = await scan(table, table_key_names.concat([attribute_name, new_attribute_name]))
+    if (items.filter(item => item[new_attribute_name] !== undefined).length > 0) {
+        console.log("Cannot rename.", new_attribute_name, "is an existing item.")
+        return
+    }
+    for (const item of items) {
+        if (item[attribute_name] === undefined) {
+            continue
+        }
+        const key = Object.fromEntries(table_key_names.map(key_name => [key_name, item[key_name]]))
+        await set(table, key, { [new_attribute_name] : item[attribute_name] })
+    }
+}
+
+export async function remove_attribute(table, attribute_name) {
+    const table_key_names = await dynamodb.describeTable({
+        TableName : table
+    }).then(metadata => metadata.Table.KeySchema.map(key => key.AttributeName))
+    const items = await scan(table)
+        .then(items => items.filter(item => item[attribute_name] !== undefined))
+    for (const item of items) {
+        const key = Object.fromEntries(table_key_names.map(key_name => [key_name, item[key_name]]))
+        await remove(table, key, [attribute_name])
+    }
+}

package/index.js

@@ -0,0 +1,5 @@
+import * as dynamodb from "./dynamodb.js"
+
+export const utils = {
+    dynamodb : dynamodb
+}

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "triangle-utils",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": ""
+}