node_modules ignore

server/node_modules/koa-ip/.eslintrc.json

@@ -0,0 +1,4 @@
+{
+  "extends": "standard",
+  "plugins": ["jest"]
+}

server/node_modules/koa-ip/History.md

@@ -0,0 +1,29 @@
+## 2.1.3/2023-03-02
+
+- update deps
+
+## 2.1.2/2022-05-15
+
+- update deps
+- update readme
+
+## 2.1.1/2022-02-24
+
+- update deps
+
+## 2.1.0/2020-09-04
+
+- use `request-ip`
+- update dependencies
+- add TypeScript definition
+
+## 2.0.0/2018-12-21
+
+- merge #1 #2 #6
+- update dependencies
+- use jest
+- breaking change: default return 403 instead of 404 status.
+
+## 1.0.0/2017-12-01
+
+- v1.0.0 for koa@2

server/node_modules/koa-ip/__tests__/koa-ip.test.js

@@ -0,0 +1,167 @@
+const request = require('supertest')
+const Koa = require('koa')
+const ip = require('..')
+
+describe('koa-ip', () => {
+  it('paramters error', async () => {
+    const app = new Koa()
+    let error
+    try {
+      app.use(ip())
+    } catch (e) {
+      error = e
+    }
+    expect(error.message).toBe('koa-ip missing opts')
+  })
+
+  it('string success', async () => {
+    const app = new Koa()
+    app.use((ctx, next) => {
+      ctx.request.ip = '192.168.0.1'
+      return next()
+    })
+    app.use(ip('192.168.0.*'))
+    app.use((ctx, next) => {
+      ctx.status = 200
+    })
+
+    await request(app.callback()).get('/').expect(200)
+  })
+
+  it('string failed', async () => {
+    const app = new Koa()
+    app.use((ctx, next) => {
+      ctx.request.ip = '192.168.1.1'
+      return next()
+    })
+    app.use(ip(/^192.168.0.*$/))
+    app.use((ctx, next) => {
+      ctx.status = 200
+    })
+
+    await request(app.callback()).get('/').expect(403)
+  })
+
+  it('array success', async () => {
+    const app = new Koa()
+    app.use((ctx, next) => {
+      ctx.request.ip = '192.168.1.1'
+      return next()
+    })
+    app.use(ip([/^192.168.0.*$/, '192.168.1.*']))
+    app.use((ctx, next) => {
+      ctx.status = 200
+    })
+
+    await request(app.callback()).get('/').expect(200)
+  })
+
+  it('array failed', async () => {
+    const app = new Koa()
+    app.use((ctx, next) => {
+      ctx.request.ip = '192.168.1.1'
+      return next()
+    })
+    app.use(ip(['192.168.0.*']))
+    app.use((ctx, next) => {
+      ctx.status = 200
+    })
+
+    await request(app.callback()).get('/').expect(403)
+  })
+
+  it('object success', async () => {
+    const app = new Koa()
+    app.use((ctx, next) => {
+      ctx.request.ip = '192.168.0.1'
+      return next()
+    })
+    app.use(ip({
+      blacklist: ['192.168.0.[2-9]']
+    }))
+    app.use((ctx, next) => {
+      ctx.status = 200
+    })
+
+    await request(app.callback()).get('/').expect(200)
+  })
+
+  it('object failed', async () => {
+    const app = new Koa()
+    app.use((ctx, next) => {
+      ctx.request.ip = '192.168.0.1'
+      return next()
+    })
+    app.use(ip({
+      whitelist: ['192.168.0.1'],
+      blacklist: ['192.168.0.[1-9]']
+    }))
+    app.use((ctx, next) => {
+      ctx.status = 200
+    })
+
+    await request(app.callback()).get('/').expect(403)
+  })
+
+  it('blacklist handler', async () => {
+    const app = new Koa()
+    app.use((ctx, next) => {
+      ctx.request.ip = '192.168.0.1'
+      return next()
+    })
+    app.use(ip({
+      blacklist: ['192.168.0.[1-9]'],
+      handler: async (ctx) => {
+        ctx.status = 403
+        ctx.body = 'Forbidden!!!'
+      }
+    }))
+    app.use((ctx, next) => {
+      ctx.status = 200
+    })
+
+    const res = await request(app.callback()).get('/')
+    expect(res.status).toBe(403)
+    expect(res.text).toBe('Forbidden!!!')
+  })
+
+  it('blacklist handler passthrough', async () => {
+    const app = new Koa()
+    app.use((ctx, next) => {
+      ctx.request.ip = '192.168.0.1'
+      return next()
+    })
+    app.use(ip({
+      blacklist: ['192.168.0.[1-9]'],
+      handler: async (ctx, next) => {
+        return next()
+      }
+    }))
+    app.use((ctx, next) => {
+      ctx.status = 401
+      ctx.body = 'Please login!!!'
+    })
+
+    const res = await request(app.callback()).get('/')
+    expect(res.status).toBe(401)
+    expect(res.text).toBe('Please login!!!')
+  })
+
+  it('use request-ip', async () => {
+    const app = new Koa()
+    app.use((ctx, next) => {
+      // rewrite scoket.remoteAddress
+      Object.defineProperty(ctx.req.socket, 'remoteAddress', {
+        value: null
+      })
+      ctx.req.headers['x-forwarded-for'] = '1.1.1.1'
+      return next()
+    })
+    app.use(ip(/^1.1.1.*$/))
+    app.use((ctx, next) => {
+      ctx.status = 200
+    })
+
+    await request(app.callback()).get('/').expect(200)
+  })
+})

