.

qwen/nodejs/node_modules/connect-session-sequelize/README.md

@@ -0,0 +1,159 @@
+# Connect Session Store using Sequelize
+
+[![Build Status](https://travis-ci.org/mweibel/connect-session-sequelize.png)](https://travis-ci.org/mweibel/connect-session-sequelize)
+
+connect-session-sequelize is a SQL session store using [Sequelize.js](http://sequelizejs.com).
+
+# Installation
+
+Please note that the most recent version requires **express 4.** If you use _express 3_ you should install version 0.0.5 and follow [the instructions in the previous README](https://github.com/mweibel/connect-session-sequelize/blob/7a446de5a7a2ebc562d288a22896d55f0fbe6e5d/README.md).
+
+```
+$ npm install connect-session-sequelize
+```
+
+# Options
+
+- `db` a successfully connected Sequelize instance
+- `table` _(optional)_ a table/model which has already been imported to your Sequelize instance, this can be used if you want to use a specific table in your db
+- `modelKey` _(optional)_ a string for the key in sequelize's models-object but it is also the name of the class to which it references (conventionally written in Camelcase) that's why it is "Session" by default if `table` is not defined.
+- `tableName` _(optional)_ a string for naming the generated table if `table` is not defined.
+  Default is the value of `modelKey`.
+- `extendDefaultFields` _(optional)_ a way add custom data to table columns. Useful if using a custom model definition
+- `disableTouch` _(optional)_ When true, the store will not update the db when receiving a touch() call. This can be useful in limiting db writes and introducing more manual control of session updates.
+
+# Usage
+
+With connect
+
+```javascript
+const connect = require("connect");
+// for express, just call it with 'require('connect-session-sequelize')(session.Store)'
+const SequelizeStore = require("connect-session-sequelize")(
+  connect.session.Store
+);
+
+connect().use(
+  connect.session({
+    store: new SequelizeStore(options),
+    secret: "CHANGEME",
+  })
+);
+```
+
+With express 4:
+
+```javascript
+// load dependencies
+var express = require("express");
+var Sequelize = require("sequelize");
+var session = require("express-session");
+
+// initalize sequelize with session store
+var SequelizeStore = require("connect-session-sequelize")(session.Store);
+
+// create database, ensure 'sqlite3' in your package.json
+var sequelize = new Sequelize("database", "username", "password", {
+  dialect: "sqlite",
+  storage: "./session.sqlite",
+});
+
+// configure express
+var app = express();
+app.use(
+  session({
+    secret: "keyboard cat",
+    store: new SequelizeStore({
+      db: sequelize,
+    }),
+    resave: false, // we support the touch method so per the express-session docs this should be set to false
+    proxy: true, // if you do SSL outside of node.
+  })
+);
+// continue as normal
+```
+If you want SequelizeStore to create/sync the database table for you, you can call `sync()` against an instance of `SequelizeStore` along with [options](https://sequelize.org/master/class/lib/model.js~Model.html#static-method-sync) if needed. This will run a sequelize `sync()` operation on the model for an initialized SequelizeStore object :
+
+```javascript
+var myStore = new SequelizeStore({
+  db: sequelize,
+});
+app.use(
+  session({
+    secret: "keyboard cat",
+    store: myStore,
+    resave: false,
+    proxy: true,
+  })
+);
+
+myStore.sync();
+```
+
+# Session expiry
+
+Session records are automatically expired and removed from the database on an interval. The `cookie.expires` property is used to set session expiry time. If that property doesn't exist, a default expiry of 24 hours is used. Expired session are removed from the database every 15 minutes by default. That interval as well as the default expiry time can be set as store options:
+
+```javascript
+new SequelizeStore({
+  ...
+  checkExpirationInterval: 15 * 60 * 1000, // The interval at which to cleanup expired sessions in milliseconds.
+  expiration: 24 * 60 * 60 * 1000  // The maximum age (in milliseconds) of a valid session.
+});
+```
+
+## Expiration interval cleanup: `stopExpiringSessions`
+
+As expirations are checked on an interval timer, `connect-session-sequelize` can keep your process from exiting. This can be problematic e.g. in testing when it is known that the application code will no longer be used, but the test script never terminates. If you know that the process will no longer be used, you can manually clean up the interval by calling the `stopExpiringSessions` method:
+
+```js
+// assuming you have set up a typical session store, for example:
+var myStore = new SequelizeStore({
+  db: sequelize,
+});
+
+// you can stop expiring sessions (cancel the interval). Example using Mocha:
+after("clean up resources", () => {
+  myStore.stopExpiringSessions();
+});
+```
+
+# Add custom field(s) as a column
+
+The `extendDefaultFields` can be used to add custom fields to the session table. These fields will be read-only as they will be inserted only when the session is first created as `defaults`. Make sure to return an object which contains unmodified `data` and `expires` properties, or else the module functionality will be broken:
+
+```javascript
+sequelize.define("Session", {
+  sid: {
+    type: Sequelize.STRING,
+    primaryKey: true,
+  },
+  userId: Sequelize.STRING,
+  expires: Sequelize.DATE,
+  data: Sequelize.TEXT,
+});
+
+function extendDefaultFields(defaults, session) {
+  return {
+    data: defaults.data,
+    expires: defaults.expires,
+    userId: session.userId,
+  };
+}
+
+var store = new SequelizeStore({
+  db: sequelize,
+  table: "Session",
+  extendDefaultFields: extendDefaultFields,
+});
+```
+
+# Contributing/Reporting Bugs
+
+Try to replicate your issue using [mweibel/connect-session-sequelize-example](https://github.com/mweibel/connect-session-sequelize-example/) and add that as a link to your issue.
+
+This way it's much simpler to reproduce and help you.
+
+# License
+
+MIT

qwen/nodejs/node_modules/connect-session-sequelize/index.d.ts

@@ -0,0 +1,39 @@
+import { SessionData, Store } from 'express-session';
+import { Sequelize, SyncOptions } from 'sequelize';
+
+interface DefaultFields {
+  data: string;
+  expires: Date;
+}
+
+interface Data {
+  [column: string]: any;
+}
+
+interface SequelizeStoreOptions {
+  db: Sequelize;
+  table?: string;
+  tableName?: string;
+  modelKey?: string;
+  extendDefaultFields?: (defaults: DefaultFields, session: any) => Data;
+  checkExpirationInterval?: number;
+  expiration?: number;
+}
+
+declare class SequelizeStore extends Store {
+  sync(options?: SyncOptions): void
+  touch: (sid: string, data: any, callback?: (err: any) => void) => void
+  stopExpiringSessions: () => void
+  get(sid: string, callback: (err: any, session?: SessionData | null) => void): void
+  set(sid: string, session: SessionData, callback?: (err?: any) => void): void
+  destroy(sid: string, callback?: (err?: any) => void): void
+}
+
+interface SequelizeStoreConstructor {
+  new(options: SequelizeStoreOptions): SequelizeStore;
+}
+
+declare namespace init {}
+declare function init(store: typeof Store): SequelizeStoreConstructor;
+
+export = init;

qwen/nodejs/node_modules/connect-session-sequelize/index.js

@@ -0,0 +1 @@
+module.exports = require('./lib/connect-session-sequelize')

qwen/nodejs/node_modules/connect-session-sequelize/lib/connect-session-sequelize.js

@@ -0,0 +1,216 @@
+/**
+ * Sequelize based session store.
+ *
+ * Author: Michael Weibel <michael.weibel@gmail.com>
+ * License: MIT
+ */
+
+const Op = require('sequelize').Op || {}
+const defaultModel = require('./model')
+const debug = require('debug')('connect:session-sequelize')
+const defaultOptions = {
+  checkExpirationInterval: 15 * 60 * 1000, // The interval at which to cleanup expired sessions.
+  expiration: 24 * 60 * 60 * 1000, // The maximum age (in milliseconds) of a valid session. Used when cookie.expires is not set.
+  disableTouch: false, // When true, we will not update the db in the touch function call. Useful when you want more control over db writes.
+  modelKey: 'Session',
+  tableName: 'Sessions'
+}
+
+function promisify (promise, fn) {
+  if (typeof fn === 'function') {
+    promise = promise.then(obj => {
+      fn(null, obj)
+    }).catch(err => {
+      if (!err) {
+        const error = new Error(err + '')
+        error.cause = err
+        err = error
+      }
+
+      fn(err)
+    })
+  }
+  return promise
+}
+
+class SequelizeStoreException extends Error {
+  constructor (message) {
+    super(message)
+    this.name = 'SequelizeStoreException'
+  }
+}
+
+module.exports = function SequelizeSessionInit (Store) {
+  class SequelizeStore extends Store {
+    constructor (options) {
+      super(options)
+      this.options = { ...defaultOptions, ...(options || {}) }
+
+      if (!this.options.db) {
+        throw new SequelizeStoreException('Database connection is required')
+      }
+
+      this.startExpiringSessions()
+
+      // Check if specific table should be used for DB connection
+      if (this.options.table) {
+        debug('Using table: %s for sessions', this.options.table)
+        // Get Specifed Table from Sequelize Object
+        this.sessionModel =
+          this.options.db[this.options.table] || this.options.db.models[this.options.table]
+      } else {
+        // No Table specified, default to ./model
+        debug('No table specified, using default table.')
+        this.sessionModel = this.options.db.define(this.options.modelKey, defaultModel, {
+          tableName: this.options.tableName || this.options.modelKey
+        })
+      }
+    }
+
+    sync (options) {
+      return this.sessionModel.sync(options)
+    }
+
+    get (sid, fn) {
+      debug('SELECT "%s"', sid)
+      return promisify(
+        this.sessionModel
+          .findOne({ where: { sid: sid } })
+          .then(function (session) {
+            if (!session) {
+              debug('Did not find session %s', sid)
+              return null
+            }
+            debug('FOUND %s with data %s', session.sid, session.data)
+
+            return JSON.parse(session.data)
+          }),
+        fn
+      )
+    }
+
+    set (sid, data, fn) {
+      debug('INSERT "%s"', sid)
+      const stringData = JSON.stringify(data)
+      const expires = this.expiration(data)
+
+      let defaults = { data: stringData, expires: expires }
+      if (this.options.extendDefaultFields) {
+        defaults = this.options.extendDefaultFields(defaults, data)
+      }
+
+      return promisify(
+        this.sessionModel
+          .findCreateFind({
+            where: { sid: sid },
+            defaults: defaults,
+            raw: false,
+            useMaster: true
+          })
+          .then(function sessionCreated ([session]) {
+            let changed = false
+            Object.keys(defaults).forEach(function (key) {
+              if (key === 'data') {
+                return
+              }
+
+              if (session.dataValues[key] !== defaults[key]) {
+                session[key] = defaults[key]
+                changed = true
+              }
+            })
+            if (session.data !== stringData) {
+              session.data = JSON.stringify(data)
+              changed = true
+            }
+            if (changed) {
+              session.expires = expires
+              return session.save().then(() => { return session })
+            }
+            return session
+          }),
+        fn
+      )
+    }
+
+    touch (sid, data, fn) {
+      debug('TOUCH "%s"', sid)
+
+      if (this.options.disableTouch) {
+        debug('TOUCH skipped due to disableTouch "%s"', sid)
+        return fn()
+      }
+
+      const expires = this.expiration(data)
+
+      return promisify(
+        this.sessionModel
+          .update({ expires: expires }, { where: { sid: sid } })
+          .then(function (rows) {
+            return rows
+          }),
+        fn
+      )
+    }
+
+    destroy (sid, fn) {
+      debug('DESTROYING %s', sid)
+      return promisify(
+        this.sessionModel
+          .findOne({ where: { sid: sid }, raw: false })
+          .then(function foundSession (session) {
+            // If the session wasn't found, then consider it destroyed already.
+            if (session === null) {
+              debug('Session not found, assuming destroyed %s', sid)
+              return null
+            }
+            return session.destroy()
+          }),
+        fn
+      )
+    }
+
+    length (fn) {
+      return promisify(this.sessionModel.count(), fn)
+    }
+
+    clearExpiredSessions (fn) {
+      debug('CLEARING EXPIRED SESSIONS')
+      return promisify(
+        this.sessionModel
+          .destroy({ where: { expires: { [Op.lt || 'lt']: new Date() } } }).catch((error) => debug(`Ignoring error at clearExpiredSessions: ${error}`)),
+        fn
+      )
+    }
+
+    startExpiringSessions () {
+      // Don't allow multiple intervals to run at once.
+      this.stopExpiringSessions()
+      if (this.options.checkExpirationInterval > 0) {
+        this._expirationInterval = setInterval(
+          this.clearExpiredSessions.bind(this),
+          this.options.checkExpirationInterval
+        )
+        // allow to terminate the node process even if this interval is still running
+        this._expirationInterval.unref()
+      }
+    }
+
+    stopExpiringSessions () {
+      if (this._expirationInterval) {
+        clearInterval(this._expirationInterval)
+        // added as a sanity check for testing
+        this._expirationInterval = null
+      }
+    }
+
+    expiration (data) {
+      if (data.cookie && data.cookie.expires && !isNaN(data.cookie.expires)) {
+        return data.cookie.expires
+      }
+      return new Date(Date.now() + this.options.expiration)
+    }
+  }
+
+  return SequelizeStore
+}

qwen/nodejs/node_modules/connect-session-sequelize/lib/model.js

@@ -0,0 +1,13 @@
+/**
+ * Session Model
+ */
+const DataTypes = require('sequelize').DataTypes
+
+module.exports = {
+  sid: {
+    type: DataTypes.STRING(36),
+    primaryKey: true
+  },
+  expires: DataTypes.DATE,
+  data: DataTypes.TEXT
+}

qwen/nodejs/node_modules/connect-session-sequelize/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "connect-session-sequelize",
+  "version": "7.1.7",
+  "description": "Session store for connect-session using sequelize",
+  "homepage": "https://github.com/mweibel/connect-session-sequelize",
+  "bugs": "https://github.com/mweibel/connect-session-sequelize/issues",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha ./test",
+    "lint": "standard"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mweibel/connect-session-sequelize.git"
+  },
+  "dependencies": {
+    "debug": "^4.1.1"
+  },
+  "devDependencies": {
+    "express-session": "^1.17.1",
+    "mocha": "^9.2.2",
+    "sequelize": ">=6.1.0",
+    "sqlite3": "^4.2.0",
+    "standard": "^14.3.4"
+  },
+  "peerDependencies": {
+    "sequelize": ">= 6.1.0"
+  },
+  "engines": {
+    "node": ">= 10"
+  },
+  "keywords": [
+    "connect-session",
+    "connect",
+    "sequelize",
+    "postgres",
+    "mysql",
+    "sqlite"
+  ],
+  "author": "Michael Weibel <michael.weibel@gmail.com> (https://github.com/mweibel)",
+  "license": "MIT",
+  "files": [
+    "lib",
+    "index.js",
+    "index.d.ts"
+  ]
+}