@goniglep57/node 1.0.0

package/alerts.js

@@ -0,0 +1,103 @@
+const nodemailer = require('nodemailer')
+
+let transporter = null
+let config = null
+
+/**
+ * Configure the alerts module with Gmail credentials
+ * @param {Object} options - Configuration options
+ * @param {string} options.gmailUser - Gmail address to send from
+ * @param {string} options.gmailAppPassword - Gmail App Password (not regular password)
+ * @param {string} options.to - Default recipient email address
+ * @param {string} [options.defaultSubject='Alert'] - Default email subject
+ */
+const configure = (options) => {
+    const { gmailUser, gmailAppPassword, to, defaultSubject = 'Alert' } = options
+
+    if (!gmailUser || !gmailAppPassword || !to) {
+        throw new Error('alerts.configure requires gmailUser, gmailAppPassword, and to')
+    }
+
+    config = {
+        from: gmailUser,
+        to,
+        defaultSubject
+    }
+
+    transporter = nodemailer.createTransport({
+        service: 'gmail',
+        auth: {
+            user: gmailUser,
+            pass: gmailAppPassword
+        }
+    })
+
+    return { configured: true }
+}
+
+/**
+ * Send an alert email
+ * @param {string|Object} messageOrOptions - Message string or options object
+ * @param {string} [messageOrOptions.message] - Email body content
+ * @param {string} [messageOrOptions.subject] - Email subject (overrides default)
+ * @param {string} [messageOrOptions.to] - Recipient email (overrides default)
+ * @param {boolean} [messageOrOptions.html=false] - Whether message is HTML
+ * @returns {Promise<Object>} - Nodemailer send result
+ */
+const send = async (messageOrOptions) => {
+    if (!transporter || !config) {
+        throw new Error('alerts not configured. Call alerts.configure() first')
+    }
+
+    let message, subject, to, html
+
+    if (typeof messageOrOptions === 'string') {
+        message = messageOrOptions
+        subject = config.defaultSubject
+        to = config.to
+        html = false
+    } else {
+        message = messageOrOptions.message
+        subject = messageOrOptions.subject || config.defaultSubject
+        to = messageOrOptions.to || config.to
+        html = messageOrOptions.html || false
+    }
+
+    if (!message) {
+        throw new Error('Message is required')
+    }
+
+    const mailOptions = {
+        from: config.from,
+        to,
+        subject,
+        [html ? 'html' : 'text']: message
+    }
+
+    const result = await transporter.sendMail(mailOptions)
+    return result
+}
+
+/**
+ * Check if alerts module is configured
+ * @returns {boolean}
+ */
+const isConfigured = () => {
+    return transporter !== null && config !== null
+}
+
+/**
+ * Reset configuration (useful for testing)
+ */
+const reset = () => {
+    transporter = null
+    config = null
+}
+
+module.exports = {
+    configure,
+    send,
+    isConfigured,
+    reset
+}
+

package/dropbox.js

