[Node, Express, SSL Certificate: Run HTTPS Server from scratch in 5 steps ](https://dev.to/omergulen/step-by-step-node-express-ssl-certificate-run-https-server-from-scratch-in-5-steps-5b87)

<Alert type='info' header='See also' text='http://code-samples.space/notes/63aee0f7f5887b033b442c10' />

node express #https #ssl

# v3.0 KanBan 2021
## Way 1: Invite from TG bot
- https://t.me/pravosleva_bot?start=invite-chat_uxTest
- https://t.me/pravosleva_bot?start=invite-chat_sp

## External API
- http://pravosleva.ru/express-helper/chat/api/get-users

## Way 2: Main 
- http://pravosleva.ru/express-helper/chat/
- http://pravosleva.ru/express-helper/chat/#/?room=ux-test

*Admin Panel could be available by token:*
```bash
CHAT_ADMIN_TOKEN=<YOUR_TOKEN>
# chat.token in Local Storage
```

`.env.dev`
```bash
EXPIRES_COOKIES_IN_DAYS=1
SUCCESS_ANYWAY=0

## ACCESS:
SP_SVYAZNOY_JWT_SECRET=random_string
SP_ACCESS_PASSWORD=admin
QR_SWAGGER_JWT_SECRET=qr_secret_string
QR_SWAGGER_ACCESS_PASSWORD=qrdoc

BASE_PROTOCOL_HOST=http://pravosleva.ru
# EXTERNAL_ROUTING=/express-helper

##
## NOTE: reCAPTCHA settings: https://www.google.com/recaptcha/admin/site/430197091/settings
## NOTE: https://www.positronx.io/how-to-get-google-recaptcha-site-key-and-secret-key/
##

# RECAPTCHAV3_SERVER_KEY=6LdjSaQZAAAAAHiKs8r6EdouBNHYgEVs1XNw0ohS
# RECAPTCHAV3_VERIFY_URL=https://www.google.com/recaptcha/api/siteverify

## TG BOT HELPER:
PRAVOSLEVA_BOT_2021_STORAGE_FILE_NAME=pravosleva-bot-2021.json

## OPEN CHAT 2021
CHAT_ADMIN_TOKEN=128256512
CHAT_ROOMS_STATE_FILE_NAME=chat.rooms.json
CHAT_PASSWORD_HASHES_MAP_FILE_NAME=chat.passwd-hashes.json
CHAT_ROOMS_TASKLIST_MAP_FILE_NAME=chat.rooms-tasklist.json

```

# v2.0 My Remont 2020
http://selection4test.ru:1338/demo

# v1.0 Open Chat 2019
http://selection4test.ru:1350/dme/tst (socket crash test)

Open Chat | Sockets experience #expressHelper #chatAPI

## Step 1: NGINX

Changes in `/etc/nginx/conf.d/default.conf` file:
```bash
server {
  # etc.

  location / {
    proxy_set_header  X-Real-IP  $remote_addr;

    # etc.
  }
}
```

## Step 2: Express middlewares

### 2.1: IP detector middleware

`mws/ip-detector.js`
```js
module.exports = function (req, res, next) {
  // NOTE: http://code-samples.space/notes/601d00a80883d4603bb0e8ab

  req.clientIp = req.headers['x-real-ip']

  next()
}
```

### 2.2: Consumer middleware for example

`mws/geoip-lite.js`
```js
const geoip = require('geoip-lite')

module.exports = function (req, res, next) {
  if (!!req.clientIp) {
    // NOTE: https://www.npmjs.com/package/geoip-lite#looking-up-an-ip-address
    req.geo = geoip.lookup(req.clientIp)
  }

  next()
}
```

### 2.3: Server script sample

`run.js`
```js
const app = require('express')()
const PORT = process.env.PORT ? Number(process.env.PORT) : 3000
const ipDetectorMW = require('./mws/ip-detector')
const geoipLiteMW = require('./mws/geoip-lite')

app.use('*', ipDetectorMW, geoipLiteMW)
// NOTE: For example: const ip = req.clientIp; const geo = req.geo;

server.listen(PORT, (err) => {
  if (err) throw err
  console.log(`> Ready on http://localhost:${PORT}`)
})
```

## Sample

http://code-samples.space/e-api/common/my-ip

How to got IP from NGINX | #ip #express #nginx

Абстракция для валидации параметров запроса

`~/utils/express-validation-middleware.ts`
```ts
import {
  Request as IRequest,
  Response as IResponse,
  NextFunction as INextFunction,
} from 'express'
import { THelp } from './interfaces'

