triangle-utils 1.0.15 → 1.0.17

package/index.js

@@ -1,16 +1,15 @@
+import states from "./states.js"
 
+import Utils_DynamoDB from "./utils/Utils_DynamoDB.js"
+import Utils_S3 from "./utils/Utils_S3.js"
+import Utils_Misc from "./utils/Utils_Misc.js"
 
-import * as utils_dynamodb from "./utils/dynamodb.js"
-import * as utils_misc from "./misc.js"
-import get_clients from "./clients.js"
-
-export default function get_utils(config) {
-    const clients = get_clients(config)
-    const utils = {}
-    for (const utils_list of [utils_misc, utils_dynamodb]) {
-        for (const [util_name, util] of Object.entries(utils_list)) {
-            utils[util_name] = (...args) => util(clients, ...args)
-        }
+export default class Utils extends Utils_Misc {
+    constructor(config) {
+        super(config)
+        this.config = config
+        this.states = states
+        this.dynamodb = new Utils_DynamoDB(config)
+        this.s3 = new Utils_S3(config)
     }
-    return utils
 }

package/package.json

@@ -1,12 +1,14 @@
 {
     "name": "triangle-utils",
-    "version": "1.0.15",
+    "version": "1.0.17",
     "main": "index.js",
     "author": "",
     "license": "ISC",
     "description": "",
     "type": "module",
     "dependencies": {
-        "@aws-sdk/client-dynamodb": "^3.953.0"
+        "@aws-sdk/client-dynamodb": "^3.953.0",
+        "@aws-sdk/client-s3": "^3.953.0",
+        "nodemailer": "^7.0.11"
     }
 }

package/test.js

@@ -0,0 +1,6 @@
+import Utils from "./index.js";
+
+
+const utils = new Utils({})
+
+console.log(utils)

package/utils/Utils_DynamoDB.js

@@ -0,0 +1,291 @@
+import { DynamoDB } from "@aws-sdk/client-dynamodb"
+
+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 default class Utils_DynamoDB {
+
+    constructor(config) {
+        this.dynamodb = new DynamoDB({ region : config.region })
+    }
+
+    async 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) => this.dynamodb.scan(request))
+    }
+
+    async get(table, key, consistent=false) {
+        const item = await this.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 })
+    }
+
+    async 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 this.dynamodb.query(request)
+            .then(response => response.Items)
+        if (items[0] === undefined) {
+            return undefined
+        }
+        return convert_output({ M : items[0] })
+    }
+
+
+
+    async 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) => this.dynamodb.query(request))
+    }
+
+    async 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) => this.dynamodb.query(request))
+    }
+
+    async 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) => this.dynamodb.query(request))
+    }
+
+    async set(table, key, attributes) {
+        return await this.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)]
+            ))
+        })
+    }
+
+    async append(table, key, attributes) {
+        return await this.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)]
+            ))
+        })
+    }
+
+    async add(table, key, attributes) {
+        const item = await this.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 this.append(table, key, attributes)
+    }
+
+    async remove(table, key, attributes) {
+        return await this.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]
+            ))
+        })
+    }
+
+    async create(table, key, attributes = {}) {
+        const item = await this.get(table, key)
+        if (item !== undefined) {
+            return undefined
+        }
+        return await this.dynamodb.putItem({
+            TableName : table,
+            Item : { ...convert_input(key).M, ...convert_input(attributes).M }
+        })
+    }
+
+    async delete(table, key) {
+        return await this.dynamodb.deleteItem({
+            TableName: table,
+            Key: Object.fromEntries(Object.keys(key).map(key_name => [key_name, convert_input(key[key_name])]))
+        })
+    }
+
+    async duplicate_attribute(table, attribute_name, new_attribute_name) {
+        const table_key_names = await this.dynamodb.describeTable({
+            TableName : table
+        }).then(metadata => metadata.Table.KeySchema.map(key => key.AttributeName))
+        const items = await this.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 this.set(table, key, { [new_attribute_name] : item[attribute_name] })
+        }
+    }
+
+    async remove_attribute(table, attribute_name) {
+        const table_key_names = await this.dynamodb.describeTable({
+            TableName : table
+        }).then(metadata => metadata.Table.KeySchema.map(key => key.AttributeName))
+        const items = await this.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 this.remove(table, key, [attribute_name])
+        }
+    }
+}

package/utils/Utils_Misc.js