@@ -0,0 +1,274 @@
+const { objectToUriParams } = require('./util.js')
+
+const DROPBOX_AUTH_TOKEN_URI = process.env.DROPBOX_AUTH_TOKEN_URI
+const DROPBOX_AUTH_SHARED_SECRET = process.env.DROPBOX_AUTH_SHARED_SECRET
+const DROPBOX_API_URI = process.env.DROPBOX_API_URI || 'https://api.dropboxapi.com/2'
+
+const Dropbox = (httpClient, config={retry:false}) => {
+    const data = {}
+
+    const getHeaders = (teamCall=false) => {
+        const headers = { 'Authorization': `Bearer ${data.access_token}`, 'Content-Type': 'application/json' }
+        if (data.dropboxUser && !teamCall) {
+            headers['Dropbox-API-Select-User'] = data.dropboxUser
+            if(data.namespace){
+                headers['Dropbox-API-Path-Root'] = `{".tag": "namespace_id", "namespace_id": "${data.namespace}"}`
+            } else {
+                headers['Dropbox-API-Path-Root'] = `{".tag": "home"}`
+            }
+        }
+
+        return { headers }
+    }
+
+    const setUser = (userId) => {
+        data.dropboxUser = userId
+    }
+
+    const setNamespace = (namespaceId) => {
+        data.namespace = namespaceId
+    }
+
+    const setToken = (token) => {
+        data.access_token = token
+    }
+
+    const manualRefreshToken = async (refresh_token, client_id, client_secret) => {
+        const creds = Buffer.from(`${client_id}:${client_secret}`).toString('base64')
+        const response = await httpClient.post(
+            'https://api.dropboxapi.com/oauth2/token',
+            new URLSearchParams({
+                grant_type: 'refresh_token',
+                refresh_token: refresh_token
+            }).toString(),
+            {
+                headers: {
+                    'Authorization': `Basic ${creds}`,
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                }
+            }
+        )
+
+        data.access_token = response.data.access_token
+
+        return response.data
+    }
+
+    const getAccessToken = async (dropboxAccountId) => {
+        const response = await httpClient.get(`${DROPBOX_AUTH_TOKEN_URI}${dropboxAccountId}`, {
+            headers: {
+                'x-shared-secret': DROPBOX_AUTH_SHARED_SECRET
+            }
+        })
+        data.access_token = response.data.access_token
+        data.dropbox_account_id = dropboxAccountId
+        return response.data
+    }
+
+    const getTemporaryLink = async (data) => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/files/get_temporary_link`, data, getHeaders())
+        return response.data
+    }
+
+    const listFolder = async (body) => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/files/list_folder`, body, getHeaders())
+        return response.data
+    }
+
+    const listFolderContinue = async (body) => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/files/list_folder/continue`, body, getHeaders())
+        return response.data
+    }
+
+    const getMetadata = async (body) => {
+        try {
+            const response = await httpClient.post(`${DROPBOX_API_URI}/files/get_metadata`, body, getHeaders())
+            console.log(response.data)
+            return response.data
+        } catch (err) {
+            // Also handle if error is thrown as part of response exception (e.g. non-2xx)
+            if (err.response?.data?.error_summary === 'path/not_found/') {
+                console.error('Path not found in dropbox', body)
+                return null
+            }
+            // throw err
+            console.error(err.message)
+            // throw err
+        }
+    }
+
+    const getSharedLinkMetadata = async (body) => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/sharing/get_shared_link_metadata`, body, getHeaders())
+        return response.data
+    }
+
+    const getLatestCursor = async (body) => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/files/list_folder/get_latest_cursor`, body, getHeaders())
+        return response.data
+    }
+
+    const convertOAuth2Token = async (body) => {
+        //the body here is converted into a uri params string
+        // OAuth2 token endpoint is separate from API v2 endpoints
+        const uriParams = objectToUriParams(body)
+        const response = await httpClient.post(`https://api.dropbox.com/oauth2/token?${uriParams}`, null, {})
+        data.access_token = response.data.access_token
+        return response.data
+    }
+
+    const teamGetInfo = async () => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/team/get_info`, null, getHeaders(true))
+        return response.data
+    }
+
+    const teamMemebersList = async () => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/team/members/list`, null, getHeaders(true))
+        return response.data
+    }
+
+    const teamNamespacesList = async () => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/team/namespaces/list`, null, getHeaders(true))
+        return response.data
+    }
+
+    const teamNamespacesListContinue = async (body) => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/team/namespaces/list/continue`, body, getHeaders(true))
+        return response.data
+    }
+
+    const retryOnExpiredToken = (cb) => {
+        return async(...args) => {
+            try {
+                return await cb(...args)
+            } catch (err) {
+                // Handle Dropbox expired auth token error
+                if (err.response?.data?.error_summary?.includes('expired_access_token')) {
+                    console.error('Dropbox auth token expired:', err.message)
+                    await getAccessToken(data.dropbox_account_id)
+                    return cb(...args)
+                }
+                console.error(err.message)
+                throw err
+            }
+        }
+    }
+
+    const retryOnServerError = (cb, maxRetries = 3, delayMs = 1000) => {
+        return async (...args) => {
+            let lastError
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                try {
+                    return await cb(...args)
+                } catch (err) {
+                    lastError = err
+                    // Only retry on 500 server errors
+                    if (err.response?.status === 500 && attempt < maxRetries) {
+                        console.error(`Dropbox 500 error (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delayMs}ms...`)
+                        await new Promise((resolve) => setTimeout(resolve, delayMs))
+                        continue
+                    }
+                    throw err
+                }
+            }
+            throw lastError
+        }
+    }
+
+    const retryOnRateLimit = (cb, maxRetries = 5, initialDelayMs = 1000) => {
+        return async (...args) => {
+            let lastError
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                try {
+                    return await cb(...args)
+                } catch (err) {
+                    lastError = err
+                    // Retry on 429 rate limit with exponential backoff
+                    if (err.response?.status === 429 && attempt < maxRetries) {
+                        // Check if Dropbox sent a Retry-After header
+                        const retryAfter = err.response?.headers?.['retry-after']
+                        const delay = retryAfter 
+                            ? parseInt(retryAfter, 10) * 1000 
+                            : initialDelayMs * Math.pow(2, attempt)
+                        console.error(`Dropbox rate limit 429 (attempt ${attempt + 1}/${maxRetries + 1}), retrying in ${delay}ms...`)
+                        await new Promise((resolve) => setTimeout(resolve, delay))
+                        continue
+                    }
+                    throw err
+                }
+            }
+            throw lastError
+        }
+    }
+
+    const getCurrentAccount = async () => {
+        const response = await httpClient.post(`${DROPBOX_API_URI}/users/get_current_account`, null, getHeaders())
+        return response.data
+    }
+
+    const createFolder = async (path) => {
+        const response = await httpClient.post(
+            `${DROPBOX_API_URI}/files/create_folder_v2`,
+            { path, autorename: false },
+            getHeaders()
+        )
+        return response.data
+    }
+
+    const createSharedLink = async (path) => {
+        try {
+            const response = await httpClient.post(
+                `${DROPBOX_API_URI}/sharing/create_shared_link_with_settings`,
+                { path, settings: { requested_visibility: { '.tag': 'public' } } },
+                getHeaders()
+            )
+            return response.data.url
+        } catch (err) {
+            // If link already exists, get the existing one
+            if (err.response?.data?.error_summary?.includes('shared_link_already_exists')) {
+                const listResponse = await httpClient.post(
+                    `${DROPBOX_API_URI}/sharing/list_shared_links`,
+                    { path, direct_only: true },
+                    getHeaders()
+                )
+                if (listResponse.data.links && listResponse.data.links.length > 0) {
+                    return listResponse.data.links[0].url
+                }
+            }
+            throw err
+        }
+    }
+
+    const exportFunctions = {
+        getTemporaryLink,
+        listFolder,
+        listFolderContinue,
+        getMetadata,
+        getSharedLinkMetadata,
+        getLatestCursor,
+        convertOAuth2Token,
+        teamGetInfo,
+        getCurrentAccount,
+        teamMemebersList,
+        teamNamespacesList,
+        createFolder,
+        createSharedLink
+    }
+    for (const key in exportFunctions) {
+        if(config.retry === true){
+            exportFunctions[key] = retryOnExpiredToken(exportFunctions[key])
+        } 
+        exportFunctions[key] = retryOnRateLimit(exportFunctions[key])
+        exportFunctions[key] = retryOnServerError(exportFunctions[key])
+    }
+
+    exportFunctions.getAccessToken = getAccessToken
+    exportFunctions.convertOAuth2Token = convertOAuth2Token
+    exportFunctions.setUser = setUser
+    exportFunctions.setNamespace = setNamespace
+    exportFunctions.setToken = setToken
+    exportFunctions.manualRefreshToken = manualRefreshToken
+
+    return exportFunctions
+}
+
+module.exports = Dropbox

