@stacksjs/bun-router 0.0.2

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './query-preservation';

package/dist/utils/query-preservation.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Generate the client-side script for query preservation
+ * This script intercepts link clicks and preserves specified query params
+ */
+export declare function generateQueryPreservationScript(config: QueryPreservationConfig): string;
+/**
+ * Inject the query preservation script into HTML content
+ * Inserts before </head> or </body> if </head> not found
+ */
+export declare function injectQueryPreservationScript(html: string, config: QueryPreservationConfig): string;
+/**
+ * Build a URL with preserved query parameters
+ * Server-side utility for generating links
+ */
+export declare function buildUrlWithPreservedParams(path: string, currentUrl: string | URL, config: QueryPreservationConfig, additionalParams?: Record<string, string>): string;
+/**
+ * Default configuration
+ */
+export declare const defaultQueryPreservationConfig: QueryPreservationConfig;
+/**
+ * Query Parameter Preservation
+ *
+ * Automatically preserves specified query parameters across navigation.
+ * This is useful for maintaining state like siteId, theme, locale, etc.
+ */
+export declare interface QueryPreservationConfig {
+  enabled?: boolean
+  preserve?: string[]
+  exclude?: string[]
+  routes?: string[]
+}

package/dist/utils.d.ts

@@ -0,0 +1,69 @@
+import type { ActionHandler, ActionHandlerClass, RouteHandler } from './types';
+/**
+ * Normalizes a path by ensuring it starts with a forward slash and has no trailing slash
+ * @param path The path to normalize
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * Converts a string path to an action path for dynamic imports
+ * @param path The path to convert (e.g., 'Actions/Home/IndexAction')
+ */
+export declare function toActionPath(path: string): string;
+/**
+ * Checks if a handler is a class constructor implementing ActionHandlerClass
+ * @param handler The handler to check
+ */
+export declare function isActionClass(handler: ActionHandler): handler is new () => ActionHandlerClass;
+/**
+ * Checks if a handler is a route handler function
+ * @param handler The handler to check
+ */
+export declare function isRouteHandler(handler: ActionHandler): handler is RouteHandler;
+/**
+ * Extracts named parameters from a path pattern
+ * @param pattern The path pattern (e.g., '/users/{id}/posts/{postId}')
+ */
+export declare function extractParamNames(pattern: string): string[];
+/**
+ * Creates a regex pattern from a path pattern
+ * @param pattern The path pattern
+ */
+export declare function createPathRegex(pattern: string): RegExp;
+/**
+ * Matches a path against a pattern and extracts parameters
+ * @param pattern The path pattern (e.g., '/users/{id}')
+ * @param path The actual path (e.g., '/users/123')
+ * @param params Output parameter object that will contain extracted parameters
+ * @param constraints Optional constraints for route parameters
+ * @returns Boolean indicating whether the path matches the pattern
+ */
+export declare function matchPath(pattern: string, path: string, params: Record<string, string>, constraints?: Record<string, string>): boolean;
+/**
+ * Joins path segments ensuring proper formatting
+ * @param segments Path segments to join
+ */
+export declare function joinPaths(...segments: string[]): string;
+/**
+ * Validates a route path format
+ * @param path The path to validate
+ */
+export declare function validatePath(path: string): boolean;
+/**
+ * Check if a file exists at the given path
+ * @param path The file path to check
+ */
+export declare function fileExists(path: string): Promise<boolean>;
+/**
+ * Resolve a view name to an actual file path
+ * @param viewName The view name (without extension)
+ * @param viewsPath The base path for views
+ * @param extensions File extensions to try
+ */
+export declare function resolveViewPath(viewName: string, viewsPath: string, extensions: string[]): Promise<string | null>;
+/**
+ * Basic HTML template processing - replaces {{ varName }} with the corresponding value
+ * @param template The HTML template string
+ * @param data The data to inject into the template
+ */
+export declare function processHtmlTemplate(template: string, data: Record<string, any>): string;
+export * from './utils/query-preservation';

package/dist/validation/validator.d.ts

