stacks 0.58.72 → 0.59.1

package/core/router/package.json

@@ -1,64 +0,0 @@
-{
-  "name": "@stacksjs/router",
-  "type": "module",
-  "version": "0.58.72",
-  "description": "The Stacks framework router.",
-  "author": "Chris Breuer",
-  "license": "MIT",
-  "funding": "https://github.com/sponsors/chrisbbreuer",
-  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/router#readme",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/stacksjs/stacks.git",
-    "directory": "./storage/framework/core/router"
-  },
-  "bugs": {
-    "url": "https://github.com/stacksjs/stacks/issues"
-  },
-  "keywords": [
-    "router",
-    "stacks",
-    "framework",
-    "typescript",
-    "javascript"
-  ],
-  "exports": {
-    ".": {
-      "bun": "./src/index.ts",
-      "import": "./dist/index.js"
-    },
-    "./*": {
-      "bun": "./src/*",
-      "import": "./dist/*"
-    }
-  },
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
-    "prepublishOnly": "bun --bun run build"
-  },
-  "peerDependencies": {
-    "@stacksjs/config": "workspace:*",
-    "unplugin-vue-router": "^0.7.0",
-    "vue-router": "^4.2.5"
-  },
-  "dependencies": {
-    "@stacksjs/config": "workspace:*",
-    "@stacksjs/logging": "workspace:*",
-    "unplugin-vue-router": "^0.7.0",
-    "vue-router": "^4.2.5"
-  },
-  "devDependencies": {
-    "@stacksjs/development": "workspace:*"
-  }
-}

package/core/router/src/index.ts

@@ -1,4 +0,0 @@
-export * from './middleware'
-export * from './request'
-export * from './server'
-export * from './router'

package/core/router/src/middleware.ts

@@ -1,34 +0,0 @@
-import { appPath } from '@stacksjs/path'
-import type { MiddlewareType } from '@stacksjs/types'
-
-export class Middleware implements MiddlewareType {
-  name: string
-  priority: number
-
-  handle: Function
-
-  constructor(data: MiddlewareType) {
-    this.name = data.name
-    this.priority = data.priority
-    this.handle = data.handle
-  }
-}
-
-// const readdir = promisify(fs.readdir)
-
-async function importMiddlewares(directory: string) {
-  // const middlewares = []
-  // TODO: somehow this breaks ./buddy dev
-  // const files = await readdir(directory)
-
-  // for (const file of files) {
-  //   // Dynamically import the middleware
-  //   const imported = await import(path.join(directory, file))
-  //   middlewares.push(imported.default)
-  // }
-
-  // return middlewares
-  return [directory] // fix this: return array of middlewares
-}
-
-export const middlewares = await importMiddlewares(appPath('middleware'))

package/core/router/src/request.ts

@@ -1,44 +0,0 @@
-interface RequestData {
-  [key: string]: string
-}
-
-type RouteParams = { [key: string]: string } | null
-
-export class Request {
-  private query: RequestData = {}
-  private params: RouteParams = null
-
-  public addQuery(url: URL): void {
-    this.query = Object.fromEntries(url.searchParams)
-  }
-
-  public get(element: string): string | number | undefined {
-    return this.query[element]
-  }
-
-  public all(): RequestData {
-    return this.query
-  }
-
-  public has(element: string): boolean {
-    return element in this.query
-  }
-
-  public isEmpty(): boolean {
-    return Object.keys(this.query).length === 0
-  }
-
-  public extractParamsFromRoute(routePattern: string, pathname: string): void {
-    const pattern = new RegExp(`^${routePattern.replace(/:(\w+)/g, (match, paramName) => `(?<${paramName}>\\w+)`)}$`)
-    const match = pattern.exec(pathname)
-
-    if (match?.groups)
-      this.params = match?.groups
-  }
-
-  public getParams(key: string): number | string | null {
-    return this.params ? (this.params[key] || null) : null
-  }
-}
-
-export const request = new Request()

