@h3ravel/core 0.1.0

package/dist/chunk-UZGBH6AC.js

@@ -0,0 +1,776 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../http/src/Middleware.ts
+var Middleware = class {
+  static {
+    __name(this, "Middleware");
+  }
+};
+
+// ../http/src/Request.ts
+import { getQuery, getRouterParams, readBody } from "h3";
+
+// ../support/src/Helpers/Obj.ts
+function safeDot(data, key) {
+  if (!key) return data;
+  return key.split(".").reduce((acc, k) => acc?.[k], data);
+}
+__name(safeDot, "safeDot");
+var setNested = /* @__PURE__ */ __name((obj, key, value) => {
+  if (!key.includes(".")) {
+    obj[key] = value;
+    return;
+  }
+  const parts = key.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (i === parts.length - 1) {
+      current[part] = value;
+    } else {
+      if (typeof current[part] !== "object" || current[part] === null) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+  }
+}, "setNested");
+
+// ../support/src/Helpers/Str.ts
+var afterLast = /* @__PURE__ */ __name((value, search) => {
+  if (!search) return value;
+  const lastIndex = value.lastIndexOf(search);
+  return lastIndex !== -1 ? value.slice(lastIndex + search.length) : value;
+}, "afterLast");
+var before = /* @__PURE__ */ __name((value, search) => {
+  if (!search) return value;
+  const index = value.indexOf(search);
+  return index !== -1 ? value.slice(0, index) : value;
+}, "before");
+
+// ../http/src/Request.ts
+var Request = class {
+  static {
+    __name(this, "Request");
+  }
+  event;
+  constructor(event) {
+    this.event = event;
+  }
+  /**
+   * Get all input data (query + body).
+   */
+  async all() {
+    let data = {
+      ...getRouterParams(this.event),
+      ...getQuery(this.event)
+    };
+    if (this.event.req.method === "POST") {
+      data = Object.assign({}, data, Object.fromEntries((await this.event.req.formData()).entries()));
+    } else if (this.event.req.method === "PUT") {
+      data = Object.fromEntries(Object.entries(await readBody(this.event)));
+    }
+    return data;
+  }
+  /**
+   * Get a single input field from query or body.
+   */
+  async input(key, defaultValue) {
+    const data = await this.all();
+    return data[key] ?? defaultValue;
+  }
+  /**
+   * Get route parameters.
+   */
+  params() {
+    return getRouterParams(this.event);
+  }
+  /**
+   * Get query parameters.
+   */
+  query() {
+    return getQuery(this.event);
+  }
+  getEvent(key) {
+    return safeDot(this.event, key);
+  }
+};
+
+// ../http/src/Response.ts
+import { html, redirect } from "h3";
+var Response = class {
+  static {
+    __name(this, "Response");
+  }
+  event;
+  statusCode = 200;
+  headers = {};
+  constructor(event) {
+    this.event = event;
+  }
+  /**
+   * Set HTTP status code.
+   */
+  setStatusCode(code) {
+    this.statusCode = code;
+    this.event.res.status = code;
+    return this;
+  }
+  /**
+   * Set a header.
+   */
+  setHeader(name, value) {
+    this.headers[name] = value;
+    return this;
+  }
+  html(content) {
+    this.applyHeaders();
+    return html(this.event, content);
+  }
+  /**
+   * Send a JSON response.
+   */
+  json(data) {
+    this.setHeader("content-type", "application/json; charset=utf-8");
+    this.applyHeaders();
+    return data;
+  }
+  /**
+   * Send plain text.
+   */
+  text(data) {
+    this.setHeader("content-type", "text/plain; charset=utf-8");
+    this.applyHeaders();
+    return data;
+  }
+  /**
+   * Redirect to another URL.
+   */
+  redirect(url, status = 302) {
+    this.setStatusCode(status);
+    return redirect(this.event, url, this.statusCode);
+  }
+  /**
+   * Apply headers before sending response.
+   */
+  applyHeaders() {
+    Object.entries(this.headers).forEach(([key, value]) => {
+      this.event.res.headers.set(key, value);
+    });
+  }
+  getEvent(key) {
+    return safeDot(this.event, key);
+  }
+};
+
+// ../http/src/Middleware/LogRequests.ts
+var LogRequests = class extends Middleware {
+  static {
+    __name(this, "LogRequests");
+  }
+  async handle({ request }, next) {
+    const url = request.getEvent("url");
+    console.log(`[${request.getEvent("method")}] ${url.pathname + url.search}`);
+    return next();
+  }
+};
+
+// ../http/src/Providers/HttpServiceProvider.ts
+import { H3, serve } from "h3";
+
+// 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: "/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, 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 import("./index.js")).AppServiceProvider,
+      (await import("./src-HATPJSC4.js")).HttpServiceProvider,
+      (await import("./src-KWAEFHNO.js")).ConfigServiceProvider,
+      (await import("./src-E5IZSMT7.js")).RouteServiceProvider,
+      (await import("./src-E5IZSMT7.js")).AssetsServiceProvider,
+      (await import("./index.js")).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) {
+    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");
+  }
+  middleware;
+  constructor(middleware = []) {
+    this.middleware = middleware;
+  }
+  async handle(event, next) {
+    const context = {
+      request: new Request(event),
+      response: new Response(event)
+    };
+    const result = await this.runMiddleware(context, () => next(context));
+    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);
+  }
+};
+
+// ../http/src/Providers/HttpServiceProvider.ts
+var HttpServiceProvider = class extends ServiceProvider {
+  static {
+    __name(this, "HttpServiceProvider");
+  }
+  register() {
+    this.app.singleton("http.app", () => {
+      return new H3();
+    });
+    this.app.singleton("http.serve", () => serve);
+  }
+};
+
+// ../http/src/Resources/JsonResource.ts
+var JsonResource = class {
+  static {
+    __name(this, "JsonResource");
+  }
+  event;
+  /**
+   * The request instance
+   */
+  request;
+  /**
+   * The response instance
+   */
+  response;
+  /**
+   * The data to send to the client
+   */
+  resource;
+  /**
+   * The final response data object
+   */
+  body = {
+    data: {}
+  };
+  /**
+   * Flag to track if response should be sent automatically
+   */
+  shouldSend = false;
+  /**
+   * Flag to track if response has been sent
+   */
+  responseSent = false;
+  /**
+   * @param req The request instance
+   * @param res The response instance
+   * @param rsc The data to send to the client
+   */
+  constructor(event, rsc) {
+    this.event = event;
+    this.request = event.req;
+    this.response = event.res;
+    this.resource = rsc;
+    for (const key of Object.keys(rsc)) {
+      if (!(key in this)) {
+        Object.defineProperty(this, key, {
+          enumerable: true,
+          configurable: true,
+          get: /* @__PURE__ */ __name(() => this.resource[key], "get"),
+          set: /* @__PURE__ */ __name((value) => {
+            this.resource[key] = value;
+          }, "set")
+        });
+      }
+    }
+  }
+  /**
+   * Return the data in the expected format
+   * 
+   * @returns 
+   */
+  data() {
+    return this.resource;
+  }
+  /**
+   * Build the response object
+   * @returns this
+   */
+  json() {
+    this.shouldSend = true;
+    this.response.status = 200;
+    const resource = this.data();
+    let data = Array.isArray(resource) ? [
+      ...resource
+    ] : {
+      ...resource
+    };
+    if (typeof data.data !== "undefined") {
+      data = data.data;
+    }
+    if (!Array.isArray(resource)) {
+      delete data.pagination;
+    }
+    this.body = {
+      data
+    };
+    if (!Array.isArray(resource) && resource.pagination) {
+      const meta = this.body.meta ?? {};
+      meta.pagination = resource.pagination;
+      this.body.meta = meta;
+    }
+    if (this.resource.pagination && !this.body.meta?.pagination) {
+      const meta = this.body.meta ?? {};
+      meta.pagination = this.resource.pagination;
+      this.body.meta = meta;
+    }
+    return this;
+  }
+  /**
+   * Add context data to the response object
+   * @param data Context data
+   * @returns this
+   */
+  additional(data) {
+    this.shouldSend = true;
+    delete data.data;
+    delete data.pagination;
+    this.body = {
+      ...this.body,
+      ...data
+    };
+    return this;
+  }
+  /**
+   * Send the output to the client
+   * @returns this
+   */
+  send() {
+    this.shouldSend = false;
+    if (!this.responseSent) {
+      this.#send();
+    }
+    return this;
+  }
+  /**
+   * Set the status code for this response
+   * @param code Status code
+   * @returns this
+   */
+  status(code) {
+    this.response.status = code;
+    return this;
+  }
+  /**
+   * Private method to send the response
+   */
+  #send() {
+    if (!this.responseSent) {
+      this.event.context.this.response.json(this.body);
+      this.responseSent = true;
+    }
+  }
+  /**
+   * Check if send should be triggered automatically
+   */
+  checkSend() {
+    if (this.shouldSend && !this.responseSent) {
+      this.#send();
+    }
+  }
+};
+
+// ../http/src/Resources/ApiResource.ts
+function ApiResource(instance) {
+  return new Proxy(instance, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        if (prop === "json" || prop === "additional") {
+          return (...args) => {
+            const result = value.apply(target, args);
+            setImmediate(() => target["checkSend"]());
+            return result;
+          };
+        } else if (prop === "send") {
+          return (...args) => {
+            target["shouldSend"] = false;
+            return value.apply(target, args);
+          };
+        }
+      }
+      return value;
+    }
+  });
+}
+__name(ApiResource, "ApiResource");
+
+export {
+  __name,
+  __require,
+  __commonJS,
+  __toESM,
+  Container,
+  PathLoader,
+  Middleware,
+  safeDot,
+  setNested,
+  afterLast,
+  before,
+  Request,
+  Response,
+  LogRequests,
+  HttpServiceProvider,
+  JsonResource,
+  ApiResource,
+  Application,
+  Controller,
+  ServiceProvider,
+  Kernel,
+  AppServiceProvider,
+  ViewServiceProvider
+};
+//# sourceMappingURL=chunk-UZGBH6AC.js.map