server/node_modules/koa-ip/index.d.ts

@@ -0,0 +1,20 @@
+import { Middleware, Context, Next } from 'koa';
+
+declare namespace koaIP {
+    type IPPatternsType = String | RegExp
+
+    interface koaIPOptionsObject {
+        whitelist?: Array<IPPatternsType>,
+        blacklist?: Array<IPPatternsType>,
+        handler?: (ctx: Context, next: Next) => any
+    }
+
+    type KoaIPOptions = koaIPOptionsObject | Array<IPPatternsType> | IPPatternsType
+
+    interface koaIP {
+        (options: KoaIPOptions): Middleware;
+    }
+}
+
+declare const koaIP: koaIP.koaIP;
+export = koaIP;

server/node_modules/koa-ip/index.js

@@ -0,0 +1,43 @@
+const assert = require('assert')
+const isPlainObject = require('lodash.isplainobject')
+const requestIp = require('request-ip')
+const debug = require('debug')('koa-ip')
+
+module.exports = function (opts) {
+  assert(opts, 'koa-ip missing opts')
+  if (!isPlainObject(opts)) {
+    opts = { whitelist: Array.isArray(opts) ? opts : [opts] }
+  }
+
+  return async function koaIp (ctx, next) {
+    const ip = ctx.ip || requestIp.getClientIp(ctx.req)
+    let pass = true
+
+    if (opts.whitelist && Array.isArray(opts.whitelist)) {
+      pass = opts.whitelist.some((item) => {
+        return new RegExp(item).test(ip)
+      })
+    }
+
+    if (pass && opts.blacklist && Array.isArray(opts.blacklist)) {
+      pass = !opts.blacklist.some((item) => {
+        return new RegExp(item).test(ip)
+      })
+    }
+
+    // pass
+    if (pass) {
+      debug(`${new Date()}: "${ip} -> ✓"`)
+      return next()
+    }
+
+    // not pass
+    if (typeof opts.handler === 'function') {
+      debug(`${new Date()}: "${ip} -> handler"`)
+      await opts.handler(ctx, next)
+    } else {
+      debug(`${new Date()}: "${ip} -> ×"`)
+      ctx.throw(403)
+    }
+  }
+}

server/node_modules/koa-ip/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "koa-ip",
+  "version": "2.1.3",
+  "description": "Ip filter middleware for koa, support `whitelist` and `blacklist`.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "jest"
+  },
+  "author": "nswbmw",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nswbmw/koa-ip"
+  },
+  "keywords": [
+    "koa",
+    "ip",
+    "whitelist",
+    "blacklist"
+  ],
+  "dependencies": {
+    "debug": "4.3.4",
+    "lodash.isplainobject": "4.0.6",
+    "request-ip": "3.3.0"
+  },
+  "devDependencies": {
+    "eslint-config-standard": "17.0.0",
+    "eslint-plugin-import": "2.27.5",
+    "eslint-plugin-jest": "27.2.1",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-promise": "6.1.1",
+    "eslint-plugin-standard": "4.1.0",
+    "jest": "29.4.3",
+    "koa": "2.14.1",
+    "supertest": "6.3.3"
+  },
+  "jest": {
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "html"
+    ]
+  }
+}

server/node_modules/koa-ip/readme.md

@@ -0,0 +1,77 @@
+## koa-ip
+
+<a href="https://communityinviter.com/apps/koa-js/koajs" rel="KoaJs Slack Community">![KoaJs Slack](https://img.shields.io/badge/Koa.Js-Slack%20Channel-Slack.svg?longCache=true&style=for-the-badge)</a> 
+
+> koa-ip is a ip filter middleware for koa, support `whitelist` and `blacklist`.
+
+### Install
+
+```sh
+$ npm i koa-ip --save
+```
+
+### Usage
+
+```js
+ip(String|RegExp)
+ip(Array{String|RegExp})
+ip({
+  whitelist: Array{String|RegExp},
+  blacklist: Array{String|RegExp},
+  handler: async (ctx, next) => {} // handle blacklist ip
+})
+```
+
+### Examples
+
+```js
+const Koa = require('koa')
+const ip = require('koa-ip')
+
+const app = new Koa()
+
+app.use(ip('192.168.0.*')) // whitelist
+// app.use(ip(['192.168.0.*', '8.8.8.[0-3]'])) // whitelist
+// app.use(ip({
+//   whitelist: ['192.168.0.*', '8.8.8.[0-3]'],
+//   blacklist: ['144.144.*']
+// }))
+
+app.listen(3000)
+```
+
+#### blacklist handler
+
+```js
+const app = new Koa()
+app.use((ctx, next) => {
+  ctx.request.ip = '127.0.0.1'
+  return next()
+})
+app.use(ip({
+  blacklist: ['127.0.0.*'],
+  handler: async (ctx, next) => {
+    ctx.status = 403
+  }
+}))
+
+app.use((ctx, next) => {
+  ctx.status = 200
+})
+
+app.listen(3000)
+```
+
+**NB**: If missing blacklist handler, default `ctx.status = 403`.
+
+More examples see [test](./__tests__/).
+
+### Test
+
+```sh
+$ npm test (coverage 100%)
+```
+
+### License
+
+MIT