package/index.js

@@ -0,0 +1,7 @@
+//generator:exportdir
+exports.alerts = require('./alerts.js')
+exports.dropbox = require('./dropbox.js')
+exports.ncrypt = require('./ncrypt.js')
+exports.secret = require('./secret.js')
+exports.server = require('./server.js')
+exports.util = require('./util.js')

package/ncrypt.js

@@ -0,0 +1,67 @@
+const crypto = require("crypto")
+
+const pubKeyEncrypt = (toEncrypt, pubKey) => {
+    const buffer = Buffer.from(toEncrypt);
+    const encrypted = crypto.publicEncrypt(pubKey, buffer)
+    return encrypted.toString('base64')
+}
+
+const privateKeyDecrypt = (toDecrypt, privateKey) => {
+    const buffer = Buffer.from(toDecrypt, 'base64');
+    const decrypted = crypto.privateDecrypt(privateKey, buffer)
+    return decrypted.toString('utf-8')
+}
+
+const symKeyEncrypt = (toEncrypt, symKey) => {
+    const iv = crypto.randomBytes(16)
+    const cipher = crypto.createCipheriv('aes256', symKey, iv)
+    let cipheredData = cipher.update(toEncrypt, 'utf-8', 'hex') + cipher.final('hex')
+    const message = `${iv.toString('hex')}-${cipheredData}`
+    return message
+}
+
+const symKeyDecrypt = (toDecrypt, symKey) => {
+    const [iv, ...data] = toDecrypt.split('-')
+    const decipher = crypto.createDecipheriv('aes256', symKey, Buffer.from(iv, 'hex'))
+    const deciphered = decipher.update(data.join('-'), 'hex', 'utf-8') + decipher.final('utf-8')
+    return deciphered
+}
+
+const hybridEncrypt = (toEncrypt, pubKey) => {
+    const symKey = crypto.randomBytes(32)
+    const encryptedSymKey = pubKeyEncrypt(symKey.toString('hex'), pubKey)
+    const encryptedData = symKeyEncrypt(toEncrypt, symKey)
+    return `${encryptedSymKey}-${encryptedData}`
+
+}
+
+const hybridDecrypt = (toDecrypt, privateKey) => {
+    const [encryptedSymKey, ...hybridData] = toDecrypt.split('-')
+    const symKey = Buffer.from(privateKeyDecrypt(encryptedSymKey, privateKey), 'hex')
+    const message = symKeyDecrypt(hybridData.join('-'), symKey, 'hex')
+    return message
+}
+
+// Hashing functions
+const md5 = (data) => {
+    return crypto.createHash('md5').update(data, 'utf-8').digest('hex')
+}
+
+const sha1 = (data) => {
+    return crypto.createHash('sha1').update(data, 'utf-8').digest('hex')
+}
+
+module.exports = {
+    pubKeyEncrypt,
+    privateKeyDecrypt,
+    symKeyEncrypt,
+    symKeyDecrypt,
+    hybridEncrypt,
+    hybridDecrypt,
+    encrypt: hybridEncrypt,
+    decrypt: hybridDecrypt,
+    hash: {
+        md5,
+        sha1
+    }
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@goniglep57/node",
+  "version": "1.0.0",
+  "description": "A package full of utility functions",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.957.0",
+    "@aws-sdk/client-sqs": "^3.957.0",
+    "nodemailer": "^6.9.16"
+  }
+}

