@rudderjs/core 0.0.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Suleiman Shahbari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,245 @@
+# @rudderjs/core
+
+Application bootstrap, service provider lifecycle, and framework-level runtime orchestration.
+
+## Installation
+
+```bash
+pnpm add @rudderjs/core
+```
+
+## Usage
+
+```ts
+import { Application } from '@rudderjs/core'
+import { hono } from '@rudderjs/server-hono'
+import { RateLimit } from '@rudderjs/middleware'
+
+export default Application.configure({
+  server:    hono(configs.server),
+  config:    configs,
+  providers,
+})
+  .withRouting({
+    web:      () => import('../routes/web.js'),
+    api:      () => import('../routes/api.js'),
+    commands: () => import('../routes/console.js'),
+  })
+  .withMiddleware((m) => {
+    m.use(RateLimit.perMinute(60))
+  })
+  .withExceptions((e) => {
+    // Custom error type → custom response
+    e.render(PaymentError, (err) =>
+      new Response(JSON.stringify({ code: err.code }), {
+        status: 402,
+        headers: { 'Content-Type': 'application/json' },
+      })
+    )
+    // Override the reporter (default: @rudderjs/log when installed, otherwise console.error)
+    e.reportUsing((err) => Sentry.captureException(err))
+    // Re-throw to the server's native fallback
+    e.ignore(DebugOnlyError)
+  })
+  .create()
+```
+
+## API Reference
+
+- `ServiceProvider` — `register()`, `boot()`, `publishes()`
+- `PublishGroup` — `{ from, to, tag? }`
+- `getPublishGroups()` — returns the global publish registry (used by `vendor:publish`)
+- `Listener`, `EventDispatcher`, `dispatcher`, `dispatch()`, `events()`
+- `Application`, `AppConfig`
+- `ConfigureOptions`, `RoutingOptions`
+- `MiddlewareConfigurator`, `ExceptionConfigurator`
+- `AppBuilder`, `RudderJS`
+- `app()`, `resolve()`
+- `defineConfig()`
+- `HttpException` — HTTP error with `statusCode`, `message`, `headers`
+- `abort(status, message?, headers?)` — throws `HttpException`
+- `abort_if(condition, status, message?)` — conditional abort
+- `abort_unless(condition, status, message?)` — inverse conditional abort
+- `report(err)` — report an error to the configured reporter
+- `report_if(condition, err)` — conditional report
+- `setExceptionReporter(fn)` — override the global reporter (wired automatically by `@rudderjs/log`)
+- Re-exports from `@rudderjs/rudder`, `@rudderjs/support`, and `@rudderjs/contracts` types plus built-in DI and Events primitives
+
+## Configuration
+
+- `AppConfig`
+  - `name?`, `env?`, `debug?`
+  - `providers?`
+  - `config?` (config object bound into the container)
+- `ConfigureOptions`
+  - `server`, `config?`, `providers?`
+
+## Dynamic Provider Registration
+
+Providers can register other providers at runtime — useful for modules, conditional features, and package composition:
+
+```ts
+import { ServiceProvider } from '@rudderjs/core'
+import { cache } from '@rudderjs/cache'
+import { panels } from '@rudderjs/panels'
+import { adminPanel } from '../Panels/Admin/AdminPanel.js'
+
+export class AppServiceProvider extends ServiceProvider {
+  register() {
+    // Static sub-provider
+  }
+
+  async boot() {
+    // Register panels from your own provider
+    await this.app.register(panels([adminPanel]))
+
+    // Conditional features
+    const config = this.app.make<{ get(k: string): unknown }>('config')
+    if (config.get('cache.enabled')) {
+      await this.app.register(cache(cacheConfig))
+    }
+  }
+}
+```
+
+`register()` calls the provider's `register()` immediately so bindings are available. If the app is already booted, `boot()` runs too. Duplicate providers (by class reference or class name) are silently skipped.
+
+## Publishing Assets
+
+Service providers can declare publishable assets (pages, config files, migrations) that users copy into their app with `pnpm rudder vendor:publish`.
+
+```ts
+import { ServiceProvider } from '@rudderjs/core'
+
+export class MyPackageServiceProvider extends ServiceProvider {
+  register(): void {}
+
+  async boot(): Promise<void> {
+    this.publishes({
+      from: new URL('../pages', import.meta.url).pathname,
+      to:   'pages/(panels)',
+      tag:  'my-package-pages',
+    })
+  }
+}
+```
+
+Multiple groups with different tags:
+
+```ts
+this.publishes([
+  { from: new URL('../pages', import.meta.url).pathname, to: 'pages/(panels)', tag: 'my-pages' },
+  { from: new URL('../config', import.meta.url).pathname, to: 'config',        tag: 'my-config' },
+])
+```
+
+Users publish with:
+
+```bash
+pnpm rudder vendor:publish --tag=my-package-pages
+pnpm rudder vendor:publish --provider=MyPackageServiceProvider
+pnpm rudder vendor:publish --list   # see all available assets
+```
+
+## Events
+
+```ts
+import { dispatch, dispatcher, events } from '@rudderjs/core'
+
+// Define an event
+class UserCreated {
+  constructor(public readonly id: number) {}
+}
+
+// Define a listener
+class SendWelcomeEmail {
+  async handle(event: UserCreated) {
+    await mailer.send(event.id)
+  }
+}
+
+// Register via provider in bootstrap/providers.ts
+import { events } from '@rudderjs/core'
+export default [
+  events({ UserCreated: [SendWelcomeEmail] }),
+]
+
+// Dispatch anywhere
+await dispatch(new UserCreated(42))
+```
+
+### `EventDispatcher` API
+
+| Method | Description |
+|--------|-------------|
+| `register(name, ...listeners)` | Register listeners for an event name. Use `'*'` for wildcard (all events). |
+| `dispatch(event)` | Dispatch to matching listeners, then wildcard listeners. Awaited in order. |
+| `count(name)` | Number of listeners for an event name. |
+| `hasListeners(name)` | `true` if at least one listener is registered. |
+| `list()` | `Record<string, number>` snapshot of all registered events and counts. |
+| `reset()` | Clear all listeners (testing / hot-reload). |
+
+## Exception Handling
+
+### `abort()` helpers
+
+Throw an `HttpException` from anywhere — routes, services, middleware:
+
+```ts
+import { abort, abort_if, abort_unless } from '@rudderjs/core'
+
+abort(404)                            // throws HttpException(404, 'Not Found')
+abort(403, 'Insufficient permissions')
+abort(402, 'Payment required', { 'X-Upgrade-URL': '/billing' })
+
+abort_if(!user, 401)                  // abort if condition is true
+abort_unless(user.isAdmin, 403)       // abort if condition is false
+```
+
+`HttpException` is caught automatically and rendered as JSON or HTML based on the request's `Accept` header — no `try/catch` needed.
+
+### `report()` helpers
+
+Manually report an error without aborting the request:
+
+```ts
+import { report, report_if } from '@rudderjs/core'
+
+report(new Error('Stripe webhook failed'))
+report_if(payment.failed, payment.error)
+```
+
+When `@rudderjs/log` is installed, `report()` routes through the log channel automatically. Otherwise it falls back to `console.error`.
+
+### `withExceptions` configurator
+
+```ts
+.withExceptions((e) => {
+  // Custom error type → custom Response
+  e.render(PaymentError, (err, req) =>
+    Response.json({ code: err.code }, { status: 402 })
+  )
+
+  // Override the reporter (default: @rudderjs/log or console.error)
+  e.reportUsing((err) => Sentry.captureException(err))
+
+  // Re-throw to the server's native fallback handler
+  e.ignore(DebugOnlyError)
+})
+```
+
+### Built-in handling (no configuration needed)
+
+| Error type | Response |
+|---|---|
+| `ValidationError` | `422` JSON `{ message, errors }` |
+| `HttpException` | Status from `statusCode`, JSON or HTML based on `Accept` |
+| Unhandled error | Reported via reporter, then `500` (with stack in debug mode) |
+
+## Notes
+
+- `Application.create()` is singleton-based and can recreate in development/local mode when config is passed.
+- `RudderJS.boot()` boots providers; `RudderJS.handleRequest()` lazily creates the HTTP handler.
+- `ValidationError` is always caught and returned as 422 JSON — no try/catch needed in routes.
+- `HttpException` is always caught and rendered with its status code — no try/catch needed in routes.
+- Unhandled errors are auto-reported and render as 500. In `debug` mode the response includes the exception message and stack trace.