@@ -0,0 +1,114 @@
+import nodemailer from "nodemailer"
+import election_ids from "./election_ids.js"
+import crypto from "crypto"
+
+export default class Utils_Misc {
+
+    constructor(config) {
+        this.config = config
+        this.text_encoder = new TextEncoder()
+        if (config.google_email !== undefined && config.google_app_password !== undefined) {
+            this.transporter = nodemailer.createTransport({
+                service: "Gmail",
+                host: "smtp.gmail.com",
+                port: 465,
+                secure: true,
+                auth: {
+                    user: config.google_email,
+                    pass: config.google_app_password,
+                }
+            })
+        }
+    }
+
+    async wait(duration) {
+        return new Promise(resolve => setTimeout(resolve, duration))
+    }
+
+    get_current_time( milliseconds = false) {
+        if (milliseconds) {
+            return (new Date()).getTime()
+        }
+        return (new Date()).toISOString()
+    }
+
+    async send_email(recipient, subject, text) {
+        for (let i = 0; i < 3; i++) {
+            try {
+                await this.transporter.sendMail({
+                    from: clients.config.alerts_email,
+                    to: recipient,
+                    subject: subject,
+                    text: text
+                })
+                return
+            } catch (error) {
+                console.log("EMAIL ERROR", error)
+            }
+        }
+    }
+
+    async admin_alert(text) {
+        console.log("ADMIN ALERT:", text)
+        await send_email(this.config.google_email, "ADMIN ALERT", text)
+    }
+
+    async safe_run( f) {
+        try {
+            await f()
+        } catch (error) {
+            if (error.stack !== undefined) {
+                await admin_alert(error.stack.toString())
+            } else {
+                await admin_alert(error.toString())
+            }
+            
+        }
+    }
+
+    async iterate(inputs, f, concurrency = 1, print_indices = false) {
+        let index = 0
+        let iterators = []
+        for (let i = 0; i < concurrency; i++) {
+            iterators.push((async () => {
+                while (index < inputs.length) {
+                    index += 1
+                    if (print_indices) {
+                        console.log(i + ":" + (index - 1) + "/" + inputs.length)
+                    }
+                    await safe_run(() => f(inputs[index - 1]))
+                }
+            })())
+        }
+        await Promise.all(iterators)
+    }
+
+    async sha256(input) {
+        const input_buffer = text_encoder.encode(input);                   
+
+        const hash_buffer = await crypto.subtle.digest("SHA-256", input_buffer)
+
+        const hash_array = Array.from(new Uint8Array(hash_buffer))
+                
+        const hash = hash_array.map(b => b.toString(16).padStart(2, "0")).join("")
+        return hash;
+    }
+
+    get_election_id(year, office, state, district) {
+        if (year === undefined || office === undefined || state === undefined || office === "P") {
+            return undefined
+        }
+        if (office === "H" && (district === undefined || district.length !== 2)) {
+            return undefined
+        }
+        if (year.length !== 4 || office.length !== 1 || state.length !== 2) {
+            return undefined
+        }
+        const office_name =  { "H" : "house", "S" : "sen", "P" : "pres" }[office]
+        const election_id = year + "-" + office_name + "-" + state.toLowerCase() + (office === "H" ? ("-" + district.toLowerCase()) : "") + "-election"
+        if (!election_ids.has(election_id)) {
+            return undefined
+        }
+        return election_id
+    }
+}

package/utils/Utils_S3.js

@@ -0,0 +1,55 @@
+import { S3, NoSuchKey } from "@aws-sdk/client-s3"
+
+export default class Utils_S3 {
+
+    constructor(config) {
+        this.s3 = new S3({ region : config.region })
+    }
+
+    async file_exists(bucket, filename) {
+        try {
+            const head = await s3.headObject({
+                Bucket : bucket,
+                Key : filename
+            })
+            return true
+        } catch (error) {
+            return false
+        }
+    }
+
+    async get_file(bucket, filename, json=false) {
+        try {
+            return await s3.getObject({
+                Bucket : bucket,
+                Key : filename
+            }).then(response => response.Body.transformToString("utf-8"))
+                .then(text => json ? JSON.parse(text) : text)
+        } catch (error) {
+            if (error instanceof NoSuchKey) {
+                return undefined
+            }
+            throw error
+        }
+    }
+
+    async create_file(bucket, filename, content) {
+        const exists = await file_exists(bucket, filename)
+        if (exists) {
+            return
+        }
+        return await s3.putObject({
+            Bucket : bucket,
+            Key : filename,
+            Body : content
+        })
+    }
+
+    async delete_file(bucket, filename) {
+        return await s3.deleteObject({
+            Bucket : bucket,
+            Key : filename
+        })
+    }
+
+}

package/clients.js

@@ -1,24 +0,0 @@
-
-import nodemailer from "nodemailer"
-import { DynamoDB } from "@aws-sdk/client-dynamodb"
-
-export default function get_clients(config) {
-    const clients = {}
-    if (config.region !== undefined) {
-        clients.dynamodb = new DynamoDB({ region : config.region })
-    }
-    if (config.google_email !== undefined && config.google_app_password !== undefined) {
-        clients.transporter = nodemailer.createTransport({
-            service: "Gmail",
-            host: "smtp.gmail.com",
-            port: 465,
-            secure: true,
-            auth: {
-                user: config.google_email,
-                pass: config.google_app_password,
-            }
-        })
-    }
-    clients.config = config
-    return clients
-}