package/readme.md

@@ -0,0 +1,12 @@
+# Common packages
+
+These are common packages that are used across the monorepo
+
+## env required
+
+### secret.js
+
+Production requirement:
+PRODUCTION_SECRET_NAME
+PRODUCTION_PUBLIC_KEY
+PRODUCTION_PRIVATE_KEY

package/secret.js

@@ -0,0 +1,63 @@
+const getSecretName = () => {
+    if(true ||process.env.NODE_ENV !== 'production'){
+        return 'local'
+    }
+    return PRODUCTION_SECRET_NAME
+}
+
+const getSecret = async (secretName) => {
+    if(true ||process.env.NODE_ENV !== 'production'){
+        return {
+            name:'local',
+            publicKey:`-----BEGIN PUBLIC KEY-----
+MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAoKPg+zo58M1u/YRTbm2H
+3zGzyUWLo5dSI/j9woqv6XfBZeVKeTJPqcy3IaciGB1euppmu4eEzHLFijHeoO23
+C1KffrHTJV8wk6Tm3pXuYfdKm+2sowpmHmzD1boMPKAUckSKg7vFWZxg1Xis4Cco
+eq1cGpNxeB1e8hGYv1Hf3sus1oTh4bHaiLmaSNLYWXws2VvzN4W4w5ezbz4hvSV8
+LKCMPNyzOcOT6ffGQueIsUMAhVZqeNdriExNeC6J+7CCh4kYiFzbRqvMH+GCwtoK
+i3qL4RYTaPdikQWmsxJ+Pza136b6PfG1KU/v8zF+YmwQRg6IpKs7Xo7/CHKEvQ9I
+GwIDAQAB
+-----END PUBLIC KEY-----`,
+            privateKey:`-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCgo+D7OjnwzW79
+hFNubYffMbPJRYujl1Ij+P3Ciq/pd8Fl5Up5Mk+pzLchpyIYHV66mma7h4TMcsWK
+Md6g7bcLUp9+sdMlXzCTpObele5h90qb7ayjCmYebMPVugw8oBRyRIqDu8VZnGDV
+eKzgJyh6rVwak3F4HV7yEZi/Ud/ey6zWhOHhsdqIuZpI0thZfCzZW/M3hbjDl7Nv
+PiG9JXwsoIw83LM5w5Pp98ZC54ixQwCFVmp412uITE14Lon7sIKHiRiIXNtGq8wf
+4YLC2gqLeovhFhNo92KRBaazEn4/NrXfpvo98bUpT+/zMX5ibBBGDoikqztejv8I
+coS9D0gbAgMBAAECggEAA4FP6Wtt1DlHULTQdTpimpYlDCE+WMV2f15xews3p2p7
+h9Om+loErvnOjSducQRDCuNPlovwc92VPdy0tOI6+j5FSKhsqQYYs0AH4Zd36h9R
+O3HGMJCLheJtq34xwijkCVJBi3pPZhMpcb7+Vq3EDlk2B0ZsVWiep72GjbYlomDa
+fL3nQrTTStBv7P61HMeLR0HZzvaOM/OvyyZswqgiOw3vbp8GYrm9YHDNcZhwADmH
+y5kVvHuCOXQqicrDupKBLLT4HtDLj7KnRwabVg5gTbQNC26/1z2KNH/6rKNVELCb
+c2jFNqEYg1YSgJe3yl8CVFhGqsvjDKMoAdooU0CEkQKBgQDOObvjqFlAr4WVQ+0r
+/M9u3XL3hg7ucAuO0Kbkcw11IgBS+oHFClfZBSucaW9Jqowje9lVaenTsRoPmLgq
+UbU4UygIhnBYA3HmZpwWxcK3QNCFO3icI0BAhuooxKb3JzhT61CbH44nTaPjf2Y4
+oLiNwebzzU1vyaqbQrt2wTEWjwKBgQDHaYPj+lC5a7DYAeth+yt6h1gkuOrx+mos
+tGRp2d3dp2sld58i3LDQWA4QW3XP6iekn1nBWpww6QdHMIEzYrCBIE2UhYT4nLK9
+rjFOgrE4EPS5C1X80uUPxbA6JqGlKk/9syJYELpalKzLK24c7IXpv3sum3lkXyYn
+cNRh3xLbtQKBgFv7Nkmpef23C/7yqCN5hE/vp+qtOZWyFgWiHP5CLttyyfA42Y64
+OUyL2NLP2BpkXlMpV1uYfPm1wWj5dhMyFIFF3dJHnG41QyU/2RjzJhE0cI0sZHRH
+6M2fH2wFom8UaDRN/crivTXclF/RIBfb39Uiik9t378flN/hWNnz+2ATAoGBAJos
+/GoRKMSTfKElqsWQmmcbqYyK5Cu+fsSdnF0ysxUi0faf7AvaMWKEEiuXaxkbYxcm
+lRCna8dtA9GIsPv3u5u6TAEe0lYdYRzCRyD6buZ4RZ2kJBFbRPrSz5PGNogqlLoD
++/O2yz4pYQecRoBaZpb5EtZQIqT149vuomYhQMVZAoGBAI/XzOvY28QeFOES9oMl
+vrqTC28Rn6qOeZ/JKoDI1u33JaldiuU8PzF2kTxwAweIojF96lLB5o1fjmKi0Tku
+4qt8Snv20TIj4+Y9MuH+ullgR6kMqviH+pZ1uxQYUax5NdIWBN6c1SrV1EhBmtzZ
+aAfsaNXTVik3/tuvd8ushVWC
+-----END PRIVATE KEY-----`
+        }
+    }
+
+    return {
+        name: PRODUCTION_SECRET_NAME,
+        publicKey: PRODUCTION_PUBLIC_KEY,
+        privateKey: PRODUCTION_PRIVATE_KEY
+    }
+}
+
+module.exports = {
+    getSecretName,
+    getSecret
+}
+

