velocious 1.0.107 → 1.0.109

package/src/cli/use-browser-cli.js

@@ -1,27 +0,0 @@
-// @ts-expect-error
-import React from "react"
-
-import BrowserCli from "./browser-cli.js"
-import restArgsError from "../utils/rest-args-error.js"
-
-const shared = {}
-
-/**
- * @param {object} args
- * @param {import("../configuration.js").default} args.configuration
- * @returns {Promise<BrowserCli>} browserCli
- */
-export default function velociousUseBrowserCli({configuration, ...restArgs}) {
-  const browserCli = React.useMemo(async () => {
-    if (!shared.browserCli) {
-      shared.browserCli = new BrowserCli({configuration})
-      shared.browserCli.enable()
-    }
-
-    return shared.browserCli
-  })
-
-  restArgsError(restArgs)
-
-  return browserCli
-}

package/src/configuration-resolver.js

@@ -1,61 +0,0 @@
-// @ts-check
-
-import Configuration, {CurrentConfigurationNotSetError} from "./configuration.js"
-import envSense from "env-sense/src/use-env-sense.js"
-import fileExists from "./utils/file-exists.js"
-
-/**
- * @param {import("./configuration-types.js").ConfigurationArgsType} [args]
- * @returns {Promise<Configuration>}
- */
-export default async function configurationResolver(args) {
-  let configuration
-
-  try {
-    configuration = Configuration.current()
-  } catch (error) {
-    if (error instanceof CurrentConfigurationNotSetError) {
-      // Ignore
-    } else {
-      throw error
-    }
-  }
-
-  if (configuration) {
-    return Configuration.current()
-  }
-
-  const directory = args?.directory || process.cwd()
-  let configurationPrePath = `${directory}/src/config/configuration`
-  const configurationPathForNode = `${configurationPrePath}.node.js`
-  const configurationPathDefault = `${configurationPrePath}.js`
-  const {isServer} = envSense()
-  let configurationPath
-
-  if (isServer && await fileExists(configurationPathForNode)) {
-    configurationPath = configurationPathForNode
-  } else {
-    configurationPath = configurationPathDefault
-  }
-
-  try {
-    const configurationImport = await import(configurationPath)
-
-    configuration = configurationImport.default
-  } catch (error) {
-    if (error instanceof Error) {
-      // This might happen during an "init" CLI command where we copy a sample configuration file.
-      if (!error.message.match(/^Cannot find module '(.+)\/configuration\.js'/)) {
-        throw error
-      }
-    }
-
-    if (!args) {
-      throw new Error("Can't spawn a new configuration because no configuration-arguments was given")
-    }
-
-    configuration = new Configuration(args)
-  }
-
-  return configuration
-}

package/src/configuration-types.js

@@ -1,61 +0,0 @@
-// @ts-check
-
-/**
- * @module types
- */
-
-/**
- * @typedef {function({request: import("./http-server/client/request.js").default, response: import("./http-server/client/response.js").default}): Promise<void>} CorsType
- */
-
-/**
- * @typedef {(id: string) => {default: typeof import("./initializer.js").default}} InitializersRequireContextType
- * @typedef {InitializersRequireContextType & {
- *   keys: () => string[],
- *   id: string
- * }} WebpackRequireContext
- * @typedef {{requireContext: WebpackRequireContext}} InitializersExportType
- * @typedef {function({configuration: import("./configuration.js").default}) : Promise<InitializersExportType>} InitializersType
- */
-
-/**
- * @typedef {object} DatabaseConfigurationType
- * @property {string} [database]
- * @property {typeof import("./database/drivers/base.js").default} [driver]
- * @property {typeof import("./database/pool/base.js").default} [poolType]
- * @property {function() : void} [getConnection]
- * @property {string} [host]
- * @property {boolean} [migrations]
- * @property {string} [password]
- * @property {number} [port]
- * @property {string} [name]
- * @property {object} [record]
- * @property {boolean} [record.transactions]
- * @property {boolean} [reset]
- * @property {object} [sqlConfig]
- * @property {string} [type]
- * @property {string} [useDatabase]
- * @property {string} [username]
- */
-
-/**
- * @typedef {Record<string, string[]>} LocaleFallbacksType
- */
-
-/**
- * @typedef {object} ConfigurationArgsType
- * @property {CorsType} [cors]
- * @property {{[key: string]: {[key: string]: DatabaseConfigurationType}}} database
- * @property {boolean} [debug]
- * @property {string} directory
- * @property {string} [environment]
- * @property {import("./environment-handlers/base.js").default} environmentHandler
- * @property {function({configuration: import("./configuration.js").default, type: string}) : void} initializeModels
- * @property {InitializersType} [initializers]
- * @property {string | function() : string} locale
- * @property {string[]} locales
- * @property {LocaleFallbacksType} localeFallbacks
- * @property {string} [testing]
- */
-
-export const nothing = {}

