triangle-utils 1.0.3 → 1.0.5

package/dynamodb.js

@@ -54,7 +54,7 @@ async function paginate(request, f) {
     }
 }
 
-export async function dynamodb_scan(dynamodb, table, attribute_names = [], filters = {}) {
+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])),
@@ -62,11 +62,11 @@ export async function dynamodb_scan(dynamodb, table, attribute_names = [], filte
         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))
+    return await paginate(request, (request) => clients.dynamodb.scan(request))
 }
 
-export async function dynamodb_get(dynamodb, table, key, consistent=false) {
-    const item = await dynamodb.getItem({
+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
@@ -78,7 +78,7 @@ export async function dynamodb_get(dynamodb, table, key, consistent=false) {
     return convert_output({ M : item })
 }
 
-export async function dynamodb_get_max(dynamodb, table, primary_key) {
+export async function dynamodb_get_max(clients, table, primary_key) {
     if (Object.keys(primary_key).length !== 1) {
         return undefined
     }
@@ -94,7 +94,7 @@ export async function dynamodb_get_max(dynamodb, table, primary_key) {
         Limit : 1,
         ScanIndexForward : false
     }
-    const items = await dynamodb.query(request)
+    const items = await clients.dynamodb.query(request)
         .then(response => response.Items)
     if (items[0] === undefined) {
         return undefined
@@ -104,7 +104,7 @@ export async function dynamodb_get_max(dynamodb, table, primary_key) {
 
 
 
-export async function dynamodb_query(dynamodb, table, primary_key, reverse=false) {
+export async function dynamodb_query(clients, table, primary_key, reverse=false) {
     if (Object.keys(primary_key).length !== 1) {
         return undefined
     }
@@ -119,10 +119,10 @@ export async function dynamodb_query(dynamodb, table, primary_key, reverse=false
         KeyConditionExpression: "#a = :a",
         ScanIndexForward : !reverse
     }
-    return await paginate(request, (request) => dynamodb.query(request))
+    return await paginate(request, (request) => clients.dynamodb.query(request))
 }
 
-export async function dynamodb_query_prefix(dynamodb, table, primary_key, secondary_key_prefix, reverse=false) {
+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
     }
@@ -139,10 +139,10 @@ export async function dynamodb_query_prefix(dynamodb, table, primary_key, second
         KeyConditionExpression: "#a = :a AND begins_with(#b, :b)",
         ScanIndexForward : !reverse
     }
-    return await paginate(request, (request) => dynamodb.query(request))
+    return await paginate(request, (request) => clients.dynamodb.query(request))
 }
 
-export async function dynamodb_query_range(dynamodb, table, primary_key, secondary_key_range, reverse=false) {
+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
     }
@@ -160,11 +160,11 @@ export async function dynamodb_query_range(dynamodb, table, primary_key, seconda
         KeyConditionExpression: "#a = :a AND (#b BETWEEN :b1 AND :b2)",
         ScanIndexForward : !reverse
     }
-    return await paginate(request, (request) => dynamodb.query(request))
+    return await paginate(request, (request) => clients.dynamodb.query(request))
 }
 
-export async function dynamodb_set(dynamodb, table, key, attributes) {
-    return await dynamodb.updateItem({
+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)
@@ -185,8 +185,8 @@ export async function dynamodb_set(dynamodb, table, key, attributes) {
     })
 }
 
-export async function dynamodb_append(dynamodb, table, key, attributes) {
-    return await dynamodb.updateItem({
+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)
@@ -203,7 +203,7 @@ export async function dynamodb_append(dynamodb, table, key, attributes) {
     })
 }
 
-export async function dynamodb_add(dynamodb, table, key, attributes) {
+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)) {
@@ -221,8 +221,8 @@ export async function dynamodb_add(dynamodb, table, key, attributes) {
     return await append(table, key, attributes)
 }
 
-export async function dynamodb_remove(dynamodb, table, key, attributes) {
-    return await dynamodb.updateItem({
+export async function dynamodb_remove(clients, table, key, attributes) {
+    return await clients.dynamodb.updateItem({
         TableName : table,
         Key : convert_input(key).M,
         UpdateExpression: "remove " + attributes
@@ -233,26 +233,26 @@ export async function dynamodb_remove(dynamodb, table, key, attributes) {
     })
 }
 
-export async function dynamodb_create(dynamodb, table, key, attributes = {}) {
+export async function dynamodb_create(clients, table, key, attributes = {}) {
     const item = await get(table, key)
     if (item !== undefined) {
         return undefined
     }
-    return await dynamodb.putItem({
+    return await clients.dynamodb.putItem({
         TableName : table,
         Item : { ...convert_input(key).M, ...convert_input(attributes).M }
     })
 }
 
-export async function dynamodb_delete(dynamodb, table, key) {
-    return await dynamodb.deleteItem({
+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(dynamodb, table, attribute_name, new_attribute_name) {
-    const table_key_names = await dynamodb.describeTable({
+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]))
@@ -269,8 +269,8 @@ export async function dynamodb_duplicate_attribute(dynamodb, table, attribute_na
     }
 }
 
-export async function dynamodb_remove_attribute(dynamodb, table, attribute_name) {
-    const table_key_names = await dynamodb.describeTable({
+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)

package/email.js

@@ -0,0 +1,20 @@
+export async function send_email(recipient, subject, text) {
+    for (let i = 0; i < 3; i++) {
+        try {
+            await transporter.sendMail({
+                from: config.alerts_email,
+                to: recipient,
+                subject: subject,
+                text: text
+            })
+            return
+        } catch (error) {
+            console.log("EMAIL ERROR", error)
+        }
+    }
+}
+
+export async function admin_alert(text) {
+    console.log("ADMIN ALERT:", text)
+    await send_email(config.google_email, "ADMIN ALERT", text)
+}

package/index.js

@@ -1,12 +1,32 @@
-import * as utils_dynamodb from "./dynamodb.js"
 
+import nodemailer from "nodemailer"
 import { DynamoDB } from "@aws-sdk/client-dynamodb"
 
-export function get_utils(config) {
+import * as utils_dynamodb from "./dynamodb.js"
+import * as utils_misc from "./misc.js"
+
+export default function get_utils(config) {
+    const clients = {}
+    if (config.region !== undefined) {
+        clients.dynamodb = new DynamoDB({ region : config.region })
+    }
+    if (config.google_email !== undefined && config.google_app_password) {
+        clients.transporter = nodemailer.createTransport({
+            service: "Gmail",
+            host: "smtp.gmail.com",
+            port: 465,
+            secure: true,
+            auth: {
+                user: config.google_email,
+                pass: config.google_app_password,
+            }
+        })
+    }
     const utils = {}
-    const dynamodb = new DynamoDB({ region : config.region })
-    for (const util of utils_dynamodb) {
-        utils[util.name] = async (...args) => await util(dynamodb, ...args)
+    for (const utils_list of [utils_misc, utils_dynamodb]) {
+        for (const [util_name, util] of Object.entries(utils_list)) {
+            utils[util_name] = async (...args) => await util(clients, ...args)
+        }
     }
     return utils
-}
+}

package/misc.js

@@ -0,0 +1,98 @@
+import config from "../config.js"
+import election_ids from "./election_ids.js"
+import nodemailer from "nodemailer"
+import crypto from "crypto"
+import * as dynamo from "./dynamodb.js"
+
+export async function wait(client, duration) {
+    return new Promise(resolve => setTimeout(resolve, duration))
+}
+
+export function get_current_time(client, milliseconds = false) {
+    if (milliseconds) {
+        return (new Date()).getTime()
+    }
+    return (new Date()).toISOString()
+}
+
+export async function send_email(recipient, subject, text) {
+    for (let i = 0; i < 3; i++) {
+        try {
+            await transporter.sendMail({
+                from: config.alerts_email,
+                to: recipient,
+                subject: subject,
+                text: text
+            })
+            return
+        } catch (error) {
+            console.log("EMAIL ERROR", error)
+        }
+    }
+}
+
+export async function admin_alert(text) {
+    console.log("ADMIN ALERT:", text)
+    await send_email(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(error.stack.toString())
+        } else {
+            await admin_alert(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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "triangle-utils",
-    "version": "1.0.3",
+    "version": "1.0.5",
     "main": "index.js",
     "author": "",
     "license": "ISC",