// NOTE: Соглашение facebook like
// Бэк присылает ответ в виде { ok: boolean; message?: string; <Возможно, чо-то еще> }

type TProps = {
  rules: THelp
}

export const withReqParamsValidationMW = ({ rules }: TProps) =>
  (req: IRequest, res: IResponse, next: INextFunction) => {
  // -- NOTE: Errs handler
  const errs: { msg: string, _reponseDetails?: any }[] = []

  for (const reqProp in rules.params) {
    switch (reqProp) {
      case 'body':
      case 'query':
        for (const key in rules.params[reqProp]) {
          if (rules.params[reqProp][key]?.required && !req[reqProp][key]) {
            const validationResult = rules.params[reqProp][key]?.validate(req[reqProp][key])
            const errOpts: any = {
              msg: `Missing required param: \`req.${reqProp}.${key}\` (${rules.params[reqProp][key].type}: ${rules.params[reqProp][key].descr})${!!validationResult.reason ? ` | ⚠️ By developer: ${validationResult.reason}` : ''}`
            }
            
            if (!!validationResult._reponseDetails)
              errOpts._reponseDetails = validationResult._reponseDetails

            errs.push(errOpts)
          } else {
            // -- NOTE: Если имеется необязательный параметр, проверим его
            if (!!req[reqProp][key]) {
              try {
                const validationResult = rules.params[reqProp][key]?.validate(req[reqProp][key])

                if (!validationResult.ok) {
                  const errOpts: {
                    msg: string;
                    _reponseDetails?: {
                      status: number;
                      [key: string]: any;
                    }
                  } = {
                    msg: `Incorrect request param format: \`req.${reqProp}.${key}\` (${rules.params[reqProp][key].descr}) expected: ${rules.params[reqProp][key].type}. Received: ${typeof req[reqProp][key]}${!!validationResult.reason ? ` | ⚠️ By developer: ${validationResult.reason}` : ''}`,
                  }
                  if (!!validationResult._reponseDetails)
                    errOpts._reponseDetails = validationResult._reponseDetails

                  errs.push(errOpts)
                }
              } catch (err) {
                errs.push({
                  msg: `Не удалось проверить поле: \`req.${reqProp}.${key}\` (${rules.params[reqProp][key].descr}); ${typeof err === 'string' ? err : (err.message || 'No err.message')}`
                })
              }
            }
            // --
          }
        }
        break
      default:
        break
    }
  }

  if (errs.length > 0) {
    let status = 400 // NOTE: Or anything by default?
    const result: any = {
      ok: false,
      message: `⛔ ERR! ${errs.map(({ msg }) => msg).join('; ')}`,
      _service: {
        originalBody: req.body,
        originalQuery: req.query,
        rules,
      }
    }

    // -- NOTE: Пробуем добавить детали первой ошибки результатов обработки в ответ (если они есть)
    try {
      // NOTE: v1 Добавить, если они имеются только у превой ошибки
      // if (!!errs[0]._reponseDetails) {
      //   const { status: newStatus, _addProps } = errs[0]._reponseDetails
      //   status = newStatus
      //   if (!!_addProps && Object.keys(_addProps).length > 0) {
      //     for (const key in _addProps) result[key] = _addProps[key]
      //   }
      // }

      // NOTE: v2 А если для этой нет? Нужно ли добавить детали хотя бы для одной ошибки из имеющихся?
      let _reponseDetails: any = null
      for (const err of errs) {
        if (!!err._reponseDetails) {
          _reponseDetails = err._reponseDetails
          break
        }
      }
      if (!!_reponseDetails) {
        const { status: newStatus, _addProps } = _reponseDetails
        status = newStatus
        if (!!_addProps && Object.keys(_addProps).length > 0) {
          for (const key in _addProps) result[key] = _addProps[key]
        }
      }
    } catch (err) {
      result._service.message = typeof err === 'string' ? err : (err.message || 'No err.message')
    }
    // --
    
    return res.status(status).send(result)
  }
  // --

  return next()
}
```

`~/utils/types.ts`
```ts
export type TValidationResult = {
  ok: boolean;
  reason?: string;
  _reponseDetails?: {
    status: number;
    _addProps?: {
      [key: string]: any;
    }
  }
}

