stacks 0.56.24 → 0.58.18

package/core/src/router/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@stacksjs/router",
+  "type": "module",
+  "version": "0.58.18",
+  "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/src/router#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stacksjs/stacks.git",
+    "directory": "./storage/framework/core/src/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"
+  ],
+  "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:*",
+    "unplugin-vue-router": "^0.7.0",
+    "vue-router": "^4.2.5"
+  },
+  "devDependencies": {
+    "@stacksjs/development": "workspace:*"
+  }
+}

package/core/src/router/src/index.ts

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

package/core/src/router/src/middleware.ts

@@ -0,0 +1,34 @@
+import fs from 'node:fs'
+import { promisify } from 'node:util'
+import { appPath, path } 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 = []
+  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
+}
+
+export const middlewares = await importMiddlewares(appPath('middleware'))

package/core/src/router/src/request.ts

@@ -0,0 +1,44 @@
+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/src/router/src/router.ts

@@ -0,0 +1,162 @@
+import type { RedirectCode, Route, RouteGroupOptions, StatusCode } from '@stacksjs/types'
+import { projectPath } from '@stacksjs/path'
+
+export interface RouterInterface {
+  get(url: Route['url'], callback: Route['callback']): 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: 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 addRoute(method: Route['method'], uri: string, callback: Route['callback'] | string | object, statusCode: StatusCode): void {
+    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
+    }
+
+    this.routes.push({
+      name,
+      method,
+      url: uri,
+      uri,
+      callback: routeCallback,
+      pattern,
+      statusCode,
+      paramNames: [],
+    })
+  }
+
+  public get(path: Route['url'], callback: Route['callback']): this {
+    this.addRoute('GET', path, callback, 200)
+    return this
+  }
+
+  public post(path: Route['url'], callback: Route['callback']): this {
+    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: RouteGroupOptions | (() => void), callback?: () => void): this {
+    let cb: () => void
+
+    if (typeof options === 'function') {
+      cb = options
+      options = {}
+    }
+    else {
+      if (!callback)
+        throw new Error('Missing callback function for route group.')
+      cb = callback
+    }
+
+    const { prefix = '', middleware = [] } = options
+
+    // 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
+      // Assuming you have a middleware property for each route.
+
+      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[]> {
+    // const routeFileData = (await readTextFile(projectPath('routes/web.ts'))).data
+
+    await import(projectPath('routes/api.ts'))
+
+    // run routes/web.ts
+    // const webRoutesPath = projectPath('routes/web.ts')
+    // await runCommand(`bun ${webRoutesPath}`)
+
+    // set this.routes to a mapped array of routes that matches the pattern
+
+    return this.routes
+  }
+}
+
+export const route = new Router()

package/core/src/router/src/server.ts