@@ -0,0 +1,169 @@
+/**
+ * Validation middleware factory
+ */
+export declare function createValidationMiddleware(rules: ValidationRules, config?: ValidatorConfig): void;
+/**
+ * Factory function to create validation rule builder
+ */
+export declare function rule(): ValidationRuleBuilder;
+/**
+ * Built-in validation rules
+ */
+export declare const BuiltInRules: {
+  required: { name: 'required'; validate: (value) => unknown; message: 'The :field field is required.' };
+  string: {
+  name: 'string';
+  validate: unknown;
+  message: 'The :field field must be a string.'
+};
+  number: {
+  name: 'number';
+  validate: unknown
+};
+  integer: {
+  name: 'integer';
+  validate: unknown
+};
+  boolean: {
+  name: 'boolean';
+  validate: unknown;
+  message: 'The :field field must be true or false.'
+};
+  email: { name: 'email'; validate: (value) => unknown };
+  url: { name: 'url'; validate: (value) => unknown };
+  min: { name: 'min'; validate: (value, parameters) => unknown };
+  max: { name: 'max'; validate: (value, parameters) => unknown };
+  between: { name: 'between'; validate: (value, parameters) => unknown };
+  in: { name: 'in'; validate: (value, parameters) => unknown; message: (field, parameters) => unknown };
+  notIn: { name: 'not_in'; validate: (value, parameters) => unknown; message: (field, parameters) => unknown };
+  regex: { name: 'regex'; validate: (value, parameters) => unknown };
+  alpha: {
+  name: 'alpha';
+  validate: unknown
+};
+  alphaNum: {
+  name: 'alpha_num';
+  validate: unknown
+};
+  alphaDash: {
+  name: 'alpha_dash';
+  validate: unknown
+};
+  date: { name: 'date'; validate: (value) => unknown };
+  dateAfter: { name: 'after'; validate: (value, parameters) => unknown };
+  dateBefore: { name: 'before'; validate: (value, parameters) => unknown };
+  confirmed: { name: 'confirmed'; validate: (value, parameters, field, data) => unknown };
+  same: { name: 'same'; validate: (value, parameters, field, data) => unknown };
+  different: { name: 'different'; validate: (value, parameters, field, data) => unknown; message: (field, parameters) => unknown };
+  json: { name: 'json'; validate: (value) => unknown; message: 'The :field field must be valid JSON.' };
+  uuid: { name: 'uuid'; validate: (value) => unknown };
+  array: {
+  name: 'array';
+  validate: unknown
+};
+  object: {
+  name: 'object';
+  validate: unknown
+}
+};
+/**
+ * Database validation rules (require external implementation)
+ */
+export declare const DatabaseRules: {
+  unique: { name: 'unique'; validate: (_value, _parameters) => unknown; message: 'The :field field must be unique.' };
+  exists: { name: 'exists'; validate: (_value, _parameters) => unknown; message: 'The selected :field is invalid.' }
+};
+/**
+ * Global validator instance
+ */
+export declare const globalValidator: Validator;
+/**
+ * Validation helper functions
+ */
+export declare const ValidationHelpers: {
+  /**
+   * Create validation rules object
+   */
+  rules(rules: Record<string, string | ValidationRuleBuilder>): unknown;
+  /**
+   * Validate single value
+   */
+  async validateValue(value: any, rules: string, field = 'value'): unknown;
+  /**
+   * Check if value passes validation
+   */
+  async passes(value: any, rules: string): unknown;
+  /**
+   * Check if value fails validation
+   */
+  async fails(value: any, rules: string): unknown
+};
+export declare interface ValidationRule {
+  name: string
+  validate: (value: any, parameters: string[], field: string, data: Record<string, any>) => Promise<boolean> | boolean
+  message: string | ((field: string, parameters: string[]) => string)
+}
+export declare interface ValidationRules {
+
+}
+export declare interface ValidationErrors {
+
+}
+export declare interface ValidatorConfig {
+  stopOnFirstFailure?: boolean
+  customMessages?: Record<string, string>
+  customAttributes?: Record<string, string>
+  bail?: boolean
+}
+/**
+ * Main validator class
+ */
+export declare class Validator {
+  private rules: Record<string, ValidationRule>;
+  private config: ValidatorConfig;
+  constructor(config?: ValidatorConfig);
+  registerRule(rule: ValidationRule): void;
+  registerRules(rules: Record<string, ValidationRule>): void;
+  private parseRuleString(ruleString: string): Array<{ name: string, parameters: string[] }>;
+  validate(data: Record<string, any>, rules: ValidationRules): Promise<ValidationErrors>;
+  validateOrFail(data: Record<string, any>, rules: ValidationRules): Promise<void>;
+  private getNestedValue(obj: Record<string, any>, path: string): any;
+  private formatErrorMessage(rule: ValidationRule, field: string, parameters: string[]): string;
+  private replacePlaceholders(message: string, field: string, parameters: string[]): string;
+}
+/**
+ * Validation rule builder for fluent API
+ */
+export declare class ValidationRuleBuilder {
+  private rules: string[];
+  required(): this;
+  string(): this;
+  number(): this;
+  integer(): this;
+  boolean(): this;
+  email(): this;
+  url(): this;
+  min(value: number): this;
+  max(value: number): this;
+  between(min: number, max: number): this;
+  in(values: string[]): this;
+  notIn(values: string[]): this;
+  regex(pattern: string): this;
+  alpha(): this;
+  alphaNum(): this;
+  alphaDash(): this;
+  date(): this;
+  after(date: string): this;
+  before(date: string): this;
+  confirmed(field?: string): this;
+  same(field: string): this;
+  different(field: string): this;
+  json(): this;
+  uuid(): this;
+  array(): this;
+  object(): this;
+  unique(table: string, column?: string): this;
+  exists(table: string, column?: string): this;
+  custom(ruleName: string, parameters: string[]): this;
+  build(): string;
+}

