@design-edito/cli 0.0.78 → 0.0.80

package/make-template/assets/express-api/src/api/auth/whoami/index.ts

@@ -0,0 +1,68 @@
+import { Outcome } from '@design-edito/tools/agnostic/misc/outcome'
+import * as Database from '../../../database'
+import { ROOT_USER_ID } from '../../../env'
+import { Codes, makeFailureOutcome } from '../../../errors'
+import { BaseUserModel, Role, Status } from '../../../schema/user'
+import { UserRevokedTokenModel } from '../../../schema/user-revoked-auth-token'
+import { makeEndpoint, nullAuthenticator, nullValidator } from '../../utils'
+
+type BaseUserData = {
+  _id: string
+  username: string
+  role: Role
+  status: Status
+}
+
+type LocalUserData = BaseUserData & {
+  email: string
+  verified: boolean
+}
+
+type GoogleUserData = BaseUserData & {
+  googleId: string
+}
+
+export type SuccessResponse = LocalUserData | GoogleUserData
+
+export const whoami = makeEndpoint<{}, SuccessResponse>(
+  nullAuthenticator,
+  nullValidator,
+  async (_body, _req, res) => {
+    const { accessTokenSigned, accessTokenPayload } = res.locals
+    // [WIP] probably better to do this in the authenticator ?
+    // Then assume res.locals are not undefined here ?
+    if (accessTokenPayload === undefined || accessTokenSigned === undefined) return makeFailureOutcome(Codes.USER_NOT_AUTHENTICATED, 'Access token has been revoked')
+    const tokenUserId = accessTokenPayload.userId
+    const foundRevokedToken = await Database.findOne(UserRevokedTokenModel, { value: accessTokenSigned }, { initiatorId: ROOT_USER_ID })
+    if (foundRevokedToken.success) return makeFailureOutcome(Codes.USER_NOT_AUTHENTICATED, 'Access token has been revoked')
+    const userLookup = await Database.findOne(BaseUserModel, { _id: tokenUserId }, { initiatorId: ROOT_USER_ID })
+    if (!userLookup.success) return userLookup
+    const { _id, username, role, status } = userLookup.payload
+    if (
+      'email' in userLookup.payload
+      && 'verified' in userLookup.payload) {
+      const email = userLookup.payload.email as string
+      const verified = userLookup.payload.verified as boolean
+      return Outcome.makeSuccess({
+        _id: _id.toString(),
+        username,
+        email,
+        role,
+        status,
+        verified
+      })
+    } else if ('googleId' in userLookup.payload) {
+      const googleId = userLookup.payload.googleId as string
+      return Outcome.makeSuccess({
+        _id: _id.toString(),
+        username,
+        googleId,
+        role,
+        status
+      })
+    }
+    // [WIP] what do here ? Send an email to the admin ?
+    // probably better not to inform the end user
+    return makeFailureOutcome(Codes.USER_DOES_NOT_EXIST, _id.toString())
+  }
+)

package/make-template/assets/express-api/src/api/index.ts

@@ -0,0 +1,18 @@
+import * as Auth from './auth'
+
+export const Endpoints = {
+
+  // Auth
+  'POST:/auth/signup': Auth.signup, // ok
+  'POST:/auth/verify-email/': Auth.verifyEmail, // ok
+  'POST:/auth/request-email-verification-token': Auth.requestEmailVerificationToken, // ok
+  'POST:/auth/login': Auth.login, // ok
+  'GET:/auth/refresh-token': Auth.refreshToken,
+  'GET:/auth/logout': Auth.logout, // ok
+  'POST:/auth/request-new-password': Auth.requestNewPassword, // ok
+  'POST:/auth/submit-new-password': Auth.submitNewPassword, // ok
+  // 'GET:/auth/google': Auth.google,
+  // 'GET:/auth/google-callback': Auth.googleCallback,
+  'GET:/auth/whoami': Auth.whoami // ok
+
+}

package/make-template/assets/express-api/src/api/types.ts