@@ -0,0 +1,154 @@
+import { extname } from 'node:path'
+import { URL } from 'node:url'
+import type { MiddlewareType, Route, StatusCode } from '@stacksjs/types'
+import { localUrl } from '@stacksjs/config'
+import { middlewares } from './middleware'
+import { request } from './request'
+import { route } from '.'
+
+interface ServeOptions {
+  host?: string
+  port?: number
+  tunnel?: boolean
+}
+
+export async function serve(options: ServeOptions = {}) {
+  const hostname = options.host || options.tunnel ? await localUrl({ type: 'backend' }) : '127.0.0.1'
+  const port = options.port || 3000
+
+  Bun.serve({
+    hostname,
+    port,
+
+    fetch(req: Request) {
+      // eslint-disable-next-line no-console
+      console.log(req)
+      return serverResponse(req)
+    },
+  })
+}
+
+export async function serverResponse(req: Request) {
+  // eslint-disable-next-line no-console
+  console.log('serverResponse', req)
+  const routesList: Route[] = await route.getRoutes()
+  const url = new URL(req.url)
+
+  const foundRoute: Route | undefined = routesList.find((route: Route) => {
+    const pattern = new RegExp(`^${route.uri.replace(/:\w+/g, '\\w+')}$`)
+
+    return pattern.test(url.pathname)
+  })
+
+  // if (url.pathname === '/favicon.ico')
+  //   return new Response('')
+
+  if (!foundRoute)
+    return new Response('Not found', { 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/src/router/tests/example.test.ts

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

package/core/src/scheduler/README.md

@@ -0,0 +1,137 @@
+# Stacks SMS
+
+Stacks SMS is driver system for sending SMS messages.
+
+## ☘️ Features
+
+- 📦 Send SMS
+
+## 🤖 Usage
+
+```bash
+bun install -d @stacksjs/sms
+```
+
+You may now use it in your project:
+
+```ts
+import * as sms from '@stacksjs/sms'
+
+/* Then choose a driver. E.g for twilio */
+const notification = sms.twilio
+
+notification.send(SMSOptions)
+
+interface SMSOptions {
+  to: string
+  content: string
+  from?: string
+  attachments?: AttachmentOptions[]
+  id?: string
+}
+```
+
+### Drivers
+
+Drivers are configured with the following environment variables:
+
+#### Twilio
+
+```bash
+TWILIO_ACCOUNT_SID=ACtest
+TWILIO_AUTH_TOKEN=testtoken
+TWILIO_FROM_NUMBER=+112345
+TWILIO_TO_NUMBER=+145678
+```
+
+#### Nexmo
+
+```bash
+VONAGE_API_KEY=VN123
+VONAGE_API_SECRET=testkey
+VONAGE_FROM_NUMBER=+112345
+```
+
+#### Gupshup
+
+```bash
+GUPSHUP_USER_ID=GU123
+GUPSHUP_PASSWORD=password
+```
+
+#### Plivo
+
+```bash
+PLIVO_ACCOUNT_ID=PA123
+PLIVO_AUTH_TOKEN=testtoken
+PLIVO_FROM_NUMBER=+112345
+```
+
+#### SMS77
+
+```bash
+SMS77_API_KEY=SA123
+SMS77_FROM=from@example.com
+```
+
+#### SNS
+
+```bash
+SMS77_API_KEY=SA123
+SMS77_FROM=from@example.com
+```
+
+#### Telnyx
+
+```bash
+TELNYX_API_KEY=TA123
+TELNYX_MESSAGE_PROFILE_ID=testprofileid
+TELNYX_FROM=from@example.com
+```
+
+#### Termii
+
+```bash
+TERMII_API_KEY=TermA123
+TERMII_SENDER=from@example.com
+```
+
+Learn more in the docs.
+
+## 🧪 Testing
+
+```bash
+bun test
+```
+
+## 📈 Changelog
+
+Please see our [releases](https://github.com/stacksjs/stacks/releases) page for more information on what has changed recently.
+
+## 🚜 Contributing
+
+Please review the [Contributing Guide](https://github.com/stacksjs/contributing) for details.
+
+## 🏝 Community
+
+For help, discussion about best practices, or any other conversation that would benefit from being searchable:
+
+[Discussions on GitHub](https://github.com/stacksjs/stacks/discussions)
+
+For casual chit-chat with others using this package:
+
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
+
+## 🙏🏼 Credits
+
+Many thanks to the following core technologies & people who have contributed to this package:
+
+- [Chris Breuer](https://github.com/chrisbbreuer)
+- [Novu](https://novu.co/)
+- [All Contributors](../../contributors)
+
+## 📄 License
+
+The MIT License (MIT). Please see [LICENSE](https://github.com/stacksjs/stacks/tree/main/LICENSE.md) for more information.
+
+Made with 💙

package/core/src/scheduler/build.ts

@@ -0,0 +1,8 @@
+import { log, runCommand } from '@stacksjs/cli'
+
+const result = await runCommand('bun build ./src/index.ts --outdir dist --format esm --external node-cron --target bun', {
+  cwd: import.meta.dir,
+})
+
+if (result.isErr())
+  log.error(result.error)