@h3ravel/core 0.1.0

package/src/Application.ts

@@ -0,0 +1,164 @@
+import { Container } from './Container'
+import { PathLoader } from './Utils/PathLoader'
+import { ServiceProvider } from './ServiceProvider'
+import path from 'node:path'
+
+export class Application extends Container {
+    paths = new PathLoader()
+    private booted = false
+    private versions = { app: '0', ts: '0' }
+    private basePath: string
+
+    private providers: ServiceProvider[] = []
+    protected externalProviders: Array<new (_app: Application) => ServiceProvider> = []
+
+    constructor(basePath: string) {
+        super()
+        this.basePath = basePath
+        this.setPath('base', basePath)
+        this.loadOptions()
+        this.registerBaseBindings()
+    }
+
+    /**
+     * Register core bindings into the container
+     */
+    protected registerBaseBindings () {
+        this.bind(Application, () => this)
+        this.bind('path.base', () => this.basePath)
+        this.bind('app.paths', () => this.paths)
+    }
+
+    /**
+     * Dynamically register all configured providers
+     */
+    public async registerConfiguredProviders () {
+        const providers = await this.getAllProviders()
+
+        for (const ProviderClass of providers) {
+            if (!ProviderClass) continue
+            const provider = new ProviderClass(this)
+            await this.register(provider)
+        }
+    }
+
+    protected async loadOptions () {
+        const app = await this.safeImport(this.getPath('base', 'package.json'))
+        const core = await this.safeImport('../package.json')
+
+        if (app && app.dependencies) {
+            this.versions.app = app.dependencies['@h3ravel/core']
+        }
+        if (core && core.devDependencies) {
+            this.versions.ts = app.devDependencies.typescript
+        }
+    }
+
+    /**
+     * Load default and optional providers dynamically
+     * 
+     * Auto-Registration Behavior
+     * 
+     * Minimal App: Loads only core, config, http, router by default.
+     * Full-Stack App: Installs database, mail, queue, cache → they self-register via their providers.
+     */
+    protected async getConfiguredProviders (): Promise<Array<new (_app: Application) => ServiceProvider>> {
+        return [
+            (await import('@h3ravel/core')).AppServiceProvider,
+            (await import('@h3ravel/http')).HttpServiceProvider,
+            (await import('@h3ravel/config')).ConfigServiceProvider,
+            (await import('@h3ravel/router')).RouteServiceProvider,
+            (await import('@h3ravel/router')).AssetsServiceProvider,
+            (await import('@h3ravel/core')).ViewServiceProvider,
+            (await this.safeImport('@h3ravel/database'))?.DatabaseServiceProvider,
+            (await this.safeImport('@h3ravel/cache'))?.CacheServiceProvider,
+            (await this.safeImport('@h3ravel/console'))?.ConsoleServiceProvider,
+            (await this.safeImport('@h3ravel/queue'))?.QueueServiceProvider,
+            (await this.safeImport('@h3ravel/mail'))?.MailServiceProvider,
+        ]
+    }
+
+    protected async getAllProviders (): Promise<Array<new (_app: Application) => ServiceProvider>> {
+        const coreProviders = await this.getConfiguredProviders()
+        return [...coreProviders, ...this.externalProviders]
+    }
+
+    registerProviders (providers: Array<new (_app: Application) => ServiceProvider>): void {
+        this.externalProviders.push(...providers)
+    }
+
+    /**
+     * Register a provider
+     */
+    public async register (provider: ServiceProvider) {
+        await provider.register()
+        this.providers.push(provider)
+    }
+
+    /**
+     * Boot all providers after registration
+     */
+    public async boot () {
+        if (this.booted) return
+
+        for (const provider of this.providers) {
+            if (provider.boot) {
+                await provider.boot()
+            }
+        }
+
+        this.booted = true
+    }
+
+    /**
+     * Attempt to dynamically import an optional module
+     */
+    private async safeImport (moduleName: string) {
+        try {
+            const mod = await import(moduleName)
+            return mod.default ?? mod
+        } catch {
+            return null
+        }
+    }
+
+    /**
+     * Get the base path of the app
+     * 
+     * @returns 
+     */
+    getBasePath (): string {
+        return this.basePath
+    }
+
+    /**
+     * Dynamically retrieves a path property from the class.
+     * Any property ending with "Path" is accessible automatically.
+     *
+     * @param name - The base name of the path property
+     * @returns 
+     */
+    getPath (name: Parameters<PathLoader['setPath']>[0], pth?: string) {
+        return path.join(this.paths.getPath(name, this.basePath), pth ?? '')
+    }
+
+    /**
+     * Programatically set the paths.
+     *
+     * @param name - The base name of the path property
+     * @param path - The new path
+     * @returns 
+     */
+    setPath (name: Parameters<PathLoader['setPath']>[0], path: string) {
+        return this.paths.setPath(name, path, this.basePath)
+    }
+
+    /**
+     * Returns the installed version of the system core and typescript.
+     *
+     * @returns 
+     */
+    getVersion (key: 'app' | 'ts') {
+        return this.versions[key]?.replaceAll(/\^|\~/g, '')
+    }
+}