package/server.js

@@ -0,0 +1,78 @@
+const addDbOnApiRoute = (app, pool, {baseRoute='/api'}) => {
+    app.use(baseRoute, async (req, res, next)=>{
+        try{
+            const client = await pool.connect()
+            res.locals.client = client
+            next()
+        } catch(e){
+            console.error(e)
+            res.status(400)
+            res.json({error:e.message})
+            client.release()
+        }
+    })
+    return app
+}
+//dynamically add routes based on ./routes/index.js
+// return {status:<status>, message:<message>} from each route
+// JSON, strings and files are supported, files must be an absolute path
+
+const dynamicRoutes = (app, router) => {
+    Object.values(router).forEach(({method, route, handler})=>{
+        app[method](route, async(req, res)=>{
+            try{
+                const returnVal = await handler(req, res.locals.client)
+                if(returnVal instanceof Function){
+                    returnVal(res)
+                }else{
+                    if(typeof returnVal.message === 'string'){
+                        if(returnVal.message.startsWith('/')){
+                            res.status(returnVal.status)
+                            res.sendFile(returnVal.message)
+                        }else{
+                            res.status(returnVal.status)
+                            res.send(returnVal.message)
+                            res.end()
+                        }
+                    }else if(typeof returnVal.message === 'object'){
+                        res.status(returnVal.status)
+                        res.json(returnVal.message)
+                        res.end()
+                    }
+                }
+            } catch(e){
+                console.error(e)
+                res.status(501)
+                res.end()
+            }finally{
+                console.log('end')
+                if(res.locals.client){
+                    res.locals.client.release()
+                }
+            }
+        })
+    })
+}
+
+
+const defaultServer = (express, pool, router, config={apiBaseRoute:'/api'}) => {
+    const app = express()
+    app.use(express.json({ limit: '5mb' }));
+    app.use(express.urlencoded({ extended: true })); // uses qs when true
+
+    addDbOnApiRoute(app, pool, {baseRoute:config.apiBaseRoute})
+    dynamicRoutes(app, router)
+
+    const server = app.listen(process.env.PORT,process.env.HOST)
+
+    console.log('port', process.env.PORT)
+
+    return {app, server}
+}
+
+
+module.exports = {
+    dynamicRoutes,
+    addDbOnApiRoute,
+    defaultServer
+}

