velocious 1.0.108 → 1.0.109

package/src/routes/app-routes.js

@@ -1,16 +0,0 @@
-// @ts-check
-
-import {digg} from "diggerize"
-
-export default class VelociousRoutesAppRoutes {
-  /**
-   * @param {import("../configuration.js").default} configuration
-   * @returns {Promise<import("./index.js").default>}
-   */
-  static async getRoutes(configuration) {
-    // Every client need to make their own routes because they probably can't be shared across different worker threads
-    const routesImport = await configuration.getEnvironmentHandler().importApplicationRoutes()
-
-    return digg(routesImport, "routes")
-  }
-}

package/src/routes/base-route.js

@@ -1,82 +0,0 @@
-// @ts-check
-
-export default class VelociousBaseRoute {
-  /** @type {typeof import("./get-route.js").default} */
-  static GetRouteType
-
-  /** @type {typeof import("./namespace-route.js").default} */
-  static NameSpaceRouteType
-
-  /** @type {typeof import("./post-route.js").default} */
-  static PostRouteType
-
-  /** @type {typeof import("./resource-route.js").default} */
-  static ResourceRouteType
-
-  /** @param {typeof import("./get-route.js").default} RouteClass */
-  static registerRouteGetType(RouteClass) {
-    this.GetRouteType = RouteClass
-  }
-
-  /** @param {typeof import("./namespace-route.js").default} RouteClass */
-  static registerRouteNamespaceType(RouteClass) {
-    this.NameSpaceRouteType = RouteClass
-  }
-
-  /** @param {typeof import("./post-route.js").default} RouteClass */
-  static registerRoutePostType(RouteClass) {
-    this.PostRouteType = RouteClass
-  }
-
-  /** @param {typeof import("./resource-route.js").default} RouteClass */
-  static registerRouteResourceType(RouteClass) {
-    this.ResourceRouteType = RouteClass
-  }
-
-  constructor() {
-    // Nothing
-  }
-
-  /** @type {Array<VelociousBaseRoute>} */
-  routes = []
-
-  /**
-   * @abstract
-   * @param {string} name
-   */
-  get(name) { throw new Error("'get' not implemented") } // eslint-disable-line no-unused-vars
-
-  /**
-   * @param {object} args
-   * @param {Record<string, any>} args.params
-   * @param {string} args.path
-   * @param {import("../http-server/client/request.js").default} args.request
-   * @returns {{restPath: string} | undefined}
-   */
-  matchWithPath({params, path, request}) { // eslint-disable-line no-unused-vars
-    throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
-  }
-
-  /**
-   * @abstract
-   * @param {string} name
-   * @param {function(import("./namespace-route.js").default) : void} callback
-   * @returns {void}
-   */
-  namespace(name, callback) { throw new Error("'namespace' not implemented") } // eslint-disable-line no-unused-vars
-
-  /**
-   * @abstract
-   * @param {string} name
-   * @returns {void}
-   */
-  post(name) { throw new Error("'post' not implemented") } // eslint-disable-line no-unused-vars
-
-  /**
-   * @abstract
-   * @param {string} name
-   * @param {function(import("./resource-route.js").default) : void} callback
-   * @returns {void}
-   */
-  resources(name, callback) { throw new Error("'resources' not implemented") } // eslint-disable-line no-unused-vars
-}

package/src/routes/basic-route.js