package/src/Container.ts

@@ -0,0 +1,71 @@
+import type { Bindings, UseKey } from "./Contracts/BindingsContract"
+
+type IBinding = UseKey | (new (..._args: any[]) => unknown)
+
+export class Container {
+    private bindings = new Map<IBinding, () => unknown>()
+    private singletons = new Map<IBinding, unknown>()
+
+    /**
+     * Bind a transient service to the container
+     */
+    bind<T> (key: new (...args: any[]) => T, factory: () => T): void
+    bind<T extends UseKey> (key: T, factory: () => Bindings[T]): void
+    bind<T extends UseKey> (
+        key: T,
+        factory: () => Bindings[T] | T
+    ) {
+        this.bindings.set(key, factory)
+    }
+
+    /**
+     * Bind a singleton service to the container
+     */
+    singleton<T extends UseKey> (
+        key: T | (new (..._args: any[]) => Bindings[T]),
+        factory: () => Bindings[T]
+    ) {
+        this.bindings.set(key, () => {
+            if (!this.singletons.has(key)) {
+                this.singletons.set(key, factory())
+            }
+            return this.singletons.get(key)!
+        })
+    }
+
+    /**
+     * Resolve a service from the container
+     */
+    make<T extends UseKey> (key: T | (new (..._args: any[]) => Bindings[T])): Bindings[T] {
+        // 1️⃣ Direct factory binding
+        if (this.bindings.has(key)) {
+            return this.bindings.get(key)!() as Bindings[T]
+        }
+
+        // 2️⃣ If class constructor → auto-resolve via reflection
+        if (typeof key === 'function') {
+            return this.build(key)
+        }
+
+        throw new Error(
+            `No binding found for key: ${typeof key === 'string' ? key : (key as any)?.name}`
+        )
+    }
+
+    /**
+     * Automatically build a class with constructor dependency injection
+     */
+    private build<T extends UseKey> (ClassType: new (..._args: any[]) => Bindings[T]): Bindings[T] {
+        const paramTypes: any[] = Reflect.getMetadata('design:paramtypes', ClassType) || []
+        const dependencies = paramTypes.map((dep) => this.make(dep))
+        return new ClassType(...dependencies)
+    }
+
+
+    /**
+     * Check if a service is registered
+     */
+    has (key: UseKey): boolean {
+        return this.bindings.has(key)
+    }
+}

package/src/Contracts/BindingsContract.ts

@@ -0,0 +1,37 @@
+import { DotNestedKeys, DotNestedValue } from "@h3ravel/support";
+import type { H3, serve } from "h3";
+
+import type { Edge } from "edge.js";
+import { PathLoader } from "../Utils/PathLoader";
+import type { Router } from "@h3ravel/router";
+
+type RemoveIndexSignature<T> = {
+    [K in keyof T as string extends K
+    ? never
+    : number extends K
+    ? never
+    : K]: T[K]
+}
+
+export type Bindings = {
+    [key: string]: any;
+    env<T extends string> (): NodeJS.ProcessEnv
+    env<T extends string> (key: T, def?: any): any
+    view: Edge,
+    asset (key: string, def?: string): string,
+    router: Router
+    config: {
+        // get<X extends Record<string, any>> (): X
+        // get<X extends Record<string, any>, K extends DotNestedKeys<X>> (key: K, def?: any): DotNestedValue<X, K>
+        get<X extends Record<string, any>> (): X
+        get<X extends Record<string, any>, T extends Extract<keyof X, string>> (key: T, def?: any): X[T]
+        set<T extends string> (key: T, value: any): void
+        load?(): any
+    }
+    'http.app': H3
+    'path.base': string
+    'app.paths': PathLoader
+    'http.serve': typeof serve
+}
+
+export type UseKey = keyof RemoveIndexSignature<Bindings>

package/src/Controller.ts

@@ -0,0 +1,20 @@
+import { HttpContext, IController } from '@h3ravel/http'
+
+import { Application } from '.'
+
+/**
+ * Base controller class
+ */
+export abstract class Controller implements IController {
+    protected app: Application
+
+    constructor(app: Application) {
+        this.app = app
+    }
+
+    public show (_ctx: HttpContext): any { return }
+    public index (_ctx: HttpContext): any { return }
+    public store (_ctx: HttpContext): any { return }
+    public update (_ctx: HttpContext): any { return }
+    public destroy (_ctx: HttpContext): any { return }
+}

package/src/Exceptions/Handler.ts

@@ -0,0 +1 @@
+export default class { }

package/src/Http/Kernel.ts