package/tests/index.test.js

@@ -0,0 +1,67 @@
+const { objectToUriParams } = require('../util.js')
+const { encrypt, decrypt } = require('../ncrypt.js')
+const { getSecretName, getSecret } = require('../secret.js')
+
+// this is not actually a test framework
+// all the functions are compatible with jest though
+const describe = (name, fn) => {
+    console.log(`describe: ${name}`)
+    fn()
+}
+
+const it = (name, fn) => {
+    console.log(`it: ${name}`)
+    fn()
+}
+
+const expect = (result) => {
+    return {
+        toBe: (expected) => {
+            if (result !== expected) {
+                throw new Error(`Expected ${result} to be ${expected}`)
+            }
+        }
+    }
+}
+
+//end mocks for jests
+
+describe('objectToUriParams', () => {
+    it('should convert an object to a URI string', () => {
+        const obj = {
+            a: 1,
+            b: 2,
+            c: 'hello world',
+            d: ' !@#$%^&*()_+-=[]{}|;:\'",.<>/?`~\n\t\r'
+        }
+        const result = objectToUriParams(obj)
+
+        const expected = [
+            `a=${encodeURIComponent(obj.a)}`,
+            `b=${encodeURIComponent(obj.b)}`,
+            `c=${encodeURIComponent(obj.c)}`,
+            `d=${encodeURIComponent(obj.d)}`
+        ].join('&')
+        expect(result).toBe(expected)
+    })
+})
+
+describe('encrypt', () => {
+    it('works', async () => {
+        const toEncrypt = {
+            access_token: 'averylongnotrealaccesstokensG0Ttoopo44t0xJfj1bljseyyHL0W0by3-Zjpu5tlAoHN_PKOelWTI7hwvvNkEdrM-jnKtUszuMlS7nAK3Y0x-m0ptTHoeVPZPE5jl-NNT52q17qZn0z0tlRBzHIpyKEiiofQ6mnUy7Lrz-hrXxvTWV_ug0HG6FqYruk-tmSUZJkKMwsdcWS1xZKdd5h8oxYScm5-gLnwd3Zal9-NTQCEob5WyBBBWU7PsNVmewesqpEOaQDanT8jiyn7ul0XJhLS1141o5_GeD1Z9gw-tmWqtlZO13O9Miz-1gDD-lNsWTKF3KkneqoAUUsMPegz_R5Cax43UYTXoTqahT4lJEYx_tbLiDAVel5FIgU6KrB5zS9lOv0_o42nunH-xmX8OWrU6l5yPShr9xiXkuyi2_Yv4y8QW5sAYMg4G4I8iJON5pH8RuPPtnSOwq7KNp7EBCb7u_St2dOcVRYCZjK5RgJK0jcp4PspUbNRNLenAbAHRe9u8PKilmo1iVafV2EmobC3WweaTF_Tbbc1U7tQEUuYnAES2KOSugsyDXNBMv283LkIjCaRW11jSA12_nubWBBHu_zxdSS3j61TR8DCkWppzd_1Um2n9kK3RB7q94wh0IANZxFJ4cS8vUvUU8Wphq4QMxIng9a-IkN99aKsIgRI95HB-eVvcbFT6jqpUpgmZgBS8uvIULmgVT-1Zs6C4UKrN16qWfc5MR_wnNjSIcIiP-pUkVmLmqOOMZM9llpD-eMrgS17xDG7lwSrFmZEEHQeaVWNhBOylivToBPMvMF5vunVNpaZas4N_1tzCP3MhH00LIYjCFoBcpPvV5IgHD3peF9R_qrMnsev2n4nY4C25IXK3cCldFw0uSDRL1rEqkaxFYwsKOqfVNI6YO8om_p8IuoD9yJ15aeZJPwsqZpEFcV04Ag1e6GMC5LmiqQ2u1iRyrbkBADChqTBabo3bU_hfwaureOtmUKkYFDymKolLxsHj1FZwqzH5qmi95yewGs_UpX81tQqZopAJb5othTKw4J_5yt3LBm7LW1uNGrYpulC38m8hU9pwKq3mj8v95H9fyONLlEUMKOctzDBxgZlV5EEGnfXYuWEvv9Vv3QuULSEj_fvcuXgDfKp_y2JB6NMV57Dhn5xkFMLpstXk9R97IIMI8tSED0A',
+            token_type: 'bearer',
+            expires_in: 14400,
+            scope: 'account_info.read',
+            uid: '2706081665',
+            account_id: 'dbid:OIUYZb6mgUwwAFf5xJeb-8zFExUJKqtrnDo'
+          }
+          
+    
+        const secretName = await getSecretName()
+        const secret = await getSecret(secretName)
+        const encrypted = encrypt(JSON.stringify(toEncrypt), secret.publicKey)
+        const decrypted = decrypt(encrypted, secret.privateKey)
+        expect(decrypted).toBe(JSON.stringify(toEncrypt))
+    })
+})