export type THelp = {
  params: {
    body?: {
      [key: string]: {
        type: string; // NOTE: Это просто для информации (не строка с типом js)
        descr: string;
        required: boolean;
        validate: (val: any) => TValidationResult;
      }
    }
    query?: {
      [key: string]: {
        type: string;
        descr: string;
        required: boolean;
        validate: (val: any) => TValidationResult;
      }
    }
  }
  res?: {
    [key: string]: any;
  }
}
```

`route-example.ts`
```ts
import { TValidationResult } from './types'

export const rules = {
  params: {
    body: {
      // NOTE: Перечисляем поля в теле ответа в качестве ключей...
      text: {
        type: 'string',
        descr: 'Target input text',
        required: true,
        validate: (val: any) => {
          const result: TValidationResult = {
            ok: true,
          }
          
          switch (true) {
            case !val || typeof val !== 'string':
              result.ok = false
              result.reason = 'Ожидается непустая строка'
              break
            default:
              break
          }
          result._reponseDetails = {
            status: 200,
          }
          return result
        }
      }
    }
  }
}

export const getSlugify = (req: IRequest, res: IResponse) => {
  const { text } = req.body
  const _result: any = { ok: true }

  try {
    // @ts-ignore
    _result.result = slugify(text)
    return res.status(200).json({ ok: true, ..._result })
  } catch (err) {
    return res.status(200).json({ ok: false, message: err?.message || 'No err.message' })
  }
}
```

## Usage example
```ts
import express, { Express as IExpress } from 'express'
import { getSlugify, rules as getSlugifyRules } from './route-example'
import { withReqParamsValidationMW } from '~/utils/express-validation-middleware'

const careServiceApi: IExpress = express()

careServiceApi.post(
  '/get-slugify',
  withReqParamsValidationMW({ rules: getSlugifyRules }),
  getSlugify,
)

export { careServiceApi }

// NOTE: POST /get-slugify { text: 'Example' } -> { ok: true, <Что-то еще> }
// NOTE: POST /get-slugify { text: '' } -> { ok: false, message: '⛔ ERR! Incorrect request param format: `req.body.text` (Target input text) expected: string. Received: string | ⚠️ By developer: Ожидается непустая строка' }
```

Request params validation #express middleware

# Express server usage details with [better-module-alias](https://www.npmjs.com/package/better-module-alias)

## Step 1
Create `./server.src` dir

## Step 2
Install tools
```bash
yarn add better-module-alias
```

## Step 3
Add `./tsconfig.server.json`
```json
{
  "compilerOptions": {
    "allowJs": true,
    "target": "es5",
    "module": "commonjs",
    "lib": [
      "es2015",
      "es5"
    ],
    "removeComments": true,
    "preserveConstEnums": true,
    "forceConsistentCasingInFileNames": true,
    "noEmit": false,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "skipLibCheck": true,
    "sourceMap": true,
    "strict": true,
    "esModuleInterop": true,
    "resolveJsonModule": false,
    "isolatedModules": false,
    "baseUrl": ".",
    "paths": {
      "~srv/*": [
        "./server.src/*"
      ]
    },
    "typeRoots": [
      "node_modules/@types"
    ],
    "outDir": "./server.dist"
  },
  "include": [
    "./server.src/run.ts"
  ],
  "exclude": [
    "node_modules",
    "**/__tests__/*"
  ]
}
```

## Step 4
Start project scripts updates. See `package.json` diffs:
```js
{
  "scripts": {

    "dev": "yarn build && NODE_ENV=development node server.dist/run.js",
    "build": "yarn make-js-server && next build",
    "start": "NODE_ENV=production node server.dist/run.js",
    
    "transpile-server": "node_modules/.bin/tsc --project ./tsconfig.server.json --downlevelIteration",
    "make-js-server": "yarn transpile-server"
  },
  "_moduleAliases": {
    "$tests": "./tests",
    "~srv": "./" // NOTE: It's for server only
  }
}
```

## Step 5
`./server.src/run.ts` diffs
```js
const packageJson = require("../package.json")
import betterModuleAlias from "better-module-alias";
betterModuleAlias(__dirname, packageJson._moduleAliases);
```

## Step 6
Ready to use! In `./server.src/socket-logic/socketLogic.ts` for example
```ts
import { getTstValue } from '~srv/utils/getTstValue'