package/dist/websocket/clustering.d.ts

@@ -0,0 +1,114 @@
+import type { ServerWebSocket } from 'bun';
+import type { Buffer } from 'node:buffer';
+/**
+ * WebSocket cluster helpers
+ */
+export declare const WebSocketClusterHelpers: {
+  /**
+   * Create room-based chat system
+   */
+  createChatSystem: (cluster: WebSocketCluster) => any;
+  /**
+   * Create real-time notifications system
+   */
+  createNotificationSystem: (cluster: WebSocketCluster) => any;
+  /**
+   * Create presence system
+   */
+  createPresenceSystem: (cluster: WebSocketCluster) => any
+};
+export declare interface WebSocketClusterConfig {
+  workers?: number
+  maxConnections?: number
+  heartbeatInterval?: number
+  compression?: boolean
+  backpressureLimit?: number
+  closeOnBackpressureLimit?: boolean
+  idleTimeout?: number
+  maxPayloadLength?: number
+}
+export declare interface ClusterMessage {
+  type: 'broadcast' | 'direct' | 'join' | 'leave' | 'heartbeat' | 'stats'
+  workerId?: string
+  targetId?: string
+  roomId?: string
+  data?: any
+  timestamp: number
+}
+export declare interface WebSocketConnection {
+  id: string
+  workerId: string
+  socket: ServerWebSocket<any>
+  rooms: Set<string>
+  metadata: Record<string, any>
+  lastHeartbeat: number
+  connected: boolean
+}
+export declare interface WebSocketRoom {
+  id: string
+  connections: Set<string>
+  metadata: Record<string, any>
+  created: number
+}
+export declare interface ClusterStats {
+  totalConnections: number
+  totalRooms: number
+  workerStats: Record<string, {
+    connections: number
+    rooms: number
+    memoryUsage: number
+    uptime: number
+  }>
+  messagesSent: number
+  messagesReceived: number
+  bytesTransferred: number
+}
+/**
+ * WebSocket cluster manager for distributing connections across workers
+ */
+export declare class WebSocketCluster {
+  private config: Required<WebSocketClusterConfig>;
+  private workers: any;
+  private connections: any;
+  private rooms: any;
+  private messageHandlers: any;
+  private stats: ClusterStats;
+  private heartbeatTimer?: Timer;
+  private isMainWorker: boolean;
+  private workerId: string;
+  constructor(config?: WebSocketClusterConfig);
+  createServer(options?: {
+    port?: number
+    hostname?: string
+    onConnection?: (ws: ServerWebSocket<any>, request: Request) => void
+    onMessage?: (ws: ServerWebSocket<any>, message: string | Buffer) => void
+    onClose?: (ws: ServerWebSocket<any>, code?: number, reason?: string) => void
+    onError?: (ws: ServerWebSocket<any>, error: Error) => void
+  }): any;
+  joinRoom(connectionId: string, roomId: string, metadata?: Record<string, any>): boolean;
+  leaveRoom(connectionId: string, roomId: string): boolean;
+  broadcastToRoom(roomId: string, message: string | Buffer, excludeConnectionId?: string): number;
+  sendToConnection(connectionId: string, message: string | Buffer): boolean;
+  getStats(): ClusterStats;
+  getRoomConnections(roomId: string): string[];
+  getConnectionRooms(connectionId: string): string[];
+  closeConnection(connectionId: string, code?: number, reason?: string): boolean;
+  shutdown(): void;
+  private generateConnectionId(): string;
+  private generateWorkerId(): string;
+  private initializeStats(): ClusterStats;
+  private setupWorkerCommunication(): void;
+  private handleWorkerMessage(message: ClusterMessage): void;
+  private handleClusterMessage(connection: WebSocketConnection, message: ClusterMessage): void;
+  private broadcastToWorkers(message: ClusterMessage): void;
+  private startHeartbeat(): void;
+  private updateWorkerStats(): void;
+}
+/**
+ * WebSocket cluster factory
+ */
+export declare class WebSocketClusterFactory {
+  static create(config?: WebSocketClusterConfig): WebSocketCluster;
+  static createHighPerformance(): WebSocketCluster;
+  static createDevelopment(): WebSocketCluster;
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@stacksjs/bun-router",
+  "type": "module",
+  "version": "0.0.2",
+  "description": "A",
+  "author": "Chris Breuer <chris@stacksjs.org>",
+  "license": "MIT",
+  "homepage": "https://github.com/stacksjs/bun-router#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stacksjs/bun-router.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stacksjs/bun-router/issues"
+  },
+  "keywords": [
+    "router",
+    "route",
+    "server",
+    "laravel",
+    "fast",
+    "bun",
+    "typescript"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "import": "./dist/*"
+    }
+  },
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "bun-router": "./dist/cli.js",
+    "router": "./bin/cli.ts"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun --bun build.ts && bun run compile",
+    "compile": "bun build ./bin/cli.ts --compile --minify --outfile bin/router",
+    "compile:all": "bun run compile:linux-x64 && bun run compile:linux-arm64 && bun run compile:windows-x64 && bun run compile:darwin-x64 && bun run compile:darwin-arm64",
+    "compile:linux-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-linux-x64 --outfile bin/router-linux-x64",
+    "compile:linux-arm64": "bun build ./bin/cli.ts --compile --minify --target=bun-linux-arm64 --outfile bin/router-linux-arm64",
+    "compile:windows-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-windows-x64 --outfile bin/router-windows-x64.exe",
+    "compile:darwin-x64": "bun build ./bin/cli.ts --compile --minify --target=bun-darwin-x64 --outfile bin/router-darwin-x64",
+    "compile:darwin-arm64": "bun build ./bin/cli.ts --compile --minify --target=bun-darwin-arm64 --outfile bin/router-darwin-arm64",
+    "zip": "bun run zip:all",
+    "zip:all": "bun run zip:linux-x64 && bun run zip:linux-arm64 && bun run zip:windows-x64 && bun run zip:darwin-x64 && bun run zip:darwin-arm64",
+    "zip:linux-x64": "zip -j bin/router-linux-x64.zip bin/router-linux-x64",
+    "zip:linux-arm64": "zip -j bin/router-linux-arm64.zip bin/router-linux-arm64",
+    "zip:windows-x64": "zip -j bin/router-windows-x64.zip bin/router-windows-x64.exe",
+    "zip:darwin-x64": "zip -j bin/router-darwin-x64.zip bin/router-darwin-x64",
+    "zip:darwin-arm64": "zip -j bin/router-darwin-arm64.zip bin/router-darwin-arm64",
+    "lint": "bunx --bun eslint .",
+    "lint:fix": "bunx --bun eslint . --fix",
+    "fresh": "bunx rimraf node_modules/ bun.lock && bun i",
+    "changelog": "bunx changelogen --output CHANGELOG.md",
+    "prepublishOnly": "bun --bun run build && bun run compile:all && bun run zip",
+    "release": "bun run changelog && bunx bumpp package.json --all",
+    "test": "bun test",
+    "dev:docs": "bun --bun vitepress dev docs",
+    "build:docs": "bun --bun vitepress build docs",
+    "preview:docs": "bun --bun vitepress preview docs",
+    "typecheck": "bunx --bun tsc --noEmit"
+  },
+  "dependencies": {
+    "@stacksjs/clapp": "^0.2.0",
+    "bun-query-builder": "^0.1.10",
+    "openapi-types": "^12.1.3",
+    "ts-rate-limiter": "^0.4.0"
+  },
+  "lint-staged": {
+    "*.{js,ts}": "bunx --bun eslint . --fix"
+  }
+}