@@ -1,76 +0,0 @@
-// @ts-check
-
-import BaseRoute from "./base-route.js"
-
-export default class VelociousBasicRoute extends BaseRoute {
-  /** @param {string} name */
-  get(name) {
-    const GetRoute = VelociousBasicRoute.GetRouteType
-    const route = new GetRoute({name})
-
-    this.routes.push(route)
-  }
-
-  /**
-   * @param {object} args
-   * @param {Record<string, any>} args.params
-   * @param {string} args.path
-   * @param {import("../http-server/client/request.js").default} args.request
-   * @returns {{restPath: string} | undefined}
-   */
-  matchWithPath({params, path, request}) { // eslint-disable-line no-unused-vars
-    throw new Error(`No 'matchWithPath' implemented on ${this.constructor.name}`)
-  }
-
-  /**
-   * @param {string} name
-   * @param {function(import("./namespace-route.js").default) : void} callback
-   * @returns {void}
-   */
-  namespace(name, callback) {
-    const NamespaceRoute = VelociousBasicRoute.NameSpaceRouteType
-
-    if (!NamespaceRoute) throw new Error("No NamespaceRoute registered")
-
-    const route = new NamespaceRoute({name})
-
-    this.routes.push(route)
-
-    if (callback) {
-      callback(route)
-    }
-  }
-
-  /**
-   * @param {string} name
-   * @returns {void}
-   */
-  post(name) {
-    const PostRoute = VelociousBasicRoute.PostRouteType
-
-    if (!PostRoute) throw new Error("No PostRoute registered")
-
-    const route = new PostRoute({name})
-
-    this.routes.push(route)
-  }
-
-  /**
-   * @param {string} name
-   * @param {function(import("./resource-route.js").default) : void} [callback]
-   * @returns {void}
-   */
-  resources(name, callback) {
-    const ResourceRoute = VelociousBasicRoute.ResourceRouteType
-
-    if (!ResourceRoute) throw new Error("No ResourceRoute registered")
-
-    const route = new ResourceRoute({name})
-
-    this.routes.push(route)
-
-    if (callback) {
-      callback(route)
-    }
-  }
-}

package/src/routes/built-in/errors/controller.js

@@ -1,7 +0,0 @@
-import Controller from "../../../controller.js"
-
-export default class BuiltInErrorsController extends Controller {
-  async notFound() {
-    this.render({status: "not-found"})
-  }
-}

package/src/routes/built-in/errors/not-found.ejs

@@ -1 +0,0 @@
-Path not found: <%= controller.getRequest().path() %>

package/src/routes/get-route.js

@@ -1,42 +0,0 @@
-// @ts-check
-
-import escapeStringRegexp from "escape-string-regexp"
-
-import BaseRoute from "./base-route.js"
-import restArgsError from "../utils/rest-args-error.js"
-
-class VelociousRouteGetRoute extends BaseRoute {
-  /**
-   * @param {object} args
-   * @param {string} args.name
-   */
-  constructor({name, ...restArgs}) {
-    super()
-    restArgsError(restArgs)
-    this.name = name
-    this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
-  }
-
-  /**
-   * @param {object} args
-   * @param {Record<string, any>} args.params
-   * @param {string} args.path
-   * @param {import("../http-server/client/request.js").default} args.request
-   * @returns {{restPath: string} | undefined}
-   */
-  matchWithPath({params, path, request}) { // eslint-disable-line no-unused-vars
-    const match = path.match(this.regExp)
-
-    if (match) {
-      const [_beginnigSlash, _matchedName, restPath] = match // eslint-disable-line no-unused-vars
-
-      params.action = this.name
-
-      return {restPath}
-    }
-  }
-}
-
-BaseRoute.registerRouteGetType(VelociousRouteGetRoute)
-
-export default VelociousRouteGetRoute

package/src/routes/index.js

@@ -1,19 +0,0 @@
-// @ts-check
-
-import GetRoute from "./get-route.js" // eslint-disable-line no-unused-vars
-import NameSpaceRoute from "./namespace-route.js" // eslint-disable-line no-unused-vars
-import PostRoute from "./post-route.js" // eslint-disable-line no-unused-vars
-import RootRoute from "./root-route.js"
-import ResourceRoute from "./resource-route.js" // eslint-disable-line no-unused-vars
-
-export default class VelociousRoutes {
-  rootRoute = new RootRoute()
-
-  /**
-   * @param {function(import("./root-route.js").default) : void} callback
-   * @returns {void}
-   */
-  draw(callback) {
-    callback(this.rootRoute)
-  }
-}

package/src/routes/namespace-route.js