console.log('--')
console.log(getTstValue(1))
console.log('--')
```

#nextjs + #express better-module-alias #pravosleva

https://www.twilio.com/blog/add-cors-support-express-typescript-api

#express #cors

## This article in progress...

![qr](https://pravosleva.pro/express-helper/chat/storage/uploads/ux-test/1696163081301.png)

В этой статье я зафиксирую для себя некоторые соображения о том, как дешевыми средствами организовать авторизацию по QR. Эта статья не претендует на абсолютную истину в надежности своего подхода. Просто мысли.

> See also https://www.npmjs.com/package/qr-code-styling, **[TRY THIS](https://qr-code-styling.com/)**

> See also: [How to create a QR code in ExpressJS](https://gabrieleromanato.name/nodejs-create-a-qr-code-in-expressjs)

### _[pravosleva.pro/express-helper/qr/swagger/](https://pravosleva.pro/express-helper/qr/swagger/)_

![qr-exp](https://pravosleva.pro/static/img/qr_https_pravosleva_pro_express-helper_qr_swagger_.png)

### _Варианты авторизации по QR_

#### *v1*

- POST `/login`

> При успешной авторизации, создаём QR код с ссылкой и возможность перейти этой по ссылке успешно N раз.

*Response:*
```js
{
  ...data,
  qr,
  // содержащий ссылку на /auth/go-target с параметрами:
  // - logged_req_id
  // - hash
}
```
- static page `/auth/go-target? logged_req_id=<STRING>& hash=<STRING>`

Если клиент перешёл по ссылке с указанными параметрами и лимит аутентификации на доп устройствах не исчерпан, *проверим ему на слово и авторизуем **(NOTE: дыра в безопасности детектед!)***, актуализируя счётчик.
**Иначе варианты:**
- ☐ 1) чистим куку и отвечаем 500
- ☐ 2) или переводим на err page?
- ✔ 3) или чистим куку и редиректим и на авторизацию с хэшом (если найдем хэш по logged_req_id (id успешного запроса /login), если нет - можно 500; ***ПОПРАВКА: hash и logged_req_id в параметрах этого запроса - 500-я будет в случаях: 3.1) невалидного хэша либо logged_req_id***

<Alert header='Additional cookie' text='**urgent_auth_service_msg** cookie for 15 seconds (will be read on client for UI notification) ***httpOnly: false***' type='warning' />

# OLD [2021-03-26]

## 🧨 Express minimalism

Simplest middleware.

```js
import { Response as IResponse } from 'express'
import { ICustomRequest } from '~/utils/interfaces'
import QRCode from 'qrcode'
import { promisify } from 'es6-promisify'

const genDataUrl: (payload: string) => Promise<string> = promisify(QRCode.toDataURL.bind(QRCode))