@@ -0,0 +1,47 @@
+import { HttpContext, Middleware, Request, Response } from '@h3ravel/http'
+
+import type { H3Event } from 'h3'
+
+export class Kernel {
+    constructor(private middleware: Middleware[] = []) { }
+
+    async handle (event: H3Event, next: (ctx: HttpContext) => Promise<unknown>): Promise<unknown> {
+        const context: HttpContext = {
+            request: new Request(event),
+            response: new Response(event)
+        }
+
+        const result = await this.runMiddleware(context, () => next(context))
+
+        // Auto-set JSON header if plain object returned
+        if (result !== undefined && this.isPlainObject(result)) {
+            event.res.headers.set('Content-Type', 'application/json; charset=UTF-8')
+        }
+
+        return result
+    }
+
+    private async runMiddleware (context: HttpContext, next: (ctx: HttpContext) => Promise<unknown>) {
+        let index = -1
+
+        const runner = async (i: number): Promise<unknown> => {
+            if (i <= index) throw new Error('next() called multiple times')
+            index = i
+            const middleware = this.middleware[i]
+
+            if (middleware) {
+                return middleware.handle(context, () => runner(i + 1))
+            } else {
+                return next(context)
+            }
+        }
+
+        return runner(0)
+    }
+
+    private isPlainObject (value: unknown): value is Record<string, unknown> {
+        return typeof value === 'object' &&
+            value !== null &&
+            (value.constructor === Object || value.constructor === Array)
+    }
+}

package/src/Providers/AppServiceProvider.ts

@@ -0,0 +1,18 @@
+import 'reflect-metadata'
+
+import { ServiceProvider } from '../ServiceProvider'
+
+/**
+ * Bootstraps core services and bindings.
+ * 
+ * Bind essential services to the container (logger, config repository).
+ * Register app-level singletons.
+ * Set up exception handling.
+ * 
+ * Auto-Registered
+ */
+export class AppServiceProvider extends ServiceProvider {
+    register () {
+        // Core bindings
+    }
+}

package/src/Providers/ViewServiceProvider.ts

@@ -0,0 +1,19 @@
+import { Edge } from 'edge.js'
+import { ServiceProvider } from '@h3ravel/core'
+
+export class ViewServiceProvider extends ServiceProvider {
+    register (): void {
+        const config = this.app.make('config')
+        const edge = Edge.create({
+            cache: process.env.NODE_ENV === 'production'
+        })
+
+        edge.mount(this.app.getPath('views'))
+
+        edge.global('asset', this.app.make('asset'))
+        edge.global('config', config.get)
+        edge.global('app', this.app)
+
+        this.app.bind('view', () => edge)
+    }
+}

package/src/ServiceProvider.ts

@@ -0,0 +1,21 @@
+import { Application } from './Application'
+
+export abstract class ServiceProvider {
+    protected app: Application
+
+    constructor(app: Application) {
+        this.app = app
+    }
+
+    /**
+     * Register bindings to the container.
+     * Runs before boot().
+     */
+    abstract register (): void | Promise<void>
+
+    /**
+     * Perform post-registration booting of services.
+     * Runs after all providers have been registered.
+     */
+    boot?(): void | Promise<void>
+}

package/src/Utils/PathLoader.ts

@@ -0,0 +1,46 @@
+import nodepath from "path"
+
+type PathName = 'views' | 'routes' | 'assets' | 'base' | 'public' | 'storage' | 'config'
+
+export class PathLoader {
+    private paths = {
+        base: '',
+        views: '/src/resources/views',
+        assets: '/public/assets',
+        routes: '/src/routes',
+        config: '/src/config',
+        public: '/public',
+        storage: '/src/storage',
+    }
+
+    /**
+     * Dynamically retrieves a path property from the class.
+     * Any property ending with "Path" is accessible automatically.
+     *
+     * @param name - The base name of the path property
+     * @param base - The base path to include to the path
+     * @returns 
+     */
+    getPath (name: PathName, base?: string): string {
+        if (base && name !== 'base') {
+            return nodepath.join(base, this.paths[name])
+        }
+
+        return this.paths[name]
+    }
+
+    /**
+     * Programatically set the paths.
+     *
+     * @param name - The base name of the path property
+     * @param path - The new path
+     * @param base - The base path to include to the path
+     */
+    setPath (name: PathName, path: string, base?: string) {
+        if (base && name !== 'base') {
+            this.paths[name] = nodepath.join(base, path)
+        }
+
+        this.paths[name] = path
+    }
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+
+export * from './Application';
+export * from './Container';
+export * from './Controller';
+export * from './ServiceProvider';
+export * from './Contracts/BindingsContract';
+export * from './Exceptions/Handler';
+export * from './Http/Kernel';
+export * from './Providers/AppServiceProvider';
+export * from './Providers/ViewServiceProvider';
+export * from './Utils/PathLoader';

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist"
+  },
+  "include": ["src", "../http/src/Middleware", "../http/src/Middleware.ts"],
+  "exclude": ["dist", "node_modules"]
+}

package/vite.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    format: ['esm', 'cjs'],
+    dts: true,
+    sourcemap: true,
+    clean: true
+})