@@ -0,0 +1,76 @@
+import { Request, Response, RequestHandler } from 'express'
+import { Outcome } from '@design-edito/tools/agnostic/misc/outcome'
+import { Codes, ErrorData } from '../errors'
+import { Endpoints } from '.'
+
+type AsyncOrNot<T> = T | Promise<T>
+
+export type Authenticator = (req: Request, res: Response) => AsyncOrNot<Outcome.Either<true, ErrorData<Codes.USER_NOT_AUTHENTICATED | Codes.USER_NOT_AUTHORIZED | Codes.USER_DOES_NOT_EXIST>>>
+
+export type Validator<
+  ReqBody extends object = {},
+  Code extends Codes = Codes // [WIP] Maybe only Codes.INVALID_REQUEST_BODY here? Or split Codes into RequestValidatonErrorCodes and RequestProcessingErrorCodes
+> = (req: Request, res: Response) => AsyncOrNot<Outcome.Either<ReqBody, ErrorData<Code>>>
+
+export type Processor<
+  ReqBody extends object = {},
+  Output extends object = {},
+  Code extends Codes = Codes
+> = (body: ReqBody, req: Request, res: Response) => AsyncOrNot<Outcome.Either<Output, ErrorData<Code>>>
+
+export type ResponseMetaData = {
+  userId: string | null
+  requestId: string
+  timestamp: number
+}
+
+export type SuccessResponseBody<Output extends object = {}> = Outcome.Success<Output> & {
+  meta: ResponseMetaData
+}
+
+export type FailureResponseBody<
+  ValidationErrCode extends Codes = Codes,
+  ProcessingErrCode extends Codes = Codes
+> = Outcome.Failure<ErrorData<ValidationErrCode | ProcessingErrCode | Codes.USER_NOT_AUTHENTICATED | Codes.USER_NOT_AUTHORIZED | Codes.USER_DOES_NOT_EXIST | Codes.UNKNOWN_ERROR>> & {
+  meta: ResponseMetaData
+}
+
+export type ResponseBody<
+  Output extends object = {},
+  ValidationErrCode extends Codes = Codes,
+  ProcessingErrCode extends Codes = Codes
+> = SuccessResponseBody<Output> | FailureResponseBody<ValidationErrCode, ProcessingErrCode>
+
+export type Handler<
+  Output extends object = {},
+  ValidationErrCode extends Codes = Codes,
+  ProcessingErrCode extends Codes = Codes
+> = RequestHandler<{}, ResponseBody<Output, ValidationErrCode, ProcessingErrCode>, unknown>
+
+export type Endpoint<
+  ReqBody extends object = {},
+  Output extends object = {},
+  ValidationErrCodes extends Codes = Codes,
+  ProcessingErrCodes extends Codes = Codes
+> = {
+  authenticator: Authenticator
+  validator: Validator<ReqBody, ValidationErrCodes>
+  processor: Processor<ReqBody, Output, ProcessingErrCodes>
+  handler: Handler<Output, ValidationErrCodes, ProcessingErrCodes>
+}
+
+export type ExtractReqBody<T extends keyof typeof Endpoints> = typeof Endpoints[T] extends Endpoint<
+  infer ReqBody,
+  any,
+  any,
+  any
+> ? ReqBody
+  : never
+
+export type ExtractResBody<T extends keyof typeof Endpoints> = typeof Endpoints[T] extends Endpoint<
+  any,
+  infer Output,
+  infer ValidationErrCode,
+  infer ProcessingErrCode
+> ? ResponseBody<Output, ValidationErrCode, ProcessingErrCode>
+  : never

package/make-template/assets/express-api/src/api/utils.ts