export const tstGenerate = async (req: ICustomRequest, res: IResponse) => {
  const { payload } = req.query

  if (!payload) {
    return res
      .status(401)
      .json({ ok: false, message: 'Missing required parameter: "payload"' })
  }

  const dataUrl = await genDataUrl(String(payload))

  return res.status(200).json({
    ok: true,
    src: dataUrl,
  })
}
```

#express #qr code experience #auth

# [casjay-forks/Express-API-Auth-JWT](https://github.com/casjay-forks/Express-API-Auth-JWT)

#express #passport #letsTry #auth

https://www.npmjs.com/package/server-timing

#expressUtils Server Timing

Express cluster

https://github.com/pravosleva/get-money-reporter/blob/master/socket-logic/xls-watcher/index.js

#express | File watcher sample

https://github.com/ljlm0402/typescript-express-starter

Express TypeScript starter #boilerplate

# TS
- https://geekyants.github.io/express-typescript/

#expressBoilerplate

PERN 2021 | React & Node.js Fullstack интернет магазин. PERN stack PostgreSQL + express + React + node.js

https://github.com/dcode-youtube/single-page-app-vanilla-js

#spa #vanillaJS #express

2019.02 [Modern Token Authentication in Node with Express](https://developer.okta.com/blog/2019/02/14/modern-token-authentication-in-node-with-express)

#express #auth

> Все настройки взяты с текущей машины как образец

## Step 1: NGINX

Add
```bash
proxy_set_header  X-Real-IP  $remote_addr;
```
to `/etc/nginx/conf.d/default.conf` file:
```bash
server {
  listen 80;
  client_max_body_size 32m;
  server_tokens off;
  proxy_http_version 1.1;

  location / {
    proxy_set_header  X-Real-IP  $remote_addr;

    if ($request_method = 'POST') {
      add_header 'Access-Control-Allow-Origin' '*';
      add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
      add_header 'Access-Control-Allow-Headers' 'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range';
      add_header 'Access-Control-Expose-Headers' 'Content-Length,Content-Range';
    }
    if ($request_method = 'GET') {
      add_header 'Access-Control-Allow-Origin' '*';
      add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
      add_header 'Access-Control-Allow-Headers' 'DNT,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range';
      add_header 'Access-Control-Expose-Headers' 'Content-Length,Content-Range';
    }
    proxy_pass          http://127.0.0.1:9000;
    proxy_http_version  1.1;
  }

  # location /api {
  #   rewrite ^/api/(.*)$ /$1 break;
  #   proxy_pass          http://127.0.0.1:5000/smartprice/api/$1
  # }
  # location  ~ ^/api/(.*)$ {
  #   proxy_pass   http://127.0.0.1:5000/smartprice/api/$1;
  # }
}
```

## Step 2: Express middlewares

### 2.1: `mws/ip-detector.js`

```js
// const userIP = require('user-ip')

module.exports = function (req, res, next) {
  // const ip = userIP(req)
  const ip = req.headers['x-real-ip']
  // NOTE: http://code-samples.space/notes/601d00a80883d4603bb0e8ab

  req.clientIp = ip

  next()
}
```

### 2.2: `mws/geoip-lite.js`

```js
const geoip = require('geoip-lite')

module.exports = function (req, res, next) {
  if (!!req.clientIp) {
    // NOTE: See also off doc
    // https://www.npmjs.com/package/geoip-lite#looking-up-an-ip-address
    req.geo = geoip.lookup(req.clientIp)
  }

  next()
}
```

### 2.3: Server script sample `run.js`

```js
import { socketLogic } from '~/socket-logic'

const next = require('next')
const expressRouter = require('./express-tools/e-api')

const isDev = process.env.NODE_ENV !== 'production'
const app = require('express')()
const server = require('http').Server(app)
const io = require('socket.io')(server)
const nextApp = next({ dev: isDev })
const nextHanlder = nextApp.getRequestHandler()
const PORT = process.env.PORT ? Number(process.env.PORT) : 3000
const ipDetectorMW = require('./mws/middlewares/ip-detector')
const geoipLiteMW = require('./mws/geoip-lite')

const _customIO = socketLogic(io)

app.use('*', ipDetectorMW, geoipLiteMW)
// NOTE: For example: const ip = req.clientIp; const geo = req.geo;

nextApp
  .prepare()
  .then(() => {
    /**
     * Router Middleware
     * Router - /e-api/*
     * Method - *
     */
    app.use('/e-api', expressRouter)

    app.all('*', (req, res) => {
      req.io = _customIO
      return nextHanlder(req, res)
    })

    server.listen(PORT, (err) => {
      if (err) throw err
      console.log(`> Ready on http://localhost:${PORT}`)
    })
  })
  .catch((ex) => {
    console.error(ex.stack)
    process.exit(1)
  })
