fastify-session-better-sqlite3-store 1.0.5

package/.github/workflows/ci.yml

@@ -0,0 +1,37 @@
+name: ci
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+
+  tests-ubuntu:
+
+    runs-on: ubuntu-latest
+    
+    steps:
+
+    - uses: actions/checkout@v2
+
+    - name: Install Dependencies
+      run: npm install
+
+    - name: run tests
+      run: npm run test
+
+  tests-windows:
+
+    runs-on: windows-latest
+    
+    steps:
+
+    - uses: actions/checkout@v2
+
+    - name: Install Dependencies
+      run: npm install
+
+    - name: run tests
+      run: npm run test

package/.github/workflows/standard.yml

@@ -0,0 +1,23 @@
+name: standard
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+
+  check-code-style-standard:
+
+    runs-on: ubuntu-latest
+    
+    steps:
+
+    - uses: actions/checkout@v2
+
+    - name: Install Standard
+      run: npm i -D standard
+
+    - name: Check code style format
+      run: npx standard *.js

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Mordecai Velasco
+
+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.

package/README.md

@@ -0,0 +1,47 @@
+# fastify-better-sqlite3-session-store
+
+![ci](https://github.com/mrdcvlsc/fastify-better-sqlite3-session-store/actions/workflows/ci.yml/badge.svg)
+![standard](https://github.com/mrdcvlsc/fastify-better-sqlite3-session-store/actions/workflows/standard.yml/badge.svg)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+Session store for [@fastify/session](https://github.com/fastify/session) using [better-sqlite3](https://github.com/WiseLibs/better-sqlite3). By default [@fastify/session](https://github.com/fastify/session) stores sessions in-memory. Using this package's class you can store sessions on an **SQLite3** database instead.
+
+## Installation
+
+```
+npm install fastify-better-sqlite3-session-store
+```
+
+## Example
+
+Use with `fastify-session`'s `store` property.
+
+```js
+const fastify = require('fastify')({logger:true})
+const fastifyCookie = require('@fastify/cookie')
+const fastifySession = require('@fastify/session')
+const db = require('better-sqlite3')(`./sqlite.db`)
+
+// require module
+const SqliteStore = require('fastify-better-sqlite3-session-store')
+
+fastify.register(fastifyCookie)
+fastify.register(fastifySession,{
+  // ...
+  // other session options
+  // ...
+  store: new SqliteStore(db)
+})
+```
+
+-----
+
+## Package-Status
+
+*premature, there are a lot of rooms for improvement*
+
+-----
+
+## License
+
+[MIT Licence](https://github.com/mrdcvlsc/fastify-better-sqlite3-session-store/blob/main/LICENSE)

package/index.js

@@ -0,0 +1,81 @@
+'use strict'
+
+const EventEmitter = require('events')
+
+class SqliteStore extends EventEmitter {
+  /**
+   * @param {Object} sqlite3db database instance of better-sqlite3.
+   * @param {string} table table name where session data will be stored, defaults to `session`.
+   */
+  constructor (sqlite3db, table = 'session') {
+    try {
+      sqlite3db.exec(`
+        create table ${table} (
+          sid TEXT PRIMARY KEY NOT NULL,
+          expires DATETIME NOT NULL,
+          session TEXT NOT NULL
+        )`
+      )
+    } catch (err) {
+      if (err.toString() !== 'SqliteError: table session already exists') {
+        throw Error(err.toString())
+      }
+    }
+    super()
+    this.setSession = sqlite3db.prepare(`INSERT INTO ${table} (sid, expires, session) VALUES (?, ?, ?)`)
+    this.getSession = sqlite3db.prepare(`SELECT sid, expires, session FROM ${table} WHERE sid = ?`)
+    this.destroySession = sqlite3db.prepare(`DELETE FROM ${table} WHERE sid = ?`)
+  }
+}
+
+SqliteStore.prototype.set = function set (sessionId, session, callback) {
+  try {
+    this.setSession.run(
+      sessionId,
+      session.expires.toISOString(),
+      JSON.stringify(session)
+    )
+    callback(null)
+  } catch (err) {
+    if (err.code === 'SQLITE_CONSTRAINT_PRIMARYKEY') {
+      callback(null)
+    } else {
+      callback(err)
+    }
+  }
+}
+
+SqliteStore.prototype.get = function get (sessionId, callback) {
+  try {
+    const results = []
+    for (const row of this.getSession.iterate(sessionId)) {
+      results.push(row)
+    }
+
+    let session = null
+    if (results.length === 1) {
+      const found = JSON.parse(results[0].session)
+      if (found.expires) {
+        if (new Date() < new Date(found.expires)) {
+          session = found
+        }
+      } else {
+        session = found
+      }
+    }
+    callback(null, session)
+  } catch (err) {
+    callback(err)
+  }
+}
+
+SqliteStore.prototype.destroy = function destroy (sessionId, callback) {
+  try {
+    this.destroySession.run(sessionId)
+    callback(null)
+  } catch (err) {
+    callback(err)
+  }
+}
+
+module.exports = SqliteStore

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "fastify-session-better-sqlite3-store",
+  "version": "1.0.5",
+  "description": "A simple session store for fastify-session using better-sqlite3",
+  "main": "index.js",
+  "scripts": {
+    "lint": "npx standard *.js",
+    "test": "node test/first.test && node test/second.test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mrdcvlsc/fastify-session-better-sqlite3-store.git"
+  },
+  "keywords": [
+    "session",
+    "fastify",
+    "store",
+    "better-sqlite3",
+    "sqlite",
+    "session-store"
+  ],
+  "author": "mrdcvlsc",
+  "license": "MIT",
+  "devDependencies": {
+    "@fastify/cookie": "^7.2.0",
+    "@fastify/session": "^9.0.0",
+    "better-sqlite3": "^7.6.2",
+    "fastify": "^4.2.1",
+    "standard": "^17.0.0"
+  }
+}

package/test/SmallTest.js

@@ -0,0 +1,77 @@
+const fs = require('fs')
+
+class SmallTest {
+  constructor (testName) {
+    this.verdicts = []
+    this.names = []
+    this.passing = true
+    this.testName = testName
+  }
+
+  assertEqual (name, a, b) {
+    this.names.push(name)
+    const result = (a === b)
+    this.verdicts.push(result ? 'PASSED' : 'FAILED')
+    if (!result) this.passing = false
+  }
+
+  results () {
+    console.log(`\n\nSmallTest : ${this.testName}\n`)
+    if (this.verdicts.length === 0) {
+      console.log('NO TESTS FOUND')
+      return false
+    }
+    for (let i = 0; i < this.verdicts.length; ++i) {
+      console.log(`  ${this.verdicts[i]} : ${this.names[i]}`)
+    }
+    return this.passing
+  }
+}
+
+async function saveJsonFile (filename, json) {
+  try {
+    await fs.promises.writeFile(filename, JSON.stringify(json))
+    return Promise.resolve()
+  } catch (err) {
+    return Promise.reject(err)
+  }
+}
+
+async function readJsonFile (filename) {
+  try {
+    const json = JSON.parse(await fs.promises.readFile(filename))
+    return Promise.resolve(json)
+  } catch (err) {
+    return Promise.reject(err)
+  }
+}
+
+/**
+ * Simulate an http GET request, with session cookies.
+ * @param {Object} fastify instance of fastify application.
+ * @param {String} endpoint get request url.
+ * @param {Object} clientSessionCookie client session cookie key pair value.
+ * @returns {Promise<Response>}
+ */
+async function httpGetRequest (fastify, endpoint, clientSessionCookie) {
+  try {
+    const response = await fastify.inject({
+      method: 'GET',
+      url: endpoint,
+      cookies: clientSessionCookie
+    })
+    return Promise.resolve(response)
+  } catch (err) {
+    return Promise.reject(err)
+  }
+}
+
+async function setTimeoutAsync (delay) {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      return resolve()
+    }, delay)
+  })
+}
+
+module.exports = { httpGetRequest, saveJsonFile, readJsonFile, SmallTest, setTimeoutAsync }