@@ -0,0 +1,146 @@
+import { randomUUID } from 'node:crypto'
+import { RequestHandler, Router } from 'express'
+import { Outcome } from '@design-edito/tools/agnostic/misc/outcome'
+import { unknownToString } from '@design-edito/tools/agnostic/errors/unknown-to-string'
+import { Codes, register } from '../errors'
+import {
+  Validator,
+  Processor,
+  Handler,
+  FailureResponseBody,
+  SuccessResponseBody,
+  Endpoint,
+  Authenticator
+} from './types'
+
+declare global {
+  namespace Express {
+    interface Locals {
+      requestId?: string
+      requestTimestamp?: number
+    }
+  }
+}
+
+function makeHandler <
+  ReqBody extends object = {},
+  Output extends object = {},
+  ValidationErrCodes extends Codes = Codes,
+  ProcessingErrCodes extends Codes = Codes
+>(authenticator: Authenticator,
+  validator: Validator<ReqBody, ValidationErrCodes>,
+  processor: Processor<ReqBody, Output, ProcessingErrCodes>
+): Handler<Output, ValidationErrCodes, ProcessingErrCodes> {
+  const handler: Handler<Output, ValidationErrCodes, ProcessingErrCodes> = async (req, res) => {
+    const requestMeta = {
+      // This only works because Jwt.authenticate is used before this
+      userId: res.locals.accessTokenPayload?.userId ?? null,
+      requestId: randomUUID(),
+      timestamp: Date.now()
+    }
+    res.locals.requestId = requestMeta.requestId
+    res.locals.requestTimestamp = requestMeta.timestamp
+    try {
+      const authenticated = await authenticator(req, res)
+      if (!authenticated.success) {
+        const { code } = authenticated.error
+        if (code === Codes.USER_NOT_AUTHENTICATED) res.status(401)
+        else if (code === Codes.USER_DOES_NOT_EXIST) res.status(401)
+        else res.status(403)
+        const responseCore = Outcome.makeFailure(authenticated.error)
+        const response: FailureResponseBody<never, never> = {
+          ...responseCore,
+          meta: requestMeta
+        }
+        res.json(response)
+        return
+      }
+
+      const validated = await validator(req, res)
+      if (!validated.success) {
+        const errorData = validated.error
+        const responseCore = Outcome.makeFailure(errorData)
+        const response: FailureResponseBody<ValidationErrCodes, never> = {
+          ...responseCore,
+          meta: requestMeta
+        }
+        res.status(400).json(response)
+        return
+      }
+      const processed = await processor(validated.payload, req, res)
+      if (!processed.success) {
+        const errorData = processed.error
+        const responseCore = Outcome.makeFailure(errorData)
+        const response: FailureResponseBody<never, ProcessingErrCodes> = {
+          ...responseCore,
+          meta: requestMeta
+        }
+        // [WIP] maybe find a better logic err.code => res.status 
+        res.status(422).json(response)
+        return
+      }
+      const responsePayload = processed.payload
+      const responseCore = Outcome.makeSuccess(responsePayload)
+      const response: SuccessResponseBody<Output> = {
+        ...responseCore,
+        meta: requestMeta
+      }
+      res.status(200).json(response)
+    } catch (err) {
+      const errorString = unknownToString(err)
+      const errorData = register.getErrorData(Codes.UNKNOWN_ERROR, errorString)
+      const responseCore = Outcome.makeFailure(errorData)
+      const response: FailureResponseBody<never, Codes.UNKNOWN_ERROR> = {
+        ...responseCore,
+        meta: requestMeta
+      }
+      res.status(500).json(response)
+    }
+  }
+  return handler
+}
+
+export function makeEndpoint<
+  ReqBody extends object = {},
+  Output extends object = {},
+  ValidationErrCodes extends Codes = Codes,
+  ProcessingErrCodes extends Codes = Codes
+>(
+  authenticator: Authenticator,
+  validator: Validator<ReqBody, ValidationErrCodes>,
+  processor: Processor<ReqBody, Output, ProcessingErrCodes>
+): Endpoint<ReqBody, Output, ValidationErrCodes, ProcessingErrCodes> {
+  return {
+    authenticator,
+    validator,
+    processor,
+    handler: makeHandler(authenticator, validator, processor)
+  }
+}
+
+export const nullAuthenticator: Authenticator = () => Outcome.makeSuccess(true)
+export const nullValidator: Validator = () => Outcome.makeSuccess({})
+
+const methods = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'] as const
+type Method = (typeof methods)[number]
+const isMethod = (str: string): str is Method => methods.includes(str as Method)
+
+export function makeRouter<T extends { [key: string]: Endpoint<any, any, any, any> }> (endpoints: T) {
+  const router = Router()
+  Object.entries(endpoints).forEach(([path, endpoint]) => {
+    const [method, ...actualPathChunks] = path.split(':')
+    const isValidMethod = method !== undefined && isMethod(method)
+    if (!isValidMethod) {
+      const errorMessage = `${method} is not a valid HTTP method. @${path}.`
+      throw new Error(errorMessage)
+    }
+    const actualPath = actualPathChunks.join(':') // [WIP] check if heading slash is needed
+    const handler: RequestHandler = endpoint.handler
+    if (method === 'GET') return router.get(actualPath, handler)
+    if (method === 'POST') return router.post(actualPath, handler)
+    if (method === 'PUT') return router.put(actualPath, handler)
+    if (method === 'DELETE') return router.delete(actualPath, handler)
+    return router.options(actualPath, handler)
+  })
+  return router
+}