package/misc.js

@@ -1,95 +0,0 @@
-import election_ids from "./utils/election_ids.js"
-import crypto from "crypto"
-
-export async function wait(clients, duration) {
-    return new Promise(resolve => setTimeout(resolve, duration))
-}
-
-export function get_current_time(clients, milliseconds = false) {
-    if (milliseconds) {
-        return (new Date()).getTime()
-    }
-    return (new Date()).toISOString()
-}
-
-export async function send_email(clients, recipient, subject, text) {
-    for (let i = 0; i < 3; i++) {
-        try {
-            await clients.transporter.sendMail({
-                from: clients.config.alerts_email,
-                to: recipient,
-                subject: subject,
-                text: text
-            })
-            return
-        } catch (error) {
-            console.log("EMAIL ERROR", error)
-        }
-    }
-}
-
-export async function admin_alert(clients, text) {
-    console.log("ADMIN ALERT:", text)
-    await send_email(clients, clients.config.google_email, "ADMIN ALERT", text)
-}
-
-export async function safe_run(clients, f) {
-    try {
-        await f()
-    } catch (error) {
-        if (error.stack !== undefined) {
-            await admin_alert(clients, error.stack.toString())
-        } else {
-            await admin_alert(clients, error.toString())
-        }
-        
-    }
-}
-
-export async function iterate(clients, inputs, f, concurrency = 1, print_indices = false) {
-    let index = 0
-    let iterators = []
-    for (let i = 0; i < concurrency; i++) {
-        iterators.push((async () => {
-            while (index < inputs.length) {
-                index += 1
-                if (print_indices) {
-                    console.log(i + ":" + (index - 1) + "/" + inputs.length)
-                }
-                await safe_run(clients, () => f(inputs[index - 1]))
-            }
-        })())
-    }
-    await Promise.all(iterators)
-}
-
-const text_encoder = new TextEncoder()
-
-export async function sha256(clients, input) {
-    const input_buffer = text_encoder.encode(input);                   
-
-    const hash_buffer = await crypto.subtle.digest("SHA-256", input_buffer)
-
-    const hash_array = Array.from(new Uint8Array(hash_buffer))
-              
-    const hash = hash_array.map(b => b.toString(16).padStart(2, "0")).join("")
-    return hash;
-}
-
-export function get_election_id(clients, year, office, state, district) {
-    if (year === undefined || office === undefined || state === undefined || office === "P") {
-        return undefined
-    }
-    if (office === "H" && (district === undefined || district.length !== 2)) {
-        return undefined
-    }
-    if (year.length !== 4 || office.length !== 1 || state.length !== 2) {
-        return undefined
-    }
-    const office_name =  { "H" : "house", "S" : "sen", "P" : "pres" }[office]
-    const election_id = year + "-" + office_name + "-" + state.toLowerCase() + (office === "H" ? ("-" + district.toLowerCase()) : "") + "-election"
-    if (!election_ids.has(election_id)) {
-        return undefined
-    }
-    return election_id
-}

package/utils/dynamodb.js

@@ -1,282 +0,0 @@
-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 dynamodb_scan(clients, 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) => clients.dynamodb.scan(request))
-}
-
-export async function dynamodb_get(clients, table, key, consistent=false) {
-    const item = await clients.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 dynamodb_get_max(clients, 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 clients.dynamodb.query(request)
-        .then(response => response.Items)
-    if (items[0] === undefined) {
-        return undefined
-    }
-    return convert_output({ M : items[0] })
-}
-
-
-
-export async function dynamodb_query(clients, 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) => clients.dynamodb.query(request))
-}
-
-export async function dynamodb_query_prefix(clients, 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) => clients.dynamodb.query(request))
-}
-
-export async function dynamodb_query_range(clients, 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) => clients.dynamodb.query(request))
-}
-
-export async function dynamodb_set(clients, table, key, attributes) {
-    return await clients.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 dynamodb_append(clients, table, key, attributes) {
-    return await clients.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 dynamodb_add(clients, 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 dynamodb_remove(clients, table, key, attributes) {
-    return await clients.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 dynamodb_create(clients, table, key, attributes = {}) {
-    const item = await get(table, key)
-    if (item !== undefined) {
-        return undefined
-    }
-    return await clients.dynamodb.putItem({
-        TableName : table,
-        Item : { ...convert_input(key).M, ...convert_input(attributes).M }
-    })
-}
-
-export async function dynamodb_delete(clients, table, key) {
-    return await clients.dynamodb.deleteItem({
-        TableName: table,
-        Key: Object.fromEntries(Object.keys(key).map(key_name => [key_name, convert_input(key[key_name])]))
-    })
-}
-
-export async function dynamodb_duplicate_attribute(clients, table, attribute_name, new_attribute_name) {
-    const table_key_names = await clients.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 dynamodb_remove_attribute(clients, table, attribute_name) {
-    const table_key_names = await clients.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])
-    }
-}