package/test/first.test.js

@@ -0,0 +1,99 @@
+const fastify = require('fastify')({ logger: true })
+const fastifyCookie = require('@fastify/cookie')
+const fastifySession = require('@fastify/session')
+const sqlite3db = require('better-sqlite3')('./test/sqlite.db')
+
+const SqliteStore = require('../index')
+
+fastify.register(fastifyCookie)
+fastify.register(fastifySession, {
+  secret: 'a super duper secret session string',
+  cookie: {
+    secure: false,
+    maxAge: 5000
+  },
+  store: new SqliteStore(sqlite3db),
+  saveUninitialized: false
+})
+
+fastify.get('/set/:name', (request, reply) => {
+  request.session.name = request.params.name
+  reply.send(`recorded:${request.session.name}`)
+})
+
+fastify.get('/destroy', async (request, reply) => {
+  try {
+    if (request.session.name) {
+      const destroyedUser = request.session.name
+      await request.session.destroy()
+      return reply.send(`destroyed:${destroyedUser}`)
+    } else {
+      return reply.send('destroyed:no-user')
+    }
+  } catch (err) {
+    fastify.log.error(err)
+    return process.exit(1)
+  }
+})
+
+fastify.get('/session', (request, reply) => {
+  if (request.session.name) {
+    reply.send(`session:${request.session.name}`)
+  } else {
+    reply.send('session:no-user')
+  }
+})
+
+const { SmallTest, httpGetRequest, saveJsonFile, setTimeoutAsync } = require('./SmallTest')
+
+async function start () {
+  const t = new SmallTest('TEST SET CASE 1')
+  try {
+    await fastify.listen({ port: 3000 })
+
+    const subject1 = await httpGetRequest(fastify, '/session')
+    const subject2 = await httpGetRequest(fastify, '/set/subject2')
+    const cookie1 = {
+      sessionId: subject2.cookies[0].value
+    }
+    const subject3 = await httpGetRequest(fastify, '/session', cookie1)
+    const subject4 = await httpGetRequest(fastify, '/destroy', cookie1)
+    const subject5 = await httpGetRequest(fastify, '/session', cookie1)
+    const subject6 = await httpGetRequest(fastify, '/set/subject6')
+    const cookie2 = {
+      sessionId: subject6.cookies[0].value
+    }
+    const subject7 = await httpGetRequest(fastify, '/session', cookie2)
+    await setTimeoutAsync(8000)
+    const subject8 = await httpGetRequest(fastify, '/session', cookie2)
+    const subject9 = await httpGetRequest(fastify, '/set/subject9')
+    const cookie3 = {
+      sessionId: subject9.cookies[0].value
+    }
+
+    t.assertEqual('session none', subject1.payload, 'session:no-user')
+    t.assertEqual('session recorded', subject2.payload, 'recorded:subject2')
+    t.assertEqual('session existing', subject3.payload, 'session:subject2')
+    t.assertEqual('session destroyed', subject4.payload, 'destroyed:subject2')
+    t.assertEqual('session no more', subject5.payload, 'session:no-user')
+    t.assertEqual('new session recorded', subject6.payload, 'recorded:subject6')
+    t.assertEqual('new session existing', subject7.payload, 'session:subject6')
+    t.assertEqual('new session expired', subject8.payload, 'session:no-user')
+    t.assertEqual('session saved then server shutsdown', subject9.payload, 'recorded:subject9')
+
+    await fastify.close()
+    await saveJsonFile('test/cookie.json', cookie3)
+
+    if (t.results()) {
+      console.log(t.testName, '=> PASSED ALL TEST\n')
+    } else {
+      console.log(t.testName, '=> FAILED SOME TEST\n')
+      process.exit(1)
+    }
+  } catch (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+}
+
+start()

package/test/second.test.js

@@ -0,0 +1,52 @@
+const fastify = require('fastify')({ logger: true })
+const fastifyCookie = require('@fastify/cookie')
+const fastifySession = require('@fastify/session')
+const sqlite3db = require('better-sqlite3')('./test/sqlite.db')
+
+const SqliteStore = require('../index')
+
+fastify.register(fastifyCookie)
+fastify.register(fastifySession, {
+  secret: 'a super duper secret session string',
+  cookie: {
+    secure: false,
+    maxAge: 5000
+  },
+  store: new SqliteStore(sqlite3db),
+  saveUninitialized: false
+})
+
+fastify.get('/session', (request, reply) => {
+  if (request.session.name) {
+    reply.send(`session:${request.session.name}`)
+  } else {
+    reply.send('session:no-user')
+  }
+})
+
+const { SmallTest, httpGetRequest, readJsonFile } = require('./SmallTest')
+
+async function start () {
+  const t = new SmallTest('TEST SET CASE 2')
+  try {
+    await fastify.listen({ port: 3001 })
+
+    const cookie = await readJsonFile('test/cookie.json')
+    const subject9 = await httpGetRequest(fastify, '/session', cookie)
+    t.assertEqual('session existing after server restart', subject9.payload, 'session:subject9')
+
+    await fastify.close()
+
+    if (t.results()) {
+      console.log(t.testName, '=> PASSED ALL TEST\n')
+    } else {
+      console.log(t.testName, '=> FAILED SOME TEST\n')
+      process.exit(1)
+    }
+  } catch (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+}
+
+start()