package/make-template/assets/express-api/src/database/index.ts

@@ -0,0 +1,173 @@
+import {
+  connect as mongooseConnect,
+  disconnect as mongooseDisconnect,
+  Model as MongooseModel,
+  FilterQuery as MongooseFilterQuery,
+  RootFilterQuery as MongooseRootFilterQuery,
+  Document as MongooseDocument,
+  Query as MongooseQuery,
+  UpdateQuery as MongooseUpdateQuery
+} from 'mongoose'
+import { unknownToString } from '@design-edito/tools/agnostic/errors/unknown-to-string'
+import { Logs } from '@design-edito/tools/agnostic/misc/logs'
+import { Outcome } from '@design-edito/tools/agnostic/misc/outcome'
+import { DB_USR, DB_PWD, DB_URL, DB_OPT } from '../env'
+import { Codes, makeFailureOutcome } from '../errors'
+
+/* * * * * * * * * * * * * * * * * *
+ *
+ * UTILITY
+ *
+ * * * * * * * * * * * * * * * * * */
+export interface QueryWithLocals<T, R = T | null> extends MongooseQuery<T, R> {
+  getOptions(): {
+    $locals?: {
+      context?: OperationContext
+    }
+  }
+}
+
+/* * * * * * * * * * * * * * * * * *
+ *
+ * CONNECTION / DISCONNECTION
+ *
+ * * * * * * * * * * * * * * * * * */
+export const connectionString = `mongodb+srv://${DB_USR}:${DB_PWD}@${DB_URL}/?${DB_OPT}`
+export async function connect () {
+  try {
+    await mongooseConnect(connectionString)
+    console.log(Logs.styles.important('Mongoose connected'))
+  } catch (err) {
+    console.log(Logs.styles.error(unknownToString(err)))
+  }
+}
+
+export async function disconnect() {
+  try {
+    await mongooseDisconnect()
+    console.log(Logs.styles.important('Mongoose disconnected'))
+  } catch (err) {
+    console.log(Logs.styles.error(unknownToString(err)))
+  }
+}
+
+/* * * * * * * * * * * * * * * * * *
+ *
+ * OPERATIONS
+ *
+ * * * * * * * * * * * * * * * * * */
+export type OperationContext = {
+  initiatorId: string | null
+}
+
+export interface DocumentWithLocals<T> extends MongooseDocument<T> {
+  $locals: {
+    context?: OperationContext
+  }
+}
+
+export async function insertOne<T> (
+  model: MongooseModel<T>,
+  data: Partial<T>,
+  context: OperationContext
+) {
+  try {
+    const doc = new model(data)
+    doc.$locals = { context }
+    const saved = await doc.save()
+    return Outcome.makeSuccess(saved.toObject())
+  } catch (err) {
+    return makeFailureOutcome(Codes.DB_ERROR, unknownToString(err))
+  }
+}
+
+export async function insertMany<T> (
+  model: MongooseModel<T>,
+  data: Partial<T>[],
+  context: OperationContext
+) {
+  try {
+    const docs = data.map(d => {
+      const doc = new model(d)
+      doc.$locals = { context }
+      return doc
+    })
+    const saved = await model.insertMany(docs)
+    return Outcome.makeSuccess(saved.map(d => d.toObject()))
+  } catch (err) {
+    return makeFailureOutcome(Codes.DB_ERROR, unknownToString(err))
+  }
+}
+
+export async function findOne<T> (
+  model: MongooseModel<T>,
+  filter: MongooseFilterQuery<T>,
+  context: OperationContext
+) {
+  try {
+    const found = await model
+      .findOne(filter)
+      .setOptions({ $locals: { context } })
+      .exec()
+    return found === null
+      ? makeFailureOutcome(Codes.DB_NO_DOCUMENT_MATCHES_FILTER, model, filter)
+      : Outcome.makeSuccess(found.toObject())
+  } catch (err) {
+    return makeFailureOutcome(Codes.DB_ERROR, unknownToString(err))
+  }
+}
+
+export async function updateOne<T> (
+  model: MongooseModel<T>,
+  filter: MongooseRootFilterQuery<T>,
+  update: MongooseUpdateQuery<T>,
+  context: OperationContext
+) {
+  try {
+    const updated = await model
+      .findOneAndUpdate(filter, update, { new: true })
+      .setOptions({ $locals: { context } })
+      .exec()
+    return updated === null
+      ? makeFailureOutcome(Codes.DB_NO_DOCUMENT_MATCHES_FILTER, model, filter)
+      : Outcome.makeSuccess(updated.toObject())
+  } catch (err) {
+    return makeFailureOutcome(Codes.DB_ERROR, unknownToString(err))
+  }
+}
+
+export async function deleteOne<T> (
+  model: MongooseModel<T>,
+  filter: MongooseRootFilterQuery<T>,
+  context: OperationContext
+) {
+  try {
+    const deleted = await model
+      .findOneAndDelete(filter)
+      .setOptions({ $locals: { context } })
+      .exec()
+    return deleted === null
+      ? makeFailureOutcome(Codes.DB_NO_DOCUMENT_MATCHES_FILTER, model, filter)
+      : Outcome.makeSuccess(deleted.toObject())
+  } catch (err) {
+    return makeFailureOutcome(Codes.DB_ERROR, unknownToString(err))
+  }
+}
+
+export async function deleteMany<T> (
+  model: MongooseModel<T>,
+  filter: MongooseRootFilterQuery<T>,
+  context: OperationContext
+) {
+  try {
+    const deleted = await model
+      .deleteMany(filter)
+      .setOptions({ $locals: { context } })
+      .exec()
+    return deleted.deletedCount === 0
+      ? makeFailureOutcome(Codes.DB_NO_DOCUMENT_MATCHES_FILTER, model, filter)
+      : Outcome.makeSuccess({ deleted: deleted.deletedCount })
+  } catch (err) {
+    return makeFailureOutcome(Codes.DB_ERROR, unknownToString(err))
+  }
+}