@@ -1,42 +0,0 @@
-// @ts-check
-
-import restArgsError from "../utils/rest-args-error.js"
-import BaseRoute from "./base-route.js"
-import BasicRoute from "./basic-route.js"
-import escapeStringRegexp from "escape-string-regexp"
-
-class VelociousRouteNamespaceRoute extends BasicRoute {
-  /**
-   * @param {object} args
-   * @param {string} args.name
-   */
-  constructor({name, ...restArgs}) {
-    super()
-    restArgsError(restArgs)
-    this.name = name
-    this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
-  }
-
-  /**
-   * @param {object} args
-   * @param {Record<string, any>} args.params
-   * @param {string} args.path
-   * @param {import("../http-server/client/request.js").default} args.request
-   * @returns {{restPath: string} | undefined}
-   */
-  matchWithPath({params, path, request}) { // eslint-disable-line no-unused-vars
-    const match = path.match(this.regExp)
-
-    if (match) {
-      const [_beginnigSlash, _matchedName, restPath] = match // eslint-disable-line no-unused-vars
-
-      params.controller = this.name
-
-      return {restPath}
-    }
-  }
-}
-
-BaseRoute.registerRouteNamespaceType(VelociousRouteNamespaceRoute)
-
-export default VelociousRouteNamespaceRoute

package/src/routes/post-route.js

@@ -1,41 +0,0 @@
-// @ts-check
-
-import BaseRoute from "./base-route.js"
-import escapeStringRegexp from "escape-string-regexp"
-import restArgsError from "../utils/rest-args-error.js"
-
-class VelociousRoutePostRoute extends BaseRoute {
-  /**
-   * @param {object} args
-   * @param {string} args.name
-   */
-  constructor({name, ...restArgs}) {
-    super()
-    restArgsError(restArgs)
-    this.name = name
-    this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
-  }
-
-  /**
-   * @param {object} args
-   * @param {Record<string, any>} args.params
-   * @param {string} args.path
-   * @param {import("../http-server/client/request.js").default} args.request
-   * @returns {{restPath: string} | undefined}
-   */
-  matchWithPath({params, path, request}) { // eslint-disable-line no-unused-vars
-    const match = path.match(this.regExp)
-
-    if (match) {
-      const [_beginnigSlash, _matchedName, restPath] = match // eslint-disable-line no-unused-vars
-
-      params.action = this.name
-
-      return {restPath}
-    }
-  }
-}
-
-BaseRoute.registerRoutePostType(VelociousRoutePostRoute)
-
-export default VelociousRoutePostRoute

package/src/routes/resolver.js