package/boost/guidelines.md

@@ -0,0 +1,144 @@
+# @rudderjs/core
+
+## Overview
+
+`@rudderjs/core` is the foundation of a RudderJS application. It provides the Application class, a Laravel-style DI container, service provider lifecycle, event dispatching, form request validation (via Zod), exception handling, and typed configuration. It re-exports essentials from `@rudderjs/support`, `@rudderjs/contracts`, and `@rudderjs/rudder` so most apps only need to import from `@rudderjs/core`.
+
+## Key Patterns
+
+### Application Bootstrap
+
+Every RudderJS app is wired in `bootstrap/app.ts` using the builder pattern:
+
+```ts
+import 'reflect-metadata'
+import 'dotenv/config'
+import { Application } from '@rudderjs/core'
+import { hono } from '@rudderjs/server-hono'
+import configs from '../config/index.ts'
+import providers from './providers.ts'
+
+export default Application.configure({
+  server: hono(configs.server), config: configs, providers,
+})
+  .withRouting({
+    web: () => import('../routes/web.ts'),
+    api: () => import('../routes/api.ts'),
+    commands: () => import('../routes/console.ts'),
+  })
+  .withMiddleware((m) => m.use(RateLimit.perMinute(60).toHandler()))
+  .withExceptions((e) => e.reportUsing((err) => Sentry.captureException(err)))
+  .create()
+```
+
+There is no `rudderjs.config.ts` -- `bootstrap/app.ts` is the framework wiring file.
+
+### Service Providers
+
+Providers follow a two-phase lifecycle: `register()` binds into the container, `boot()` runs after all providers are registered.
+
+```ts
+import { ServiceProvider, app } from '@rudderjs/core'
+
+export class AppServiceProvider extends ServiceProvider {
+  register(): void {
+    this.app.singleton('userService', () => new UserService())
+  }
+
+  async boot(): Promise<void> {
+    // All bindings are available here
+  }
+}
+```
+
+Many packages export a **factory function** that returns a provider class (e.g., `cache(config)`, `queue(config)`). These are used in `bootstrap/providers.ts`:
+
+```ts
+import { cache } from '@rudderjs/cache'
+export default [cache(cacheConfig), AppServiceProvider]
+```
+
+Providers can be registered dynamically at runtime via `app().register(ProviderClass)`. Duplicates are silently skipped (guarded by class reference and class name).
+
+Deferred providers define `provides()` returning token strings -- they are lazily booted on first container resolve of those tokens.
+
+### Dependency Injection
+
+The DI container supports several binding types:
+
+```ts
+// Transient -- new instance each time
+app().bind('mailer', (c) => new Mailer(c.make('config')))
+
+// Singleton -- created once, cached forever
+app().singleton('db', (c) => new Database(c.make('config')))
+
+// Scoped -- one instance per request (requires ScopeMiddleware)
+app().scoped('cart', () => new ShoppingCart())
+
+// Instance -- store an already-created value
+app().instance('config', configRepo)
+```
+
+Resolve with `app().make<T>(token)` or the global `resolve<T>(token)` helper.
+
+Auto-resolution works for classes decorated with `@Injectable()`. Use `@Inject('token')` to override specific constructor parameters:
+
+```ts
+@Injectable()
+class PhotoController {
+  constructor(
+    private storage: StorageService,        // auto-resolved by type
+    @Inject('s3') private backup: Storage,  // resolved by token
+  ) {}
+}
+```
+
+Contextual bindings let you override a dependency for a specific consumer:
+
+```ts
+container.when(PhotoController).needs('storage').give(() => new S3Storage())
+```
+
+### Middleware
+
+Middleware is configured in `bootstrap/app.ts` via `withMiddleware()`. Each handler receives a `MiddlewareHandler` signature from `@rudderjs/contracts`:
+
+```ts
+.withMiddleware((m) => {
+  m.use(RateLimit.perMinute(60).toHandler())
+  m.use(cors({ origins: ['https://example.com'] }))
+})
+```
+
+### Exception Handling
+
+Use `abort(status, message?)`, `abort_if(condition, status)`, and `abort_unless(condition, status)` to throw `HttpException`. Configure custom renderers via `withExceptions()` in `bootstrap/app.ts`. Use `report(err)` to log without throwing.
+
+### Events
+
+Extend `Listener` and call `dispatch(new MyEvent(data))`. Register listeners in a provider's `boot()`.
+
+### Validation
+
+Extend `FormRequest` and define a `rules()` method returning a Zod schema (`z.object({...})`). `z` is re-exported from `@rudderjs/core`.
+
+## Common Pitfalls
+
+- **Missing `reflect-metadata`**: Must be imported at the very top of `bootstrap/app.ts` before any other imports. Install as a `dependency`, not `devDependency`.
+- **Provider boot order matters**: `DatabaseServiceProvider` must come before any provider that uses ORM models. Order your `providers` array accordingly.
+- **Scoped bindings outside request scope**: Calling `app().make('scopedToken')` outside of `container.runScoped()` throws. Ensure `ScopeMiddleware` is registered or wrap the call manually.
+- **Dynamic provider duplicates**: `app().register()` is safe to call multiple times with the same class -- duplicates are skipped. But factory functions create anonymous classes, so use consistent references.
+- **Circular dependency with `@rudderjs/router`**: Core loads router at runtime via dynamic `import()`. Never add `@rudderjs/core` to router's `dependencies` -- use `peerDependencies` only.
+
+## Key Imports
+
+```ts
+import { Application, app, resolve, ServiceProvider, Injectable, Inject } from '@rudderjs/core'
+import { FormRequest, ValidationError, z } from '@rudderjs/core'
+import { Listener, dispatch, events } from '@rudderjs/core'
+import { HttpException, abort, abort_if, report } from '@rudderjs/core'
+import { Collection, Env, env, config, sleep } from '@rudderjs/core'
+import { rudder, Command } from '@rudderjs/core'
+import type { AppRequest, AppResponse, MiddlewareHandler } from '@rudderjs/core'
+```