package/make-template/assets/express-api/src/email/index.ts

@@ -0,0 +1,47 @@
+import { Sender, Recipient, EmailParams, MailerSend } from 'mailersend'
+import { APIResponse } from 'mailersend/lib/services/request.service'
+import { Outcome } from '@design-edito/tools/agnostic/misc/outcome'
+import { unknownToString } from '@design-edito/tools/agnostic/errors/unknown-to-string'
+import { MAILERSEND_API_KEY } from '../env'
+
+export type SendOptions = {
+  senderEmail: string
+  senderName: string
+  recipientEmail: string
+  recipientName: string
+  subject: string
+  htmlBody: string
+}
+
+export async function send (
+  from: string,
+  fromName: string,
+  to: string,
+  toName: string,
+  subject: string,
+  htmlBody: string
+): Promise<Outcome.Either<APIResponse, string>> {
+  const mailerSend = new MailerSend({ apiKey: MAILERSEND_API_KEY })
+  const sender = new Sender(from, fromName)
+  const recipient = new Recipient(to, toName)
+  const emailParams = new EmailParams()
+    .setFrom(sender)
+    .setTo([recipient])
+    .setReplyTo(sender)
+    .setSubject(subject)
+    .setHtml(htmlBody)
+  try {
+    const sent = await mailerSend.email.send(emailParams)
+    return Outcome.makeSuccess(sent)
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err))
+  }
+}
+
+export function makeUserEmailVerificationTokenBody (username: string, token: string): string {
+  return `Hey ${username}! Here is your account verification code: ${token}.`
+}
+
+export function makeUserPasswordRenewalTokenBody (username: string, token: string): string {
+  return `Hey ${username}! Here is your password renewal code: ${token}.`
+}