package/core/router/src/router.ts

@@ -1,294 +0,0 @@
-import type { RedirectCode, Route, RouteGroupOptions, StatusCode } from '@stacksjs/types'
-import { path as p, routesPath } from '@stacksjs/path'
-import { log } from '@stacksjs/logging'
-import { pascalCase } from '@stacksjs/strings'
-
-type Prefix = string
-
-export interface RouterInterface {
-  get: (url: Route['url'], callback: Route['callback']) => Promise<this>
-  post: (url: Route['url'], callback: Route['callback']) => this
-  view: (url: Route['url'], callback: Route['callback']) => this
-  redirect: (url: Route['url'], callback: Route['callback'], status?: RedirectCode) => this
-  delete: (url: Route['url'], callback: Route['callback']) => this
-  patch: (url: Route['url'], callback: Route['callback']) => this
-  put: (url: Route['url'], callback: Route['callback']) => this
-  group: (options: Prefix | RouteGroupOptions, callback: () => void) => this
-  name: (name: string) => this
-  middleware: (middleware: Route['middleware']) => this
-  getRoutes: () => Promise<Route[]>
-}
-
-export class Router implements RouterInterface {
-  private routes: Route[] = []
-  private apiPrefix = '/api'
-  private groupPrefix = ''
-  private path = ''
-
-  private addRoute(method: Route['method'], uri: string, callback: Route['callback'] | string | object, statusCode: StatusCode): this {
-    const name = uri.replace(/\//g, '.').replace(/:/g, '') // we can improve this
-    const pattern = new RegExp(`^${uri.replace(/:[a-zA-Z]+/g, (_match) => {
-      return '([a-zA-Z0-9-]+)'
-    })}$`)
-
-    let routeCallback: Route['callback']
-
-    if (typeof callback === 'string' || typeof callback === 'object') {
-      // Convert string or object to RouteCallback
-      routeCallback = () => callback
-    }
-    else {
-      routeCallback = callback
-    }
-
-    log.debug(`Adding route: ${method} ${uri} with name ${name}`)
-
-    this.routes.push({
-      name,
-      method,
-      url: uri,
-      uri,
-      callback: routeCallback,
-      pattern,
-      statusCode,
-      paramNames: [],
-    })
-
-    return this
-  }
-
-  public async get(path: Route['url'], callback: Route['callback']): Promise<this> {
-    this.path = this.normalizePath(path)
-    log.debug(`Normalized Path: ${this.path}`)
-
-    callback = await this.resolveCallback(callback)
-
-    const uri = this.prepareUri(this.path)
-    log.debug(`Prepared URI: ${uri}`)
-
-    return this.addRoute('GET', uri, callback, 200)
-  }
-
-  public async health(): Promise<this> {
-    const healthModule = await import(p.userActionsPath('HealthAction.ts'))
-    const callback = healthModule.default.handle
-
-    const path = healthModule.default.path ?? `${this.apiPrefix}/health`
-
-    this.addRoute('GET', path, callback, 200)
-
-    return this
-  }
-
-  public async job(path: Route['url']): Promise<this> {
-    path = pascalCase(path)
-
-    // removes the potential `JobJob` suffix in case the user does not choose to use the Job suffix in their file name
-    const jobModule = await import(p.userJobsPath(`${path}Job.ts`.replace(/JobJob/, 'Job')))
-    const callback = jobModule.default.handle
-
-    path = this.prepareUri(path)
-    this.addRoute('GET', path, callback, 200)
-
-    return this
-  }
-
-  public async action(path: Route['url']): Promise<this> {
-    path = pascalCase(path) // actions are PascalCase
-
-    // removes the potential `ActionAction` suffix in case the user does not choose to use the Job suffix in their file name
-    const actionModule = await import(p.userActionsPath(`${path}Action.ts`.replace(/ActionAction/, 'Action')))
-    const callback = actionModule.default.handle
-
-    path = this.prepareUri(path)
-    this.addRoute('GET', path, callback, 200)
-
-    return this
-  }
-
-  public post(path: Route['url'], callback: Route['callback']): this {
-    path = this.prepareUri(path)
-    this.addRoute('POST', path, callback, 201)
-
-    return this
-  }
-
-  public view(path: Route['url'], callback: Route['callback']): this {
-    this.addRoute('GET', path, callback, 200)
-
-    return this
-  }
-
-  public redirect(path: Route['url'], callback: Route['callback'], _status?: RedirectCode): this {
-    this.addRoute('GET', path, callback, 302)
-
-    return this
-  }
-
-  public delete(path: Route['url'], callback: Route['callback']): this {
-    this.addRoute('DELETE', path, callback, 204)
-    return this
-  }
-
-  public patch(path: Route['url'], callback: Route['callback']): this {
-    this.addRoute('PATCH', path, callback, 202)
-    return this
-  }
-
-  public put(path: Route['url'], callback: Route['callback']): this {
-    this.addRoute('PUT', path, callback, 202)
-    return this
-  }
-
-  public group(options: string | RouteGroupOptions, callback?: () => void): this {
-    if (typeof options === 'string')
-      options = options.startsWith('/') ? options.slice(1) : options
-
-    let cb: () => void
-
-    this.prepareGroupPrefix(options)
-
-    if (typeof options === 'function') {
-      cb = options
-      options = {}
-    }
-
-    if (!callback)
-      throw new Error('Missing callback function for your route group.')
-
-    cb = callback
-
-    const { prefix, middleware = [] } = options as RouteGroupOptions
-
-    // Save a reference to the original routes array
-    const originalRoutes = this.routes
-
-    // Create a new routes array for the duration of the callback
-    this.routes = []
-
-    // Execute the callback. This will add routes to the new this.routes array
-    cb()
-
-    // For each route added by the callback, adjust the URI and add to the original routes array
-    this.routes.forEach((r) => {
-      r.uri = `${prefix}${r.uri}`
-
-      if (middleware.length)
-        r.middleware = middleware
-
-      originalRoutes.push(r)
-      return this
-    })
-
-    // Restore the original routes array.
-    this.routes = originalRoutes
-
-    return this
-  }
-
-  public name(name: string): this {
-    // @ts-expect-error - this is fine for now
-    this.routes[this.routes.length - 1].name = name
-
-    return this
-  }
-
-  public middleware(middleware: Route['middleware']): this {
-    // @ts-expect-error - this is fine for now
-    this.routes[this.routes.length - 1].middleware = middleware
-
-    return this
-  }
-
-  public prefix(prefix: string): this {
-    // @ts-expect-error - this is fine for now
-    this.routes[this.routes.length - 1].prefix = prefix
-
-    return this
-  }
-
-  public async getRoutes(): Promise<Route[]> {
-    await import(routesPath('api.ts'))
-
-    return this.routes
-  }
-
-  private setGroupPrefix(prefix: string, options: RouteGroupOptions = {}) {
-    if (prefix !== '') {
-      prefix = `/${this.groupPrefix}/${prefix}`.replace(/\/\//g, '/') // remove double slashes in case there are any
-      this.groupPrefix = prefix
-      return
-    }
-
-    // Ensure options is always treated as an object, even if it's undefined or a function
-    const effectiveOptions = typeof options === 'object' ? options : {}
-
-    this.groupPrefix = effectiveOptions.prefix ?? prefix ?? ''
-  }
-
-  private prepareGroupPrefix(options: string | RouteGroupOptions): void {
-    if (this.groupPrefix !== '' && typeof options !== 'string')
-      return this.setGroupPrefix(this.groupPrefix, options)
-
-    if (typeof options === 'string')
-      return this.setGroupPrefix(options)
-
-    return this.setGroupPrefix('', options)
-  }
-
-  private async resolveCallback(callback: Route['callback']): Promise<Route['callback']> {
-    if (callback instanceof Promise) {
-      const actionModule = await callback
-      return actionModule.default
-    }
-
-    if (typeof callback === 'string')
-      return this.importCallbackFromPath(callback, this.path)
-
-    // in this case, the callback ends up being a function
-    return callback
-  }
-
-  private async importCallbackFromPath(callbackPath: string, originalPath: string): Promise<Route['callback']> {
-    let modulePath = callbackPath
-    let importPathFunction = p.appPath // Default import path function
-
-    if (callbackPath.startsWith('../'))
-      importPathFunction = p.routesPath
-
-    // Remove trailing .ts if present
-    modulePath = modulePath.endsWith('.ts') ? modulePath.slice(0, -3) : modulePath
-    const actionModule = await import(importPathFunction(`${modulePath}.ts`))
-
-    // Use custom path from action module if available
-    const newPath = actionModule.default.path ?? originalPath
-    this.updatePathIfNeeded(newPath, originalPath)
-
-    return actionModule.default.handle
-  }
-
-  private normalizePath(path: string): string {
-    return path.endsWith('/') ? path.slice(0, -1) : path
-  }
-
-  public prepareUri(path: string) {
-    // if string starts with / then remove it because we are adding it back in the next line
-    if (path.startsWith('/'))
-      path = path.slice(1)
-
-    path = `${this.apiPrefix}${this.groupPrefix}/${path}`
-
-    // if path ends in "/", then remove it
-    // e.g. triggered when route is "/"
-    return path.endsWith('/') ? path.slice(0, -1) : path
-  }
-
-  private updatePathIfNeeded(newPath: string, originalPath: string): void {
-    if (newPath !== originalPath) {
-    // Logic to update the path if needed, based on the action module's custom path
-      this.path = newPath
-    }
-  }
-}
-
-export const route = new Router()

package/core/router/src/server.ts

@@ -1,173 +0,0 @@
-import { URL } from 'node:url'
-import process from 'node:process'
-import { log } from '@stacksjs/logging'
-import type { MiddlewareType, Route, StatusCode } from '@stacksjs/types'
-import { middlewares } from './middleware'
-import { request } from './request'
-import { route } from '.'
-
-interface ServeOptions {
-  host?: string
-  port?: number
-  debug?: boolean
-  timezone?: string
-}
-
-export async function serve(options: ServeOptions = {}) {
-  const hostname = options.host || 'localhost'
-  const port = options.port || 3000
-  const development = options.debug ? true : process.env.APP_ENV !== 'production' && process.env.APP_ENV !== 'prod'
-
-  if (options.timezone)
-    process.env.TZ = options.timezone
-
-  Bun.serve({
-    hostname,
-    port,
-    development,
-
-    fetch(req: Request) {
-      return serverResponse(req)
-    },
-  })
-}
-
-export async function serverResponse(req: Request) {
-  log.info(`Incoming Request: ${req.method} ${req.url}`)
-  log.info(`Headers: ${JSON.stringify(req.headers)}`)
-  log.info(`Body: ${JSON.stringify(req.body)}`)
-  // log.info(`Query: ${JSON.stringify(req.query)}`)
-  // log.info(`Params: ${JSON.stringify(req.params)}`)
-  // log.info(`Cookies: ${JSON.stringify(req.cookies)}`)
-
-  // Trim trailing slash from the URL if it's not the root '/'
-  // This automatically allows for route definitions, like
-  // '/about' and '/about/' to be treated as the same
-  const trimmedUrl = req.url.endsWith('/') && req.url.length > 1 ? req.url.slice(0, -1) : req.url
-
-  const routesList: Route[] = await route.getRoutes()
-  log.info(`Routes List: ${JSON.stringify(routesList)}`)
-
-  const url = new URL(trimmedUrl)
-  log.info(`URL: ${JSON.stringify(url)}`)
-
-  const foundRoute: Route | undefined = routesList.find((route: Route) => {
-    const pattern = new RegExp(`^${route.uri.replace(/:\w+/g, '\\w+')}$`)
-
-    return pattern.test(url.pathname)
-  })
-
-  log.info(`Found Route: ${JSON.stringify(foundRoute)}`)
-
-  // if (url.pathname === '/favicon.ico')
-  //   return new Response('')
-
-  if (!foundRoute)
-    return new Response('Pretty 404 page coming soon', { status: 404 }) // TODO: create a pretty 404 page
-
-  addRouteParamsAndQuery(url, foundRoute)
-  executeMiddleware(foundRoute)
-
-  return execute(foundRoute, req, { statusCode: foundRoute?.statusCode })
-}
-
-function addRouteParamsAndQuery(url: URL, route: Route): void {
-  if (!isObjectNotEmpty(url.searchParams))
-    request.addQuery(url)
-
-  request.extractParamsFromRoute(route.uri, url.pathname)
-}
-
-function executeMiddleware(route: Route): void {
-  const { middleware = null } = route
-
-  if (middleware && middlewares && isObjectNotEmpty(middlewares)) {
-    if (isString(middleware)) {
-      const middlewareItem: MiddlewareType = middlewares.find((middlewareItem: MiddlewareType) => {
-        return middlewareItem.name === middleware
-      })
-
-      if (middlewareItem)
-        middlewareItem.handle() // Invoke only if it exists and is not undefined.
-    }
-    else {
-      middleware.forEach((m) => {
-        const middlewareItem: MiddlewareType = middlewares.find((middlewareItem: MiddlewareType) => {
-          return middlewareItem.name === m
-        })
-
-        if (middlewareItem)
-          middlewareItem.handle() // Again, invoke only if it exists.
-      })
-    }
-  }
-}
-
-interface Options {
-  statusCode?: StatusCode
-}
-
-function execute(route: Route, request: Request, { statusCode }: Options) {
-  if (!statusCode)
-    statusCode = 200
-
-  if (route?.method === 'GET' && (statusCode === 301 || statusCode === 302)) {
-    const callback = String(route.callback)
-    const response = Response.redirect(callback, statusCode)
-
-    return noCache(response)
-  }
-
-  if (route?.method !== request.method)
-    return new Response('Method not allowed', { status: 405 })
-
-  // Check if it's a path to an HTM L file
-  if (isString(route.callback) && extname(route.callback) === '.html') {
-    try {
-      const fileContent = Bun.file(route.callback)
-
-      return new Response(fileContent, { headers: { 'Content-Type': 'text/html' } })
-    }
-    catch (error) {
-      return new Response('Error reading the HTML file', { status: 500 })
-    }
-  }
-
-  if (isString(route.callback))
-    return new Response(route.callback)
-
-  if (isFunction(route.callback)) {
-    const result = (route.callback)()
-    return new Response(JSON.stringify(result))
-  }
-
-  if (isObject(route.callback))
-    return new Response(JSON.stringify(route.callback))
-
-  // If no known type matched, return a generic error.
-  return new Response('Unknown callback type.', { status: 500 })
-}
-
-function noCache(response: Response) {
-  response.headers.set('Cache-Control', 'no-store, no-cache, must-revalidate, proxy-revalidate')
-  response.headers.set('Pragma', 'no-cache')
-  response.headers.set('Expires', '0')
-
-  return response
-}
-
-function isString(val: unknown): val is string {
-  return typeof val === 'string'
-}
-
-function isObjectNotEmpty(obj: object): boolean {
-  return Object.keys(obj).length > 0
-}
-
-function isFunction(val: unknown): val is Function {
-  return typeof val === 'function'
-}
-
-function isObject(val: unknown): val is object {
-  return val !== null && typeof val === 'object' && !Array.isArray(val)
-}

package/core/router/tests/example.test.ts

@@ -1,5 +0,0 @@
-describe('example test', () => {
-  it('assert', () => {
-    expect(1).toBe(1)
-  })
-})

package/core/router/tsconfig.json

@@ -1,3 +0,0 @@
-{
-  "extends": "../tsconfig.json"
-}