package/dist/application.d.ts

@@ -0,0 +1,147 @@
+import { Container, ContextualBindingBuilder } from './di.js';
+import { ServiceProvider } from './service-provider.js';
+import type { ServerAdapterProvider, MiddlewareHandler, AppRequest } from '@rudderjs/contracts';
+export interface BootConfig {
+    name?: string;
+    env?: string;
+    debug?: boolean;
+    providers?: (new (app: Application) => ServiceProvider)[];
+    /** Config values loaded from config/ files — bound to the container as 'config' */
+    config?: Record<string, unknown>;
+}
+export type ProviderClass = new (app: Application) => ServiceProvider;
+export declare class Application {
+    private static instance;
+    readonly container: Container;
+    private providers;
+    private booted;
+    private _booting;
+    private _bootedProviders;
+    /** Tracks registered provider classes to prevent duplicates. */
+    private _registeredClasses;
+    /** Tracks registered provider names to prevent duplicates from factory functions. */
+    private _registeredNames;
+    /** Deferred providers — token → ProviderClass (lazily booted on first resolve). */
+    private _deferredProviders;
+    readonly name: string;
+    readonly env: string;
+    readonly debug: boolean;
+    private constructor();
+    /** Track a provider class for duplicate detection. */
+    private _trackProvider;
+    /** Check whether a provider class (or its name) has already been registered. */
+    private _isDuplicate;
+    static create(config?: BootConfig): Application;
+    static getInstance(): Application;
+    bind(token: Parameters<Container['bind']>[0], factory: Parameters<Container['bind']>[1]): this;
+    singleton(token: Parameters<Container['singleton']>[0], factory: Parameters<Container['singleton']>[1]): this;
+    instance<T>(token: Parameters<Container['instance']>[0], value: T): this;
+    make<T>(token: Parameters<Container['make']>[0]): T;
+    scoped(token: Parameters<Container['scoped']>[0], factory: Parameters<Container['scoped']>[1]): this;
+    runScoped<T>(fn: () => T): T;
+    when(concrete: Parameters<Container['when']>[0]): ContextualBindingBuilder;
+    /**
+     * Dynamically register a service provider at runtime.
+     *
+     * - Calls `register()` immediately so bindings are available.
+     * - If the application is already booted, calls `boot()` too.
+     * - Duplicate providers (by class reference or class name) are silently skipped.
+     *
+     * Works with both provider classes and factory return values:
+     * ```ts
+     * await this.app.register(MyServiceProvider)
+     * await this.app.register(cache(cacheConfig))
+     * ```
+     */
+    register(Provider: ProviderClass | ProviderClass[]): Promise<this>;
+    private _registerAll;
+    private _bootAll;
+    bootstrap(): Promise<this>;
+    isBooted(): boolean;
+    isProduction(): boolean;
+    isDevelopment(): boolean;
+    static configure(options: ConfigureOptions): AppBuilder;
+    /** @internal — testing only */
+    static resetForTesting(): void;
+}
+export interface ConfigureOptions {
+    server: ServerAdapterProvider;
+    config?: Record<string, unknown>;
+    providers?: (new (app: Application) => ServiceProvider)[];
+}
+export interface RoutingOptions {
+    web?: () => Promise<unknown>;
+    api?: () => Promise<unknown>;
+    commands?: () => Promise<unknown>;
+    channels?: () => Promise<unknown>;
+}
+export declare class MiddlewareConfigurator {
+    private _handlers;
+    use(handler: MiddlewareHandler): this;
+    getHandlers(): MiddlewareHandler[];
+}
+export type ErrorRenderer = (err: unknown, req: AppRequest) => Response | Promise<Response>;
+export declare class ExceptionConfigurator {
+    private _renders;
+    private _ignored;
+    /**
+     * Register a custom renderer for a specific error type.
+     *
+     * @example
+     * e.render(PaymentError, (err, req) =>
+     *   new Response(JSON.stringify({ code: err.code }), { status: 402, headers: { 'Content-Type': 'application/json' } })
+     * )
+     */
+    render<T extends Error>(type: new (...args: any[]) => T, fn: (err: T, req: AppRequest) => Response | Promise<Response>): this;
+    /**
+     * Ignore an error type — re-throws it so the server's native handler sees it.
+     */
+    ignore(type: new (...args: any[]) => unknown): this;
+    /**
+     * Override the global exception reporter for unhandled errors.
+     * By default, `@rudderjs/log` wires this automatically when installed.
+     *
+     * @example
+     * e.reportUsing((err) => Sentry.captureException(err))
+     */
+    reportUsing(fn: (err: unknown) => void): this;
+    /** @internal — called by RudderJS to produce the combined error handler */
+    buildHandler(): ErrorRenderer;
+}
+export declare class AppBuilder {
+    private readonly _options;
+    private _loaders;
+    private _mwFn?;
+    private _excFn?;
+    constructor(_options: ConfigureOptions);
+    withRouting(routes: RoutingOptions): this;
+    withMiddleware(fn: (m: MiddlewareConfigurator) => void): this;
+    withExceptions(fn: (e: ExceptionConfigurator) => void): this;
+    create(): RudderJS;
+}
+export declare class RudderJS {
+    private readonly _app;
+    private readonly _server;
+    private readonly _loaders;
+    private readonly _mwFn?;
+    private readonly _excFn?;
+    /** Phase 1: providers only — safe to await in CLI (no Vike virtual imports) */
+    private _providerBoot;
+    /** Phase 2: provider boot + HTTP handler — created lazily on first handleRequest call */
+    private _boot;
+    private _handler;
+    constructor(_app: Application, _server: ServerAdapterProvider, _loaders: Array<() => Promise<unknown>>, _mwFn?: ((m: MiddlewareConfigurator) => void) | undefined, _excFn?: ((e: ExceptionConfigurator) => void) | undefined);
+    private _suppressVikeNoise;
+    /** Phase 1 — boot providers + routes. Safe in CLI (no Vike virtual URLs). */
+    private _bootstrapProviders;
+    /** Phase 2 — create the HTTP fetch handler. Requires Vite context (virtual: URLs). */
+    private _createHandler;
+    /** Boot providers without starting an HTTP server — used by the CLI */
+    boot(): Promise<void>;
+    handleRequest(request: Request, env?: unknown, ctx?: unknown): Promise<Response>;
+    readonly fetch: (request: Request, env?: unknown, ctx?: unknown) => Promise<Response>;
+}
+export declare const app: () => Application;
+export declare const resolve: <T>(token: Parameters<Container["make"]>[0]) => T;
+export declare function defineConfig<T>(config: T): T;
+//# sourceMappingURL=application.d.ts.map

package/dist/application.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application.d.ts","sourceRoot":"","sources":["../src/application.ts"],"names":[],"mappings":"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"}