@@ -1,102 +0,0 @@
-// @ts-check
-
-import {digg} from "diggerize"
-import {dirname} from "path"
-import {fileURLToPath} from "url"
-import fs from "fs/promises"
-import * as inflection from "inflection"
-
-export default class VelociousRoutesResolver {
-  /**
-   * @param {object} args
-   * @param {import("../configuration.js").default} args.configuration
-   * @param {import("../http-server/client/request.js").default} args.request
-   * @param {import("../http-server/client/response.js").default} args.response
-   */
-  constructor({configuration, request, response}) {
-    if (!configuration) throw new Error("No configuration given")
-    if (!request) throw new Error("No request given")
-    if (!response) throw new Error("No response given")
-
-    this.configuration = configuration
-    this.params = request.params()
-    this.request = request
-    this.response = response
-  }
-
-  async resolve() {
-    let controllerPath
-    let currentRoute = digg(this, "configuration", "routes", "rootRoute")
-    let currentPath = this.request.path()
-    let viewPath
-
-    const matchResult = this.matchPathWithRoutes(currentRoute, currentPath)
-    let action = this.params.action ? inflection.camelize(this.params.action.replaceAll("-", "_"), true) : undefined
-    let controller = this.params.controller
-
-    if (!matchResult) {
-      const __filename = fileURLToPath(import.meta.url)
-      const __dirname = dirname(__filename)
-
-      controller = "errors"
-      controllerPath = "./built-in/errors/controller.js"
-      action = "notFound"
-      viewPath = await fs.realpath(`${__dirname}/built-in/errors`)
-    } else if (action) {
-      if (!controller) controller = "_root"
-
-      controllerPath = `${this.configuration.getDirectory()}/src/routes/${controller}/controller.js`
-      viewPath = `${this.configuration.getDirectory()}/src/routes/${controller}`
-    } else {
-      throw new Error(`Matched the route but didn't know what to do with it: ${currentPath} (action: ${action}, controller: ${controller}, params: ${JSON.stringify(this.params)})`)
-    }
-
-    const controllerClassImport = await import(controllerPath)
-    const controllerClass = controllerClassImport.default
-    const controllerInstance = new controllerClass({
-      action,
-      configuration: this.configuration,
-      controller,
-      params: this.params,
-      request: this.request,
-      response: this.response,
-      viewPath
-    })
-
-    if (!(action in controllerInstance)) {
-      throw new Error(`Missing action on controller: ${controller}#${action}`)
-    }
-
-    await this.configuration.ensureConnections(async () => {
-      await controllerInstance._runBeforeCallbacks()
-      await controllerInstance[action]()
-    })
-  }
-
-  /**
-   * @param {import("./base-route.js").default} route
-   * @param {string} path
-   * @returns {{restPath: string} | undefined}
-   */
-  matchPathWithRoutes(route, path) {
-    const pathWithoutSlash = path.replace(/^\//, "")
-
-    for (const subRoute of route.routes) {
-      const matchResult = subRoute.matchWithPath({
-        params: this.params,
-        path: pathWithoutSlash,
-        request: this.request
-      })
-
-      if (!matchResult) continue
-
-      const {restPath} = matchResult
-
-      if (restPath) {
-        return this.matchPathWithRoutes(subRoute, restPath)
-      }
-
-      return matchResult
-    }
-  }
-}

package/src/routes/resource-route.js

@@ -1,61 +0,0 @@
-// @ts-check
-
-import BaseRoute from "./base-route.js"
-import BasicRoute from "./basic-route.js"
-import escapeStringRegexp from "escape-string-regexp"
-import restArgsError from "../utils/rest-args-error.js"
-
-class VelociousRouteResourceRoute extends BasicRoute {
-  /**
-   * @param {object} args
-   * @param {string} args.name
-   */
-  constructor({name, ...restArgs}) {
-    super()
-    restArgsError(restArgs)
-    this.name = name
-    this.regExp = new RegExp(`^(${escapeStringRegexp(name)})(.*)$`)
-  }
-
-  /**
-   * @param {object} args
-   * @param {Record<string, any>} args.params
-   * @param {string} args.path
-   * @param {import("../http-server/client/request.js").default} args.request
-   * @returns {{restPath: string} | undefined}
-   */
-  matchWithPath({params, path, request}) {
-    const match = path.match(this.regExp)
-
-    if (match) {
-      const [_beginnigSlash, _matchedName, restPath] = match // eslint-disable-line no-unused-vars
-
-      let action = "index"
-      let subRoutesMatchesRestPath = false
-
-      for (const route of this.routes) {
-        if (route.matchWithPath({params, path: restPath, request})) {
-          subRoutesMatchesRestPath = true
-        }
-      }
-
-      if (!subRoutesMatchesRestPath) {
-        if (request.httpMethod() == "POST") {
-          action = "create"
-        } else if (restPath.match(/\/(.+)/)) {
-          // TODO: This should change the action to "show" and set the "resource_name_id" in params.
-          action = "show"
-        }
-      }
-
-      params.action = action
-      params.controller = this.name
-
-      return {restPath}
-    }
-  }
-}
-
-BaseRoute.registerRouteResourceType(VelociousRouteResourceRoute)
-
-export default VelociousRouteResourceRoute

package/src/routes/root-route.js

@@ -1,6 +0,0 @@
-// @ts-check
-
-import BasicRoute from "./basic-route.js"
-
-export default class VelociousRootRoute extends BasicRoute {
-}

package/src/templates/configuration.js

@@ -1,60 +0,0 @@
-import AsyncTrackedMultiConnection from "velocious/src/database/pool/async-tracked-multi-connection.js"
-import Configuration from "velocious/src/configuration.js"
-import fs from "fs/promises"
-import InitializerFromRequireContext from "../../../../src/database/initializer-from-require-context.js"
-import MysqlDriver from "velocious/src/database/drivers/mysql/index.js"
-import path from "path"
-import requireContext from "require-context"
-
-export default new Configuration({
-  database: {
-    development: {
-      default: {
-        driver: MysqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mysql",
-        host: "mariadb",
-        username: "username",
-        password: "password",
-        database: "database_development"
-      }
-    },
-    production: {
-      default: {
-        driver: MysqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mysql",
-        host: "mariadb",
-        username: "username",
-        password: "password",
-        database: "database_production"
-      }
-    },
-    test: {
-      default: {
-        driver: MysqlDriver,
-        poolType: AsyncTrackedMultiConnection,
-        type: "mysql",
-        host: "mariadb",
-        username: "username",
-        password: "password",
-        database: "database_test"
-      }
-    }
-  },
-  initializeModels: async ({configuration}) => {
-    const modelsPath = await fs.realpath(`${path.dirname(import.meta.dirname)}/../src/models`)
-    const requireContextModels = requireContext(modelsPath, true, /^(.+)\.js$/)
-    const initializerFromRequireContext = new InitializerFromRequireContext({requireContext: requireContextModels})
-
-    await configuration.ensureConnections(async () => {
-      await initializerFromRequireContext.initialize({configuration})
-    })
-  },
-  locale: () => "en",
-  locales: ["de", "en"],
-  localeFallbacks: {
-    de: ["de", "en"],
-    en: ["en", "de"]
-  }
-})

package/src/templates/generate-migration.js

@@ -1,11 +0,0 @@
-import Migration from "velocious/src/database/migration/index.js"
-
-export default class __MIGRATION_NAME__ extends Migration {
-  async up() {
-    await this.execute("...")
-  }
-
-  async down() {
-    await this.execute("...")
-  }
-}

package/src/templates/generate-model.js

@@ -1,6 +0,0 @@
-import Record from "velocious/src/database/record/index.js"
-
-class __MODEL_NAME__ extends Record {
-}
-
-export default __MODEL_NAME__

package/src/templates/routes.js

@@ -1,11 +0,0 @@
-import Routes from "velocious/src/routes/index.js"
-
-const routes = new Routes()
-
-routes.draw((route) => {
-  route.resources("tasks", (route) => {
-    route.get("users")
-  })
-})
-
-export default {routes}

package/src/testing/request-client.js

@@ -1,77 +0,0 @@
-// @ts-check
-
-class Response {
-  /**
-   * @param {globalThis.Response} fetchResponse
-   */
-  constructor(fetchResponse) {
-    this.fetchResponse = fetchResponse
-  }
-
-  /**
-   * @returns {Promise<void>}
-   */
-  async parse() {
-    this._body = await this.fetchResponse.text()
-
-    if (this.statusCode() != 200) throw new Error(`Request failed with code ${this.statusCode()} and body: ${this.body()}`)
-  }
-
-  /** @returns {string} */
-  body() {
-    if (!this._body) throw new Error("Response body not parsed yet. Call parse() first.")
-
-    return this._body
-  }
-
-  /** @returns {string | null} */
-  contentType() {
-    return this.fetchResponse.headers.get("content-type")
-  }
-
-  /** @returns {number} */
-  statusCode() { return this.fetchResponse.status }
-}
-
-export default class RequestClient {
-  host = "localhost"
-  port = 31006
-
-  /**
-   * @param {string} path
-   * @returns {Promise<Response>}
-   */
-  async get(path) {
-    const fetchResponse = await fetch(`http://${this.host}:${this.port}${path}`)
-    const response = new Response(fetchResponse)
-
-    await response.parse()
-
-    return response
-  }
-
-  /**
-   * @param {string} path
-   * @param {object} data
-   * @returns {Promise<Response>}
-   */
-  async post(path, data) {
-    const fetchResponse = await fetch(
-      `http://${this.host}:${this.port}${path}`,
-      {
-        body: JSON.stringify(data),
-        headers: {
-          "Content-Type": "application/json"
-        },
-        method: "POST",
-        signal: AbortSignal.timeout(5000)
-      }
-    )
-
-    const response = new Response(fetchResponse)
-
-    await response.parse()
-
-    return response
-  }
-}