```

## Sample

http://code-samples.space/e-api/common/my-ip

#ip #express #nginx

https://github.com/jasonhenderson/electron-express/blob/master/main.js

#electron #express

- [Get HTTP POST Body in Express.js](https://stackabuse.com/get-http-post-body-in-express-js/)

#express

https://tilomitra.medium.com/building-server-rendered-react-apps-with-nextjs-40313e978cb4

#nextjs #express

## s4t

1. `./ssl/key.pem` & `./ssl/cert.pem`
2. Run srever script:
```js
// ./bin/www

var app = require('../app') // Express app
const fs = require('fs')
const https = require('https')
const port = getNormalizedPort(process.env.PORT || 3001)

function getNormalizedPort(val) {
  const port = parseInt(val, 10)

  if (isNaN(port)) return val;
  if (port >= 0) return port;
  return false;
}

var server = https.createServer({
  key: fs.readFileSync('ssl/key.pem'),
  cert: fs.readFileSync('ssl/cert.pem'),
  // passphrase: '123456789',
}, app)
  .listen(PORT, function () {
    console.log(`Listening on port ${PORT}! Go to https://localhost:${PORT}/`)
  })
```

## [Running express.js server over HTTPS](https://timonweb.com/javascript/running-expressjs-server-over-https/)

HTTPS is everywhere and more often than not we need to spin an https server or two. Here's how you can do it for your local express.js dev server:

### 1. Generate a self-signed certificate
```bash
openssl req -nodes -new -x509 -keyout server.key -out server.cert
```

### 2. Enable HTTPS in Express
Add something like this to your index.js
```js
var express = require('express')
var fs = require('fs')
var https = require('https')
var app = express()

app.get('/', function (req, res) {
  res.send('hello world')
})

https.createServer({
  key: fs.readFileSync('server.key'),
  cert: fs.readFileSync('server.cert')
}, app)
.listen(3000, function () {
  console.log('Example app listening on port 3000! Go to https://localhost:3000/')
})
```
Now run a command node index.js and your server should be available at address https://localhost:3000.

See also: [How To Create an HTTPS Server on Localhost using Express](https://medium.com/@nitinpatel_20236/how-to-create-an-https-server-on-localhost-using-express-366435d61f28)

🎓 #ssl #express #openssl

[https://github.com/pravosleva/express-graphql-sample](https://github.com/pravosleva/express-graphql-sample)

#express #graphql

[multer](https://github.com/expressjs/multer/blob/master/doc/README-ru.md)

#express #fileUploader

`~/utils/*`
```js
// getBaseLogger.js

export const getBaseLogger = (
  requiredFields = ['log', 'info', 'warn', 'error', 'success']
) => {
  const baseLog = (...args) => {
    console.log('--- WARN: logger was not set!');
    for (const key in args) console.log(args[key]);
  };
  const result = {};

  for (const i in requiredFields) result[requiredFields[i]] = baseLog;

  return result;
};
```

`run.js`
```js
import { getBaseLogger } from './utils/getBaseLogger';

const makeLogger = (fileName) => {
  const logger = require('tracer').console({
    transport: [
      function (data) {
        fs.appendFile(`./${fileName}`, data.rawoutput + '\n', (err) => {
          if (err) throw err;
        });
      },
      function (data) {
        console.log(data.output);
      },
    ],
  });

  logger.log('logger init');

  return logger;
};
const prodLogger = isProd ? makeLogger('_prod-logger.log') : null;
const devLogger = isDev ? makeLogger('_dev-logger.log') : null;
const logger = devLogger || prodLogger || getBaseLogger();
logger.log(
  `${String(process.env.NODE_ENV).toUpperCase()}: process.env`,
  getProcessEnvs()
);

// Express middleware:

ExpressApp.use('*', function (req, res, next) {
  // etc.

  req.logger = logger;
  next();
})
```

express