package/tests/rate-limit-test.js

@@ -0,0 +1,61 @@
+/**
+ * Quick test to verify the rate limit retry logic works correctly
+ * Run with: node tests/rate-limit-test.js
+ */
+
+const Dropbox = require('../dropbox.js')
+
+// Mock axios that returns 429 twice, then succeeds
+const createMockAxios = () => {
+    let callCount = 0
+    return {
+        post: async (url, data, config) => {
+            callCount++
+            console.log(`[Mock] API call #${callCount} to ${url}`)
+            
+            if (callCount <= 2) {
+                // Simulate 429 rate limit for first 2 calls
+                const error = new Error('Rate limited')
+                error.response = { status: 429 }
+                throw error
+            }
+            
+            // Success on 3rd call
+            return { data: { link: 'https://example.com/temp-link' } }
+        },
+        get: async (url, config) => {
+            // Mock getAccessToken
+            return { data: { access_token: 'mock-token' } }
+        }
+    }
+}
+
+const runTest = async () => {
+    console.log('=== Testing Rate Limit Retry Logic ===\n')
+    
+    const mockAxios = createMockAxios()
+    const dropbox = Dropbox(mockAxios)
+    
+    // Set a mock token
+    dropbox.setToken('mock-token')
+    
+    console.log('Calling getTemporaryLink (should fail twice, then succeed)...\n')
+    
+    const startTime = Date.now()
+    
+    try {
+        const result = await dropbox.getTemporaryLink({ path: '/test/file.jpg' })
+        const elapsed = Date.now() - startTime
+        
+        console.log(`\n✅ SUCCESS! Got result after ${elapsed}ms:`, result)
+        console.log('\nThe retry logic is working correctly!')
+        console.log('- First call: 429 → waited ~1000ms → retried')
+        console.log('- Second call: 429 → waited ~2000ms → retried')
+        console.log('- Third call: Success!')
+    } catch (error) {
+        console.log('\n❌ FAILED:', error.message)
+        process.exit(1)
+    }
+}
+
+runTest()

package/util.js

@@ -0,0 +1,11 @@
+
+const objectToUriParams = obj => {
+    return Object.entries(obj)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+        .join('&')
+}
+
+
+module.exports = {
+    objectToUriParams
+}