@1auth/store-sql 0.0.0-alpha.7 → 0.0.0-alpha.71

package/index.js

@@ -1,97 +1,213 @@
 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) => {
-  Object.assign(options, params)
-}
+  Object.assign(options, params);
+};
 
 export const exists = async (table, filters) => {
-  const item = await select(table, filters)
-  return item?.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)
-}
+  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 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 = []) => {
-  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])
-}
+  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])
+    // 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 = {}) => {
-  normalizeValues(values)
-  const { insert, parameters } = makeSqlParts({}, values)
-  const sql = `INSERT INTO ${table} ${insert}`
-  return await options.query(sql, parameters)
-}
+  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} 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 = {}) => {
-  normalizeValues(values)
-  const { update, where, parameters } = makeSqlParts(filters, values)
-  const sql = `UPDATE ${table} SET ${update} ${where}`
-  await options.query(sql, parameters)
-}
+  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}`;
+  await options.query(sql, parameters);
+};
 
 export const remove = async (table, filters = {}) => {
-  const { where, parameters } = makeSqlParts(filters)
-  const sql = `DELETE FROM ${table} ${where}`
-  await options.query(sql, parameters)
-}
+  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) => {
-  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.expire &&= new Date(values.expire * 1000).toISOString()
-}
+  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 = []) => {
-  let parameters = []
-  let idx = 1
-  const keys = Object.keys(values)
-
-  const select = fields.length ? fields.join(', ') : '*'
-
-  const insertParts = []
-  const updateParts = []
+export const getPlaceholder = (idx) => {
+  return options.placeholder === "$" ? "$" + idx : options.placeholder;
+};
+export const makeSqlParts = (
+  filters = {},
+  values = {},
+  fields = [],
+  idx = 1,
+) => {
+  let parameters = [];
+  const keys = Object.keys(values);
+
+  const select = fields.length ? '"' + fields.join('", "') + '"' : "*";
+
+  const insertParts = [];
+  const updateParts = [];
   for (const key of keys) {
-    insertParts.push('$' + idx)
-    updateParts.push(key + ' = $' + idx)
-    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(', ') + ')'
-
-  const update = updateParts.join(', ')
-
-  parameters = parameters.concat(Object.values(values))
+    '("' + keys.join('", "') + '") VALUES (' + insertParts.join(",") + ")";
+  const update = updateParts.join(", ");
+  parameters = parameters.concat(Object.values(values));
 
-  let where = Object.keys(filters)
+  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 + ')'
-        parameters = parameters.concat(filters[key])
-        return sql
+        let sql = filters[key].map(() => getPlaceholder(idx++)).join(",");
+        sql &&= '"' + key + '" IN (' + sql + ")";
+        parameters = parameters.concat(filters[key]);
+        return sql;
       }
-      const sql = key + ' = $' + idx++
-      parameters.push(filters[key])
-      return sql
+      // const sql = '"' + key + '" = $' + idx++;
+      const sql = '"' + key + '" = ' + getPlaceholder(idx++);
+      parameters.push(filters[key]);
+      return sql;
     })
-    .join(' AND ')
-  where &&= `WHERE ${where}`
+    .filter((v) => v)
+    .join(" AND ");
+  where &&= `WHERE ${where}`;
 
-  return { select, insert, update, where, parameters }
-}
+  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.7",
+  "version": "0.0.0-alpha.71",
   "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": {
@@ -41,17 +41,20 @@
   },
   "repository": {
     "type": "git",
-    "url": "github:willfarrell/1auth",
+    "url": "git+https://github.com/willfarrell/1auth.git",
     "directory": "packages/store-dynamodb"
   },
   "bugs": {
     "url": "https://github.com/willfarrell/1auth/issues"
   },
   "homepage": "https://github.com/willfarrell/1auth",
-  "gitHead": "39c704fcab5798f6bee8d00b2bcf574ba250a4cf",
+  "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.