@h3ravel/core 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { H3Event, H3, Middleware as Middleware$1, MiddlewareOptions, serve } from 'h3';
+import { IPathName, IRouter, IApplication, IServiceProvider, IController, HttpContext, IMiddleware } from '@h3ravel/shared';
+import { H3, serve, H3Event } from 'h3';
 import { Edge } from 'edge.js';
 
-type PathName = 'views' | 'routes' | 'assets' | 'base' | 'public' | 'storage' | 'config';
 declare class PathLoader {
     private paths;
     /**
@@ -12,7 +12,7 @@ declare class PathLoader {
      * @param base - The base path to include to the path
      * @returns
      */
-    getPath(name: PathName, base?: string): string;
+    getPath(name: IPathName, base?: string): string;
     /**
      * Programatically set the paths.
      *
@@ -20,161 +20,7 @@ declare class PathLoader {
      * @param path - The new path
      * @param base - The base path to include to the path
      */
-    setPath(name: PathName, path: string, base?: string): void;
-}
-
-/**
- * Builds "nested.key" paths for autocompletion
- */
-type DotNestedKeys<T> = {
-    [K in keyof T & string]: T[K] extends object ? `${K}` | `${K}.${DotNestedKeys<T[K]>}` : `${K}`;
-}[keyof T & string];
-/**
- * Retrieves type at a given dot-path
- */
-type DotNestedValue<T, Path extends string> = Path extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? DotNestedValue<T[Key], Rest> : never : Path extends keyof T ? T[Path] : never;
-
-declare class Request {
-    private readonly event;
-    constructor(event: H3Event);
-    /**
-     * Get all input data (query + body).
-     */
-    all<T = Record<string, unknown>>(): Promise<T>;
-    /**
-     * Get a single input field from query or body.
-     */
-    input<T = unknown>(key: string, defaultValue?: T): Promise<T>;
-    /**
-     * Get route parameters.
-     */
-    params<T = Record<string, string>>(): T;
-    /**
-     * Get query parameters.
-     */
-    query<T = Record<string, string>>(): T;
-    /**
-     * Get the base event
-     */
-    getEvent(): H3Event;
-    getEvent<K extends DotNestedKeys<H3Event>>(key: K): DotNestedValue<H3Event, K>;
-}
-
-declare class Response {
-    private readonly event;
-    private statusCode;
-    private headers;
-    constructor(event: H3Event);
-    /**
-     * Set HTTP status code.
-     */
-    setStatusCode(code: number): this;
-    /**
-     * Set a header.
-     */
-    setHeader(name: string, value: string): this;
-    html(content: string): string;
-    /**
-     * Send a JSON response.
-     */
-    json<T = unknown>(data: T): T;
-    /**
-     * Send plain text.
-     */
-    text(data: string): string;
-    /**
-     * Redirect to another URL.
-     */
-    redirect(url: string, status?: number): string;
-    /**
-     * Apply headers before sending response.
-     */
-    private applyHeaders;
-    /**
-     * Get the base event
-     */
-    getEvent(): H3Event;
-    getEvent<K extends DotNestedKeys<H3Event>>(key: K): DotNestedValue<H3Event, K>;
-}
-
-interface HttpContext {
-    request: Request;
-    response: Response;
-}
-
-declare abstract class Middleware {
-    abstract handle(context: HttpContext, next: () => Promise<unknown>): Promise<unknown>;
-}
-
-/**
- * Defines the contract for all controllers.
- * Any controller implementing this must define these methods.
- */
-interface IController {
-    show(ctx: HttpContext): any;
-    index(ctx: HttpContext): any;
-    store(ctx: HttpContext): any;
-    update(ctx: HttpContext): any;
-    destroy(ctx: HttpContext): any;
-}
-
-type EventHandler = (ctx: HttpContext) => unknown;
-declare class Router {
-    private h3App;
-    private app;
-    private routes;
-    private groupPrefix;
-    private groupMiddleware;
-    constructor(h3App: H3, app: Application);
-    /**
-     * Route Resolver
-     *
-     * @param handler
-     * @param middleware
-     * @returns
-     */
-    private resolveHandler;
-    /**
-     * Add a route to the stack
-     *
-     * @param method
-     * @param path
-     * @param handler
-     * @param name
-     * @param middleware
-     */
-    private addRoute;
-    private resolveControllerOrHandler;
-    get(path: string, handler: EventHandler | (new (...args: any[]) => Controller), methodName?: string, name?: string, middleware?: Middleware[]): void;
-    post(path: string, handler: EventHandler | (new (...args: any[]) => Controller), methodName?: string, name?: string, middleware?: Middleware[]): void;
-    put(path: string, handler: EventHandler | (new (...args: any[]) => Controller), methodName?: string, name?: string, middleware?: Middleware[]): void;
-    delete(path: string, handler: EventHandler | (new (...args: any[]) => Controller), methodName?: string, name?: string, middleware?: Middleware[]): void;
-    /**
-     * API Resource support
-     *
-     * @param path
-     * @param controller
-     */
-    apiResource(path: string, Controller: new (app: Application) => Controller, middleware?: Middleware[]): void;
-    /**
-     * Named route URL generator
-     *
-     * @param name
-     * @param params
-     * @returns
-     */
-    route(name: string, params?: Record<string, string>): string | undefined;
-    /**
-     * Grouping
-     *
-     * @param options
-     * @param callback
-     */
-    group(options: {
-        prefix?: string;
-        middleware?: EventHandler[];
-    }, callback: () => void): void;
-    middleware(path: string, handler: Middleware$1, opts?: MiddlewareOptions): void;
+    setPath(name: IPathName, path: string, base?: string): void;
 }
 
 type RemoveIndexSignature<T> = {
@@ -186,7 +32,7 @@ type Bindings = {
     env<T extends string>(key: T, def?: any): any;
     view: Edge;
     asset(key: string, def?: string): string;
-    router: Router;
+    router: IRouter;
     config: {
         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];
@@ -226,28 +72,13 @@ declare class Container {
     has(key: UseKey): boolean;
 }
 
-declare abstract class ServiceProvider {
-    protected app: Application;
-    constructor(app: Application);
-    /**
-     * 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>;
-}
-
-declare class Application extends Container {
+declare class Application extends Container implements IApplication {
     paths: PathLoader;
     private booted;
     private versions;
     private basePath;
     private providers;
-    protected externalProviders: Array<new (_app: Application) => ServiceProvider>;
+    protected externalProviders: Array<new (_app: IApplication) => IServiceProvider>;
     constructor(basePath: string);
     /**
      * Register core bindings into the container
@@ -266,13 +97,13 @@ declare class Application extends Container {
      * 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 getConfiguredProviders(): Promise<Array<new (_app: Application) => ServiceProvider>>;
-    protected getAllProviders(): Promise<Array<new (_app: Application) => ServiceProvider>>;
-    registerProviders(providers: Array<new (_app: Application) => ServiceProvider>): void;
+    protected getConfiguredProviders(): Promise<Array<new (_app: IApplication) => IServiceProvider>>;
+    protected getAllProviders(): Promise<Array<new (_app: IApplication) => IServiceProvider>>;
+    registerProviders(providers: Array<new (_app: IApplication) => IServiceProvider>): void;
     /**
      * Register a provider
      */
-    register(provider: ServiceProvider): Promise<void>;
+    register(provider: IServiceProvider): Promise<void>;
     /**
      * Boot all providers after registration
      */
@@ -294,7 +125,7 @@ declare class Application extends Container {
      * @param name - The base name of the path property
      * @returns
      */
-    getPath(name: Parameters<PathLoader['setPath']>[0], pth?: string): string;
+    getPath(name: IPathName, pth?: string): string;
     /**
      * Programatically set the paths.
      *
@@ -302,7 +133,7 @@ declare class Application extends Container {
      * @param path - The new path
      * @returns
      */
-    setPath(name: Parameters<PathLoader['setPath']>[0], path: string): void;
+    setPath(name: IPathName, path: string): void;
     /**
      * Returns the installed version of the system core and typescript.
      *
@@ -315,7 +146,7 @@ declare class Application extends Container {
  * Base controller class
  */
 declare abstract class Controller implements IController {
-    protected app: Application;
+    protected app: IApplication;
     constructor(app: Application);
     show(_ctx: HttpContext): any;
     index(_ctx: HttpContext): any;
@@ -324,9 +155,25 @@ declare abstract class Controller implements IController {
     destroy(_ctx: HttpContext): any;
 }
 
+declare abstract class ServiceProvider implements IServiceProvider {
+    protected app: Application;
+    constructor(app: Application);
+    /**
+     * 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>;
+}
+
 declare class Kernel {
-    private middleware;
-    constructor(middleware?: Middleware[]);
+    protected context: (event: H3Event) => HttpContext;
+    protected middleware: IMiddleware[];
+    constructor(context: (event: H3Event) => HttpContext, middleware?: IMiddleware[]);
     handle(event: H3Event, next: (ctx: HttpContext) => Promise<unknown>): Promise<unknown>;
     private runMiddleware;
     private isPlainObject;

package/dist/index.js

@@ -1,13 +1,358 @@
-import {
-  AppServiceProvider,
-  Application,
-  Container,
-  Controller,
-  Kernel,
-  PathLoader,
-  ServiceProvider,
-  ViewServiceProvider
-} from "./chunk-22XJG4AW.js";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/Container.ts
+var Container = class {
+  static {
+    __name(this, "Container");
+  }
+  bindings = /* @__PURE__ */ new Map();
+  singletons = /* @__PURE__ */ new Map();
+  bind(key, factory) {
+    this.bindings.set(key, factory);
+  }
+  /**
+   * Bind a singleton service to the container
+   */
+  singleton(key, factory) {
+    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(key) {
+    if (this.bindings.has(key)) {
+      return this.bindings.get(key)();
+    }
+    if (typeof key === "function") {
+      return this.build(key);
+    }
+    throw new Error(`No binding found for key: ${typeof key === "string" ? key : key?.name}`);
+  }
+  /**
+   * Automatically build a class with constructor dependency injection
+   */
+  build(ClassType) {
+    const paramTypes = 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) {
+    return this.bindings.has(key);
+  }
+};
+
+// src/Utils/PathLoader.ts
+import nodepath from "path";
+var PathLoader = class {
+  static {
+    __name(this, "PathLoader");
+  }
+  paths = {
+    base: "",
+    views: "/src/resources/views",
+    assets: "/public/assets",
+    routes: "/src/routes",
+    config: "/src/config",
+    public: "/public",
+    storage: "/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, base) {
+    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, path2, base) {
+    if (base && name !== "base") {
+      this.paths[name] = nodepath.join(base, path2);
+    }
+    this.paths[name] = path2;
+  }
+};
+
+// src/Application.ts
+import path from "path";
+var Application = class _Application extends Container {
+  static {
+    __name(this, "Application");
+  }
+  paths = new PathLoader();
+  booted = false;
+  versions = {
+    app: "0",
+    ts: "0"
+  };
+  basePath;
+  providers = [];
+  externalProviders = [];
+  constructor(basePath) {
+    super();
+    this.basePath = basePath;
+    this.setPath("base", basePath);
+    this.loadOptions();
+    this.registerBaseBindings();
+  }
+  /**
+   * Register core bindings into the container
+   */
+  registerBaseBindings() {
+    this.bind(_Application, () => this);
+    this.bind("path.base", () => this.basePath);
+    this.bind("app.paths", () => this.paths);
+  }
+  /**
+   * Dynamically register all configured providers
+   */
+  async registerConfiguredProviders() {
+    const providers = await this.getAllProviders();
+    for (const ProviderClass of providers) {
+      if (!ProviderClass)
+        continue;
+      const provider = new ProviderClass(this);
+      await this.register(provider);
+    }
+  }
+  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.
+   */
+  async getConfiguredProviders() {
+    return [
+      (await this.safeImport("@h3ravel/core")).AppServiceProvider,
+      (await this.safeImport("@h3ravel/http")).HttpServiceProvider,
+      (await this.safeImport("@h3ravel/config")).ConfigServiceProvider,
+      (await this.safeImport("@h3ravel/router")).RouteServiceProvider,
+      (await this.safeImport("@h3ravel/router")).AssetsServiceProvider,
+      (await this.safeImport("@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
+    ];
+  }
+  async getAllProviders() {
+    const coreProviders = await this.getConfiguredProviders();
+    return [
+      ...coreProviders,
+      ...this.externalProviders
+    ];
+  }
+  registerProviders(providers) {
+    this.externalProviders.push(...providers);
+  }
+  /**
+   * Register a provider
+   */
+  async register(provider) {
+    await provider.register();
+    this.providers.push(provider);
+  }
+  /**
+   * Boot all providers after registration
+   */
+  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
+   */
+  async safeImport(moduleName) {
+    console.log(moduleName);
+    try {
+      const mod = await import(moduleName);
+      return mod.default ?? mod ?? {};
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get the base path of the app
+   * 
+   * @returns 
+   */
+  getBasePath() {
+    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, pth) {
+    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, path2) {
+    return this.paths.setPath(name, path2, this.basePath);
+  }
+  /**
+   * Returns the installed version of the system core and typescript.
+   *
+   * @returns 
+   */
+  getVersion(key) {
+    return this.versions[key]?.replaceAll(/\^|\~/g, "");
+  }
+};
+
+// src/Controller.ts
+var Controller = class {
+  static {
+    __name(this, "Controller");
+  }
+  app;
+  constructor(app) {
+    this.app = app;
+  }
+  show(_ctx) {
+    return;
+  }
+  index(_ctx) {
+    return;
+  }
+  store(_ctx) {
+    return;
+  }
+  update(_ctx) {
+    return;
+  }
+  destroy(_ctx) {
+    return;
+  }
+};
+
+// src/ServiceProvider.ts
+var ServiceProvider = class {
+  static {
+    __name(this, "ServiceProvider");
+  }
+  app;
+  constructor(app) {
+    this.app = app;
+  }
+};
+
+// src/Http/Kernel.ts
+var Kernel = class {
+  static {
+    __name(this, "Kernel");
+  }
+  context;
+  middleware;
+  constructor(context, middleware = []) {
+    this.context = context;
+    this.middleware = middleware;
+  }
+  async handle(event, next) {
+    const ctx = this.context(event);
+    const result = await this.runMiddleware(ctx, () => next(ctx));
+    if (result !== void 0 && this.isPlainObject(result)) {
+      event.res.headers.set("Content-Type", "application/json; charset=UTF-8");
+    }
+    return result;
+  }
+  async runMiddleware(context, next) {
+    let index = -1;
+    const runner = /* @__PURE__ */ __name(async (i) => {
+      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);
+      }
+    }, "runner");
+    return runner(0);
+  }
+  isPlainObject(value) {
+    return typeof value === "object" && value !== null && (value.constructor === Object || value.constructor === Array);
+  }
+};
+
+// src/Providers/AppServiceProvider.ts
+import "reflect-metadata";
+var AppServiceProvider = class extends ServiceProvider {
+  static {
+    __name(this, "AppServiceProvider");
+  }
+  register() {
+  }
+};
+
+// src/Providers/ViewServiceProvider.ts
+import { Edge } from "edge.js";
+var ViewServiceProvider = class extends ServiceProvider {
+  static {
+    __name(this, "ViewServiceProvider");
+  }
+  register() {
+    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);
+  }
+};
 export {
   AppServiceProvider,
   Application,