package/src/configuration.js

@@ -1,395 +0,0 @@
-// @ts-check
-
-/**
- * @typedef {function(Record<string, import("./database/drivers/base.js").default>) : Promise<void>} WithConnectionsCallbackType
- */
-
-import {digg} from "diggerize"
-import restArgsError from "./utils/rest-args-error.js"
-import {withTrackedStack} from "./utils/with-tracked-stack.js"
-
-/** @type {{currentConfiguration: VelociousConfiguration | null}} */
-const shared = {
-  currentConfiguration: null
-}
-
-class CurrentConfigurationNotSetError extends Error {}
-
-export {CurrentConfigurationNotSetError}
-
-export default class VelociousConfiguration {
-  /**
-   * @returns {VelociousConfiguration}
-   */
-  static current() {
-    if (!shared.currentConfiguration) throw new CurrentConfigurationNotSetError("A current configuration hasn't been set")
-
-    return shared.currentConfiguration
-  }
-
-  /**
-   * @param {import("./configuration-types.js").ConfigurationArgsType} args
-   */
-  constructor({cors, database, debug = false, directory, environment, environmentHandler, initializeModels, initializers, locale, localeFallbacks, locales, testing, ...restArgs}) {
-    restArgsError(restArgs)
-
-    this.cors = cors
-    this.database = database
-    this.debug = debug
-    this._environment = environment || process.env.VELOCIOUS_ENV || process.env.NODE_ENV || "development"
-    this._environmentHandler = environmentHandler
-    this._directory = directory
-    this._initializeModels = initializeModels
-    this._isInitialized = false
-    this.locale = locale
-    this.localeFallbacks = localeFallbacks
-    this.locales = locales
-    this._initializers = initializers
-    this._testing = testing
-
-    /** @type {{[key: string]: import("./database/pool/base.js").default}} */
-    this.databasePools = {}
-
-    /** @type {{[key: string]: typeof import("./database/record/index.js").default}} */
-    this.modelClasses = {}
-
-    this.getEnvironmentHandler().setConfiguration(this)
-  }
-
-  /**
-   * @returns {import("./configuration-types.js").CorsType | undefined}
-   */
-  getCors() {
-    return this.cors
-  }
-
-  /**
-   * @returns {Record<string, any>}
-   */
-  getDatabaseConfiguration() {
-    if (!this.database) throw new Error("No database configuration")
-
-    if (!this.database[this.getEnvironment()]) {
-      throw new Error(`No database configuration for environment: ${this.getEnvironment()} - ${Object.keys(this.database).join(", ")}`)
-    }
-
-    return digg(this, "database", this.getEnvironment())
-  }
-
-  /**
-   * @returns {Array<string>}
-   */
-  getDatabaseIdentifiers() {
-    return Object.keys(this.getDatabaseConfiguration())
-  }
-
-  /**
-   * @param {string} identifier
-   * @returns {import("./database/pool/base.js").default}
-   */
-  getDatabasePool(identifier = "default") {
-    if (!this.isDatabasePoolInitialized(identifier)) {
-      this.initializeDatabasePool(identifier)
-    }
-
-    return digg(this, "databasePools", identifier)
-  }
-
-  /**
-   * @param {string} identifier
-   * @returns {import("./configuration-types.js").DatabaseConfigurationType})
-   */
-  getDatabaseIdentifier(identifier) {
-    if (!this.getDatabaseConfiguration()[identifier]) throw new Error(`No such database identifier configured: ${identifier}`)
-
-    return this.getDatabaseConfiguration()[identifier]
-  }
-
-  /**
-   * @param {string} identifier
-   * @returns {typeof import("./database/pool/base.js").default}
-   */
-  getDatabasePoolType(identifier = "default") {
-    const poolTypeClass = digg(this.getDatabaseIdentifier(identifier), "poolType")
-
-    if (!poolTypeClass) {
-      throw new Error("No poolType given in database configuration")
-    }
-
-    return poolTypeClass
-  }
-
-  /**
-   * @returns {string} The database type.
-   */
-  getDatabaseType(identifier = "default") {
-    const databaseType = digg(this.getDatabaseIdentifier(identifier), "type")
-
-    if (!databaseType) throw new Error("No database type given in database configuration")
-
-    return databaseType
-  }
-
-  /**
-   * @returns {string}
-   */
-  getDirectory() {
-    if (!this._directory) {
-      this._directory = process.cwd()
-    }
-
-    return this._directory
-  }
-
-  /**
-   * @returns {string}
-   */
-  getEnvironment() { return digg(this, "_environment") }
-
-  /**
-   * @param {string} newEnvironment
-   * @returns {void}
-   */
-  setEnvironment(newEnvironment) { this._environment = newEnvironment }
-
-  /**
-   * @returns {import("./environment-handlers/base.js").default}
-   */
-  getEnvironmentHandler() {
-    if (!this._environmentHandler) throw new Error("No environment handler set")
-
-    return this._environmentHandler
-  }
-
-  /**
-   * @returns {import("./configuration-types.js").LocaleFallbacksType | undefined}
-   */
-  getLocaleFallbacks() { return this.localeFallbacks }
-
-  /**
-   * @param {import("./configuration-types.js").LocaleFallbacksType} newLocaleFallbacks
-   * @returns {void}
-   */
-  setLocaleFallbacks(newLocaleFallbacks) { this.localeFallbacks = newLocaleFallbacks }
-
-  /**
-   * @returns {string}
-   */
-  getLocale() {
-    if (typeof this.locale == "function") {
-      return this.locale()
-    } else if (this.locale) {
-      return this.locale
-    } else {
-      return this.getLocales()[0]
-    }
-  }
-
-  /**
-   * @returns {Array<string>}
-   */
-  getLocales() { return digg(this, "locales") }
-
-  /**
-   * @param {string} name
-   * @returns {typeof import("./database/record/index.js").default}
-   */
-  getModelClass(name) {
-    const modelClass = this.modelClasses[name]
-
-    if (!modelClass) throw new Error(`No such model class ${name} in ${Object.keys(this.modelClasses).join(", ")}}`)
-
-    return modelClass
-  }
-
-  /**
-   * @returns {Record<string, typeof import("./database/record/index.js").default>} A hash of all model classes, keyed by model name, as they were defined in the configuration. This is a direct reference to the model classes, not a copy.
-   */
-  getModelClasses() {
-    return this.modelClasses
-  }
-
-  /**
-   * @returns {string} The path to a config file that should be used for testing.
-   */
-  getTesting() { return this._testing }
-
-  /**
-   * @returns {void}
-   */
-  initializeDatabasePool(identifier = "default") {
-    if (!this.database) throw new Error("No 'database' was given")
-    if (this.databasePools[identifier]) throw new Error("DatabasePool has already been initialized")
-
-    const PoolType = this.getDatabasePoolType(identifier)
-
-    this.databasePools[identifier] = new PoolType({configuration: this, identifier})
-    this.databasePools[identifier].setCurrent()
-  }
-
-  isDatabasePoolInitialized(identifier = "default") { return Boolean(this.databasePools[identifier]) }
-
-  /**
-   * @returns {boolean}
-   */
-  isInitialized() { return this._isInitialized }
-
-  /**
-   * @param {object} args
-   * @param {string} args.type
-   * @returns {Promise<void>}
-   */
-  async initializeModels(args = {type: "server"}) {
-    if (!this._modelsInitialized) {
-      this._modelsInitialized = true
-
-      if (this._initializeModels) {
-        await this._initializeModels({configuration: this, type: args.type})
-      }
-    }
-  }
-
-  /**
-   * @param {object} args
-   * @param {string} args.type
-   * @returns {Promise<void>}
-   */
-  async initialize({type} = {type: "undefined"}) {
-    if (!this.isInitialized()) {
-      this._isInitialized = true
-
-      await this.initializeModels({type})
-
-      if (this._initializers) {
-        const initializers = await this._initializers({configuration: this})
-        const {requireContext, ...restArgs} = initializers
-
-        restArgsError(restArgs)
-
-        if (requireContext) {
-          for (const initializerKey of requireContext.keys()) {
-            const InitializerClass = requireContext(initializerKey).default
-            const initializerInstance = new InitializerClass({configuration: this, type})
-
-            await initializerInstance.run()
-          }
-        }
-      }
-    }
-  }
-
-  /**
-   * @param {typeof import("./database/record/index.js").default} modelClass
-   * @returns {void}
-   */
-  registerModelClass(modelClass) {
-    this.modelClasses[modelClass.name] = modelClass
-  }
-
-  /**
-   * @returns {void}
-   */
-  setCurrent() {
-    shared.currentConfiguration = this
-  }
-
-  /**
-   * @param {import("./routes/index.js").default} newRoutes
-   * @returns {void}
-   */
-  setRoutes(newRoutes) { this.routes = newRoutes }
-
-  /**
-   * @param {Function} callback
-   * @returns {void}
-   */
-  setTranslator(callback) { this._translator = callback }
-
-  /**
-   * @param {string} msgID
-   * @param {undefined | {defaultValue: string}} args
-   * @returns {string}
-   */
-  _defaultTranslator(msgID, args) {
-    if (args?.defaultValue) return args.defaultValue
-
-    return msgID
-  }
-
-  /**
-   * @returns {Function}
-   */
-  getTranslator() {
-    return this._translator || this._defaultTranslator
-  }
-
-  /**
-   * @param {WithConnectionsCallbackType} callback
-   * @returns {Promise<void>}
-   */
-  async withConnections(callback) {
-    /** @type {{[key: string]: import("./database/drivers/base.js").default}} */
-    const dbs = {}
-
-    const stack = Error().stack
-    const actualCallback = async () => {
-      await withTrackedStack(stack, async () => {
-        return await callback(dbs)
-      })
-    }
-
-    let runRequest = actualCallback
-
-    for (const identifier of this.getDatabaseIdentifiers()) {
-      let actualRunRequest = runRequest
-
-      const nextRunRequest = async () => {
-        return await this.getDatabasePool(identifier).withConnection(async (db) => {
-          dbs[identifier] = db
-
-          await actualRunRequest()
-        })
-      }
-
-      runRequest = nextRunRequest
-    }
-
-    await runRequest()
-  }
-
-  /**
-   * @returns {Record<string, import("./database/drivers/base.js").default>} A map of database connections with identifier as key
-   */
-  getCurrentConnections() {
-    /** @type {{[key: string]: import("./database/drivers/base.js").default}} */
-    const dbs = {}
-
-    for (const identifier of this.getDatabaseIdentifiers()) {
-      try {
-        dbs[identifier] = this.getDatabasePool(identifier).getCurrentConnection()
-      } catch (error) {
-        if (error instanceof Error && (error.message == "ID hasn't been set for this async context" || error.message == "A connection hasn't been made yet")) {
-          // Ignore
-        } else {
-          throw error
-        }
-      }
-    }
-
-    return dbs
-  }
-
-  /**
-   * @param {WithConnectionsCallbackType} callback
-   * @returns {Promise<void>}
-   */
-  async ensureConnections(callback) {
-    let dbs = this.getCurrentConnections()
-
-    if (Object.keys(dbs).length > 0) {
-      await callback(dbs)
-    } else {
-      await this.withConnections(callback)
-    }
-  }
-}

