triangle-utils 1.2.12 → 1.3.1

package/utils/Utils_DynamoDB.js

@@ -1,316 +0,0 @@
-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 compile_pages(request, f, compile = true) {
-    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 || !compile) {
-            return items
-        }
-        last_eval_key = response.LastEvaluatedKey
-    }
-}
-
-export default class Utils_DynamoDB {
-
-    constructor(config) {
-        this.dynamodb = new DynamoDB({ region : config.region })
-    }
-
-    async scan(table, options = {}) {
-        const filters = options.filters !== undefined ? options.filters : {}
-        const undefined_attribute_names = options.undefined_attribute_names !== undefined ? options.undefined_attribute_names : []
-        const defined_attribute_names = options.defined_attribute_names !== undefined ? options.defined_attribute_names : []
-        const concurrency = options.concurrency !== undefined ? options.concurrency : 1
-        const attribute_names = options.attribute_names !== undefined ? options.attribute_names : []
-        const iterators = []
-        for (let i = 0; i < concurrency; i++) {
-            const request = Object.fromEntries(Object.entries({
-                TableName : table,
-                ExpressionAttributeNames : Object.fromEntries(
-                    [...Object.keys(filters), ...attribute_names, ...undefined_attribute_names, ...defined_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),
-                    ...undefined_attribute_names.map(attribute_name => "attribute_not_exists(#" + attribute_name + ")"),
-                    ...defined_attribute_names.map(attribute_name => "attribute_exists(#" + attribute_name + ")")
-                ].join(" AND "),
-                ProjectionExpression : attribute_names.map(attribute_name => "#" + attribute_name).join(", "),
-                Segment : i,
-                TotalSegments : concurrency
-            }).filter(([field, value]) => value !== undefined && (typeof value === typeof 3 || Object.keys(value).length !== 0)))
-            iterators.push(compile_pages(request, (request) => this.dynamodb.scan(request)))
-        }
-        const segments = await Promise.all(iterators)
-        return segments.flat()
-    }
-
-    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, options = {}) {
-        const reverse = options.reverse !== undefined ? options.reverse : false
-        const compile = options.reverse !== undefined ? options.compile : true
-        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 compile_pages(request, (request) => this.dynamodb.query(request), compile)
-    }
-
-    async query_prefix(table, primary_key, secondary_key_prefix, options = {}) {
-        const reverse = options.reverse !== undefined ? options.reverse : false
-        const compile = options.reverse !== undefined ? options.compile : true
-        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 compile_pages(request, (request) => this.dynamodb.query(request), compile)
-    }
-
-    async query_range(table, primary_key, secondary_key_range, options = {}) {
-        const reverse = options.reverse !== undefined ? options.reverse : false
-        const compile = options.reverse !== undefined ? options.compile : true
-        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 compile_pages(request, (request) => this.dynamodb.query(request), compile)
-    }
-
-    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, true)
-        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

@@ -1,161 +0,0 @@
-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: this.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 this.send_email(this.config.google_email, "ADMIN ALERT", text)
-    }
-
-    async safe_run(f) {
-        try {
-            await f()
-        } catch (error) {
-            if (error.stack !== undefined) {
-                await this.admin_alert(error.stack.toString())
-            } else {
-                await this.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 this.safe_run(() => f(inputs[index - 1]))
-                }
-            })())
-        }
-        await Promise.all(iterators)
-    }
-
-    async sha256(input) {
-        const input_buffer = this.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
-    }
-
-    encrypt(text) {
-        const iv = crypto.randomBytes(16)
-        const cipher = crypto.createCipheriv("aes-256-cbc", Buffer.from(this.config.secret_key, "hex"), iv)
-        let ciphertext = cipher.update(text, "utf8", "hex")
-        ciphertext += cipher.final("hex")
-        return {
-            iv: iv.toString("hex"),
-            ciphertext: ciphertext
-        }
-    }
-
-    decrypt(encryption) {
-        const iv = encryption.iv
-        const ciphertext = encryption.ciphertext
-        const decipher = crypto.createDecipheriv("aes-256-cbc", Buffer.from(this.config.secret_key, "hex"), Buffer.from(iv, "hex"))
-        let text = decipher.update(ciphertext, "hex", "utf8")
-        text += decipher.final("utf8")
-        return text
-    }
-
-    get_secret_hash(username) {
-        const secret_hash = crypto.createHmac("sha256", this.config.cognito_client_secret)
-            .update(username + this.config.cognito_client_id)
-            .digest("base64")
-        return secret_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
-    }
-
-    get_chunk_indices(text_length, max_length = 2500, overlap = 50) {
-        const num_chunks = Math.ceil((text_length + overlap) / max_length)
-        const chunk_length = Math.ceil((text_length - overlap) / num_chunks + overlap)
-        const chunk_indices = []
-        for (let i = 0; i < num_chunks; i++) {
-            chunk_indices.push([
-                (chunk_length - overlap) * i,
-                (chunk_length - overlap) * i + chunk_length
-            ])
-        }
-        return chunk_indices
-    }
-
-    chunkify(text, max_length = 2500, overlap = 50) {
-        const chunk_indices = this.get_chunk_indices(text.length, max_length, overlap)
-        return chunk_indices.map(chunk_index => ({
-            chunk_index : chunk_index,
-            chunk_text : text.substring(...chunk_index)
-        }))
-    }
-}