package/make-template/assets/express-api/src/env/index.ts

@@ -0,0 +1,77 @@
+import dotenv from 'dotenv'
+
+dotenv.config()
+
+const MODE = process.env.MODE as 'development' | 'production'
+const HOST = process.env.HOST as string
+const DB_USR = process.env.DB_USR as string
+const DB_PWD = process.env.DB_PWD as string
+const DB_URL = process.env.DB_URL as string
+const DB_OPT = process.env.DB_OPT as string
+const DB_RESERVED_AGENDA_JOBS_COLLECTION_NAME = process.env.DB_RESERVED_AGENDA_JOBS_COLLECTION_NAME as string
+const ROOT_USER_ID = process.env.ROOT_USER_ID as string
+const ROOT_USER_NAME = process.env.ROOT_USER_NAME as string
+const ROOT_USER_EMAIL = process.env.ROOT_USER_EMAIL as string
+const ROOT_USER_PWD = process.env.ROOT_USER_PWD as string
+const USER_EMAIL_VALIDATION_TOKEN_LIFETIME_MINUTES = process.env.USER_EMAIL_VALIDATION_TOKEN_LIFETIME_MINUTES as string
+const JWT_SECRET = process.env.JWT_SECRET as string
+const ACCESS_TOKEN_EXPIRATION_SECONDS = parseFloat(process.env.ACCESS_TOKEN_EXPIRATION_SECONDS as string)
+const ACCESS_TOKEN_RENEWAL_THRESHOLD_SECONDS = parseFloat(process.env.ACCESS_TOKEN_RENEWAL_THRESHOLD_SECONDS as string)
+const REFRESH_TOKEN_EXPIRATION_SECONDS = parseFloat(process.env.REFRESH_TOKEN_EXPIRATION_SECONDS as string)
+const ACCESS_TOKEN_MAX_REFRESH_COUNT = parseFloat(process.env.ACCESS_TOKEN_MAX_REFRESH_COUNT as string)
+const REFRESH_TOKEN_MAX_REFRESH_COUNT = parseFloat(process.env.REFRESH_TOKEN_MAX_REFRESH_COUNT as string)
+const MAILERSEND_API_KEY = process.env.MAILERSEND_API_KEY as string
+const EMAILER_EMAIL = process.env.EMAILER_EMAIL as string
+const EMAILER_NAME = process.env.EMAILER_NAME as string
+
+function kill (message: string) {
+  console.log(message) // [WIP] replace all app's console.logs with actual logger calls
+  throw process.exit(1) // It's too early in this file to use await Init.shutdown(1)
+}
+
+if (typeof MODE !== 'string') { kill('.env/MODE field must be a string') }
+if (typeof HOST !== 'string') { kill('.env/HOST field must be a string') }
+else if (MODE !== 'development' && MODE !== 'production') { kill('.env/MODE field must be either "development" or "production"') }
+else if (typeof DB_USR !== 'string') { kill('.env/DB_USR field must be a string') }
+else if (typeof DB_PWD !== 'string') { kill('.env/DB_PWD field must be a string') }
+else if (typeof DB_URL !== 'string') { kill('.env/DB_URL field must be a string') }
+else if (typeof DB_OPT !== 'string') { kill('.env/DB_OPT field must be a string') }
+else if (typeof DB_RESERVED_AGENDA_JOBS_COLLECTION_NAME !== 'string') { kill('.env/DB_RESERVED_AGENDA_JOBS_COLLECTION_NAME field must be a string') }
+else if (typeof ROOT_USER_ID !== 'string') { kill('.env/ROOT_USER_ID field must be a string') }
+else if (typeof ROOT_USER_NAME !== 'string') { kill('.env/ROOT_USER_NAME field must be a string') }
+else if (typeof ROOT_USER_EMAIL !== 'string') { kill('.env/ROOT_USER_EMAIL field must be a string') }
+else if (typeof ROOT_USER_PWD !== 'string') { kill('.env/ROOT_USER_PWD field must be a string') }
+else if (typeof USER_EMAIL_VALIDATION_TOKEN_LIFETIME_MINUTES !== 'string') { kill('.env/USER_EMAIL_VALIDATION_TOKEN_LIFETIME_MINUTES field must be a string') }
+else if (typeof JWT_SECRET !== 'string') { kill('.env/JWT_SECRET field must be a string') }
+else if (typeof ACCESS_TOKEN_EXPIRATION_SECONDS !== 'number' || Number.isNaN(ACCESS_TOKEN_EXPIRATION_SECONDS)) { kill('.env/ACCESS_TOKEN_EXPIRATION_SECONDS field must be a number') }
+else if (typeof ACCESS_TOKEN_RENEWAL_THRESHOLD_SECONDS !== 'number' || Number.isNaN(ACCESS_TOKEN_RENEWAL_THRESHOLD_SECONDS)) { kill('.env/ACCESS_TOKEN_RENEWAL_THRESHOLD_SECONDS field must be a number') }
+else if (typeof REFRESH_TOKEN_EXPIRATION_SECONDS !== 'number' || Number.isNaN(REFRESH_TOKEN_EXPIRATION_SECONDS)) { kill('.env/REFRESH_TOKEN_EXPIRATION_SECONDS field must be a number') }
+else if (typeof ACCESS_TOKEN_MAX_REFRESH_COUNT !== 'number' || Number.isNaN(ACCESS_TOKEN_MAX_REFRESH_COUNT)) { kill('.env/ACCESS_TOKEN_MAX_REFRESH_COUNT field must be a number') }
+else if (typeof REFRESH_TOKEN_MAX_REFRESH_COUNT !== 'number' || Number.isNaN(REFRESH_TOKEN_MAX_REFRESH_COUNT)) { kill('.env/REFRESH_TOKEN_MAX_REFRESH_COUNT field must be a number') }
+else if (typeof MAILERSEND_API_KEY !== 'string') { kill('.env/MAILERSEND_API_KEY field must be a string') }
+else if (typeof EMAILER_EMAIL !== 'string') { kill('.env/EMAILER_EMAIL field must be a string') }
+else if (typeof EMAILER_NAME !== 'string') { kill('.env/EMAILER_NAME field must be a string') }
+
+export {
+  MODE,
+  HOST,
+  DB_USR,
+  DB_PWD,
+  DB_URL,
+  DB_OPT,
+  DB_RESERVED_AGENDA_JOBS_COLLECTION_NAME,
+  ROOT_USER_ID,
+  ROOT_USER_NAME,
+  ROOT_USER_EMAIL,
+  ROOT_USER_PWD,
+  USER_EMAIL_VALIDATION_TOKEN_LIFETIME_MINUTES,
+  JWT_SECRET,
+  ACCESS_TOKEN_EXPIRATION_SECONDS,
+  ACCESS_TOKEN_RENEWAL_THRESHOLD_SECONDS,
+  REFRESH_TOKEN_EXPIRATION_SECONDS,
+  ACCESS_TOKEN_MAX_REFRESH_COUNT,
+  REFRESH_TOKEN_MAX_REFRESH_COUNT,
+  MAILERSEND_API_KEY,
+  EMAILER_EMAIL,
+  EMAILER_NAME
+}