package/src/controller.js

@@ -1,166 +0,0 @@
-// @ts-check
-
-import ejs from "ejs"
-import {incorporate} from "incorporator"
-import * as inflection from "inflection"
-import {Logger} from "./logger.js"
-import restArgsError from "./utils/rest-args-error.js"
-
-export default class VelociousController {
-  /**
-   * @param {string} methodName
-   * @returns {void}
-   */
-  static beforeAction(methodName) {
-    if (!this._beforeActions) {
-      /** @type {Array<string>}  */
-      this._beforeActions = []
-    }
-
-    this._beforeActions.push(methodName)
-  }
-
-  /**
-   * @param {object} args
-   * @param {string} args.action
-   * @param {import("./configuration.js").default} args.configuration
-   * @param {string} args.controller
-   * @param {object} args.params
-   * @param {import("./http-server/client/request.js").default} args.request
-   * @param {import("./http-server/client/response.js").default} args.response
-   * @param {string} args.viewPath
-   */
-  constructor({action, configuration, controller, params, request, response, viewPath}) {
-    if (!action) throw new Error("No action given")
-    if (!configuration) throw new Error("No configuration given")
-    if (!controller) throw new Error("No controller given")
-    if (!params) throw new Error("No params given")
-    if (!request) throw new Error("No request given")
-    if (!response) throw new Error("No response given")
-    if (!viewPath) throw new Error("No viewPath given")
-
-    this._action = action
-    this._controller = controller
-    this._configuration = configuration
-    this.logger = new Logger(this)
-    this._params = params
-    this._request = request
-    this._response = response
-    this.viewParams = {}
-    this._viewPath = viewPath
-  }
-
-  /** @returns {string} */
-  getAction() { return this._action }
-
-  /** @returns {import("./configuration.js").default} */
-  getConfiguration() { return this._configuration }
-
-  /** @returns {object} */
-  getParams() { return this._params }
-
-  /** @returns {import("./http-server/client/request.js").default} */
-  getRequest() { return this._request }
-
-  /**
-   * @private
-   * @returns {typeof VelociousController}
-   */
-  _getControllerClass() {
-    const controllerClass = /** @type {typeof VelociousController} */ (this.constructor)
-
-    return controllerClass
-  }
-
-  async _runBeforeCallbacks() {
-    await this.logger.debug("_runBeforeCallbacks")
-
-    let currentControllerClass = this._getControllerClass()
-
-    while (currentControllerClass) {
-      await this.logger.debug(`Running callbacks for ${currentControllerClass.name}`)
-
-      const beforeActions = currentControllerClass._beforeActions
-
-      if (beforeActions) {
-        for (const beforeActionName of beforeActions) {
-          const beforeAction = currentControllerClass.prototype[beforeActionName]
-
-          if (!beforeAction) throw new Error(`No such before action: ${beforeActionName}`)
-
-          const boundBeforeAction = beforeAction.bind(this)
-
-          await boundBeforeAction()
-        }
-      }
-
-      currentControllerClass = Object.getPrototypeOf(currentControllerClass)
-
-      if (!currentControllerClass?.name?.endsWith("Controller")) break
-    }
-
-    await this.logger.debug("After runBeforeCallbacks")
-  }
-
-  /**
-   * @returns {object}
-   */
-  params() { return this._params }
-
-  /**
-   * @param {object} [args]
-   * @param {object} [args.json]
-   * @param {number | string} [args.status]
-   * @returns {Promise<void>}
-   */
-  async render({json, status, ...restArgs} = {}) {
-    restArgsError(restArgs)
-
-    if (json) {
-      return this.renderJsonArg(json)
-    }
-
-    if (status) {
-      this._response.setStatus(status)
-    }
-
-    return await this.renderView()
-  }
-
-  /** @param {object} json */
-  renderJsonArg(json) {
-    const body = JSON.stringify(json)
-
-    this._response.setHeader("Content-Type", "application/json; charset=UTF-8")
-    this._response.setBody(body)
-  }
-
-  renderView() {
-    return new Promise((resolve, reject) => {
-      const viewPath = `${this._viewPath}/${inflection.dasherize(inflection.underscore(this._action))}.ejs`
-      const {viewParams} = this
-      const actualViewParams = incorporate({controller: this}, viewParams)
-
-      ejs.renderFile(viewPath, actualViewParams, {}, (err, str) => {
-        if (err) {
-          reject(err)
-        } else {
-          this._response.setHeader("Content-Type", "text/html; charset=UTF-8")
-          this._response.setBody(str)
-
-          resolve(null)
-        }
-      })
-    })
-  }
-
-  renderText() {
-    throw new Error("renderText stub")
-  }
-
-  /** @returns {import("./http-server/client/request.js").default} */
-  request() { return this._request }
-
-  /** @returns {import("./http-server/client/response.js").default} */
-  response() { return this._response }
-}