@1auth/store-sql 0.0.0-alpha.6 → 0.0.0-alpha.60

package/index.js

@@ -1,9 +1,14 @@
 const options = {
   log: false,
-  query: (sql, parameters) => {
-    console.log('sql', sql, parameters)
-    return {}
-  }
+  query: undefined, // async (sql, parameters) => {}
+  // number of seconds after expire before removal
+  // 10d chosen based on EFF DNT Policy
+  timeToLiveExpireOffset: 10 * 24 * 60 * 60,
+  timeToLiveKey: 'remove',
+  // mode:
+  // ?: use `?` for variables, ie sqlite
+  // $: use `$1` for variables, ie postgres
+  placeholder: '?'
 }
 
 export default (params) => {
@@ -11,30 +16,106 @@ export default (params) => {
 }
 
 export const exists = async (table, filters) => {
-  const item = await select(table, filters)
-  return item?.sub
+  if (options.log) {
+    options.log('@1auth/store-sql exists(', table, filters, ')')
+  }
+  const { select, where, parameters } = makeSqlParts(filters, {}, ['sub'])
+  const sql = `SELECT ${select} FROM ${table} ${where} LIMIT 1`
+  return await options.query(sql, parameters).then((res) => res?.[0]?.sub)
 }
 
-export const selectList = async (table, filters = {}, fields = []) => {
-  const { select, where, parameters } = makeSqlParts(filters, {}, fields)
-  const sql = `SELECT ${select} FROM ${table} ${where}`
-  return await options.query(sql, parameters)
+export const count = async (table, filters = {}) => {
+  if (options.log) {
+    options.log('@1auth/store-sql count(', table, filters, ')')
+  }
+  const { where, parameters } = makeSqlParts(filters, {})
+  const sql = `SELECT COUNT(*) AS count FROM ${table} ${where}`
+  return await options.query(sql, parameters).then((res) => res[0].count)
 }
 
 export const select = async (table, filters = {}, fields = []) => {
+  if (options.log) {
+    options.log('@1auth/store-sql select(', table, filters, fields, ')')
+  }
   const { select, where, parameters } = makeSqlParts(filters, {}, fields)
   const sql = `SELECT ${select} FROM ${table} ${where} LIMIT 1`
-  return await options.query(sql, parameters).then((res) => res[0])
+  return await options
+    .query(sql, parameters)
+    .then((res) => res?.[0])
+    // Workaround because an expire filter doesn't exists yet'
+    .then((row) => {
+      parseValues(row)
+      return row
+    })
+}
+
+export const selectList = async (table, filters = {}, fields = []) => {
+  if (options.log) {
+    options.log('@1auth/store-sql selectList(', table, filters, fields, ')')
+  }
+  const { select, where, parameters } = makeSqlParts(filters, {}, fields)
+  const sql = `SELECT ${select} FROM ${table} ${where}`
+  return await options
+    .query(sql, parameters)
+    // Workaround because an expire filter doesn't exists yet'
+    .then((rows) => {
+      return rows.map((row) => {
+        parseValues(row)
+        return row
+      })
+    })
 }
 
 export const insert = async (table, values = {}) => {
+  if (options.log) {
+    options.log('@1auth/store-sql insert(', table, values, ')')
+  }
+  if (values.expire && options.timeToLiveKey) {
+    values[options.timeToLiveKey] =
+      values.expire + options.timeToLiveExpireOffset
+  }
+  values = structuredClone(values)
   normalizeValues(values)
   const { insert, parameters } = makeSqlParts({}, values)
-  const sql = `INSERT INTO ${table} ${insert}`
-  return await options.query(sql, parameters).then((res) => res.id)
+  const sql = `INSERT INTO ${table} ${insert} RETURNING id`
+  const res = await options.query(sql, parameters)
+  return res.id
+}
+
+export const insertList = async (table, rows = []) => {
+  if (options.log) {
+    options.log('@1auth/store-sql insertList(', table, rows, ')')
+  }
+  const insertValues = []
+  let insertParameters = []
+  for (let i = 0, l = rows.length; i < l; i++) {
+    const values = structuredClone(rows[i])
+    normalizeValues(values)
+    const { insert, parameters } = makeSqlParts(
+      {},
+      values,
+      [],
+      i * Object.keys(values).length + 1
+    )
+    if (i) {
+      insertValues.push(insert.split('VALUES')[1]) // (?)
+    } else {
+      insertValues.push(insert) // (name) VALUES (?)
+    }
+
+    insertParameters = insertParameters.concat(parameters)
+  }
+
+  const sql = `INSERT INTO ${table} ${insertValues.join(',')} RETURNING id`
+  const res = await options.query(sql, insertParameters)
+  return res
 }
 
 export const update = async (table, filters = {}, values = {}) => {
+  if (options.log) {
+    options.log('@1auth/store-sql update(', table, filters, values, ')')
+  }
+  values = structuredClone(values)
   normalizeValues(values)
   const { update, where, parameters } = makeSqlParts(filters, values)
   const sql = `UPDATE ${table} SET ${update} ${where}`
@@ -42,56 +123,91 @@ export const update = async (table, filters = {}, values = {}) => {
 }
 
 export const remove = async (table, filters = {}) => {
+  if (options.log) {
+    options.log('@1auth/store-sql remove(', table, filters, ')')
+  }
   const { where, parameters } = makeSqlParts(filters)
   const sql = `DELETE FROM ${table} ${where}`
   await options.query(sql, parameters)
 }
 
 const normalizeValues = (values) => {
+  if (!values) return
   values.create &&= new Date(values.create * 1000).toISOString()
   values.update &&= new Date(values.update * 1000).toISOString()
   values.verify &&= new Date(values.verify * 1000).toISOString()
+  values.lastused &&= new Date(values.lastused * 1000).toISOString()
   values.expire &&= new Date(values.expire * 1000).toISOString()
+  values.remove &&= new Date(values.remove * 1000).toISOString()
+}
+
+const parseValues = (values) => {
+  if (!values) return
+  values.create &&= Date.parse(values.create) / 1000
+  values.update &&= Date.parse(values.update) / 1000
+  values.verify &&= Date.parse(values.verify) / 1000
+  values.lastused &&= Date.parse(values.lastused) / 1000
+  values.expire &&= Date.parse(values.expire) / 1000
+  values.remove &&= Date.parse(values.remove) / 1000
 }
 
 // export for testing
-export const makeSqlParts = (filters = {}, values = {}, fields = []) => {
+export const getPlaceholder = (idx) => {
+  return options.placeholder === '$' ? '$' + idx : options.placeholder
+}
+export const makeSqlParts = (
+  filters = {},
+  values = {},
+  fields = [],
+  idx = 1
+) => {
   let parameters = []
-  let idx = 1
   const keys = Object.keys(values)
 
-  const select = fields.length ? fields.join(', ') : '*'
+  const select = fields.length ? '"' + fields.join('", "') + '"' : '*'
 
   const insertParts = []
   const updateParts = []
   for (const key of keys) {
-    insertParts.push('$' + idx)
-    updateParts.push(key + ' = $' + idx)
+    // insertParts.push("$" + idx);
+    // updateParts.push('"' + key + '" = $' + idx);
+    insertParts.push(getPlaceholder(idx))
+    updateParts.push('"' + key + '" = ' + getPlaceholder(idx))
     idx++
   }
-
   const insert =
-    '("' + keys.join('", "') + '") VALUES (' + insertParts.join(', ') + ')'
-
+    '("' + keys.join('", "') + '") VALUES (' + insertParts.join(',') + ')'
   const update = updateParts.join(', ')
-
   parameters = parameters.concat(Object.values(values))
 
   let where = Object.keys(filters)
   where = where
     .map((key) => {
       if (Array.isArray(filters[key])) {
-        let sql = filters[key].map((v, vidx) => '$' + idx++).join(',')
-        sql = key + ' IN (' + sql + ')'
+        let sql = filters[key].map(() => getPlaceholder(idx++)).join(',')
+        sql &&= '"' + key + '" IN (' + sql + ')'
         parameters = parameters.concat(filters[key])
         return sql
       }
-      const sql = key + ' = $' + idx++
+      // const sql = '"' + key + '" = $' + idx++;
+      const sql = '"' + key + '" = ' + getPlaceholder(idx++)
       parameters.push(filters[key])
       return sql
     })
+    .filter((v) => v)
     .join(' AND ')
   where &&= `WHERE ${where}`
 
   return { select, insert, update, where, parameters }
 }
+
+export const __table = async (sql) => {
+  await options.query(sql)
+}
+
+export const __clear = async (table) => {
+  if (options.log) {
+    options.log('__clear', { table })
+  }
+  options.query(`DELETE FROM ${table}`)
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@1auth/store-sql",
-  "version": "0.0.0-alpha.6",
+  "version": "0.0.0-alpha.60",
   "description": "",
   "type": "module",
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   },
   "engineStrict": true,
   "publishConfig": {
@@ -27,7 +27,7 @@
   ],
   "scripts": {
     "test": "npm run test:unit",
-    "test:unit": "ava"
+    "test:unit": "node --test"
   },
   "license": "MIT",
   "funding": {
@@ -48,10 +48,13 @@
     "url": "https://github.com/willfarrell/1auth/issues"
   },
   "homepage": "https://github.com/willfarrell/1auth",
-  "gitHead": "be4a52c6e52443e7b21d0f67cb6062ae9f6f069c",
+  "gitHead": "7a6c0fbb8ab71d6a2171e678697de9f237568431",
   "peerDependencies": {
     "@aws-sdk/client-dynamodb": "^3.0.0",
     "@aws-sdk/util-dynamodb": "^3.0.0",
-    "uuid": "9.0.0"
+    "uuid": "^11.0.0"
+  },
+  "devDependencies": {
+    "better-sqlite3": "^11.0.0"
   }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 will Farrell
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.