@orieljs/routing 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,997 @@
+// BaseRouter.ts
+import {
+  CurrentRoute as CurrentRoute2,
+  UrlGenerator,
+  ViewFactory
+} from "@orieljs/contracts";
+import { currentContainer as currentContainer2 } from "@orieljs/container";
+
+// dispatch.ts
+import { CurrentRoute } from "@orieljs/contracts";
+import { currentContainer } from "@orieljs/container";
+
+// bindings.ts
+import { RouteModelResolver } from "@orieljs/contracts";
+import { BindingResolutionError } from "@orieljs/container";
+import { Str } from "@orieljs/support";
+
+// errors.ts
+var NotFoundHttpError = class extends Error {
+  kind = "Http";
+  status = 404;
+  name = "NotFoundHttpError";
+  constructor(path) {
+    super(`The route ${path} could not be found.`);
+  }
+};
+var MethodNotAllowedHttpError = class extends Error {
+  kind = "Http";
+  status = 405;
+  headers;
+  name = "MethodNotAllowedHttpError";
+  constructor(method, path, allowed) {
+    super(`The ${method} method is not supported for route ${path}. Supported methods: ${allowed.join(", ")}.`);
+    this.headers = { Allow: allowed.join(", ") };
+  }
+};
+var RouteNotDefinedError = class extends Error {
+  constructor(routeName) {
+    super(`Route [${routeName}] not defined.`);
+    this.routeName = routeName;
+  }
+  routeName;
+  kind = "Server";
+  status = 500;
+  name = "RouteNotDefinedError";
+};
+var UrlGenerationError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "UrlGenerationError";
+  constructor(routeName, uri, missing) {
+    super(`Missing required parameter for [Route: ${routeName}] [URI: ${uri}] [Missing parameter: ${missing.join(", ")}].`);
+  }
+};
+var RouteModelNotFoundError = class extends Error {
+  constructor(model, value) {
+    super(`No query results for model [${model}] ${String(value)}`);
+    this.model = model;
+    this.ids = [value];
+  }
+  model;
+  kind = "ModelNotFound";
+  status = 404;
+  ids;
+  name = "RouteModelNotFoundError";
+};
+var RoutingError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "RoutingError";
+};
+
+// middleware.ts
+import {
+  ExceptionHandler,
+  PipelineFactory
+} from "@orieljs/contracts";
+
+// toResponse.ts
+async function toResponse(request, value) {
+  if (value instanceof Response) return value;
+  if (value === null || value === void 0) return new Response(null, { status: 204 });
+  if (typeof value === "string") return html(value);
+  if (typeof value !== "object") return html(String(value));
+  const candidate = value;
+  if (typeof candidate.toResponse === "function") {
+    return toResponse(request, await candidate.toResponse.call(value, request));
+  }
+  if (typeof candidate.render === "function") return html(String(await candidate.render.call(value)));
+  if (typeof candidate.toHtml === "function") return html(String(candidate.toHtml.call(value)));
+  if (typeof candidate.toJSON !== "function") {
+    if (typeof candidate.toJson === "function") return json(String(candidate.toJson.call(value)));
+    if (typeof candidate.toArray === "function") return json(JSON.stringify(candidate.toArray.call(value)));
+  }
+  return json(JSON.stringify(value));
+}
+function html(body) {
+  return new Response(body, { headers: { "content-type": "text/html; charset=utf-8" } });
+}
+function json(body) {
+  return new Response(body, { headers: { "content-type": "application/json" } });
+}
+
+// middleware.ts
+var MiddlewareNotFoundError = class extends Error {
+  constructor(middleware) {
+    super(
+      `Middleware [${middleware}] is not defined. Register it with Route.aliasMiddleware() or withMiddleware((m) => m.alias({ ... })).`
+    );
+    this.middleware = middleware;
+  }
+  middleware;
+  kind = "Server";
+  status = 500;
+  name = "MiddlewareNotFoundError";
+};
+function expand(references, aliases, groups, visiting, out) {
+  for (const reference of references) {
+    if (typeof reference === "function") {
+      out.push({ cls: reference, parameters: [] });
+      continue;
+    }
+    const index = reference.indexOf(":");
+    const name = index === -1 ? reference : reference.slice(0, index);
+    const parameters = index === -1 ? [] : reference.slice(index + 1).split(",");
+    if (index === -1 && Object.hasOwn(groups, name)) {
+      if (visiting.has(name)) throw new RoutingError(`Middleware group [${name}] includes itself.`);
+      visiting.add(name);
+      expand(groups[name], aliases, groups, visiting, out);
+      visiting.delete(name);
+      continue;
+    }
+    if (!Object.hasOwn(aliases, name)) throw new MiddlewareNotFoundError(reference);
+    out.push({ cls: aliases[name], parameters });
+  }
+}
+function resolveMiddleware(references, excluded, aliases, groups) {
+  const all = [];
+  expand(references, aliases, groups, /* @__PURE__ */ new Set(), all);
+  const skipped = [];
+  expand(excluded, aliases, groups, /* @__PURE__ */ new Set(), skipped);
+  const skippedClasses = new Set(skipped.map((entry) => entry.cls));
+  const seen = /* @__PURE__ */ new Set();
+  const classIds = /* @__PURE__ */ new Map();
+  return all.filter((entry) => {
+    if (skippedClasses.has(entry.cls)) return false;
+    if (!classIds.has(entry.cls)) classIds.set(entry.cls, classIds.size);
+    const key = `${classIds.get(entry.cls)}:${entry.parameters.join(",")}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function renderError(container, request, error) {
+  if (!container.bound(ExceptionHandler)) throw error;
+  const handler = container.make(ExceptionHandler);
+  await handler.report(error);
+  return handler.render(request, error);
+}
+async function guard(container, request, run) {
+  try {
+    const result = await run();
+    return result instanceof Response ? result : await toResponse(request, result);
+  } catch (error) {
+    return renderError(container, request, error);
+  }
+}
+async function runMiddleware(container, request, middleware, instances, destination, stage) {
+  const pipes = middleware.map(({ cls, parameters }) => {
+    const instance = container.make(cls);
+    instances.push(instance);
+    return (passable, next) => guard(container, passable, () => instance.handle(passable, next, ...parameters));
+  });
+  if (stage !== void 0) {
+    pipes.splice(
+      stage.at,
+      0,
+      (passable, next) => guard(container, passable, async () => {
+        await stage.run(passable);
+        return next(passable);
+      })
+    );
+  }
+  return container.make(PipelineFactory).make().send(request).through(pipes).then((passable) => guard(container, passable, () => destination(passable)));
+}
+
+// bindings.ts
+function orderForBindings(router, middleware) {
+  const aliases = router.getMiddleware();
+  const groups = router.getMiddlewareGroups();
+  const early = /* @__PURE__ */ new Set();
+  for (const name of ["auth", "guest"]) if (Object.hasOwn(aliases, name)) early.add(aliases[name]);
+  for (const group of ["web", "api"]) {
+    try {
+      for (const entry of resolveMiddleware([group], [], aliases, groups)) early.add(entry.cls);
+    } catch {
+    }
+  }
+  const before = middleware.filter((entry) => early.has(entry.cls));
+  const after = middleware.filter((entry) => !early.has(entry.cls));
+  return { middleware: [...before, ...after], at: before.length };
+}
+async function substituteBindings(router, route, values, container) {
+  const resolver = container.bound(RouteModelResolver) ? container.make(RouteModelResolver) : void 0;
+  const bound = {};
+  for (const { name, field } of route.parameters) {
+    const value = values[name];
+    if (value === void 0) {
+      bound[name] = void 0;
+      continue;
+    }
+    const binder = router.getBinder(name);
+    if (binder !== void 0) {
+      bound[name] = await binder(value);
+      continue;
+    }
+    const model = router.getModel(name);
+    if (model !== void 0) {
+      if (resolver === void 0) {
+        throw new BindingResolutionError(
+          `Route.model('${name}', ${model.name}) needs a RouteModelResolver. Is the Database service provider registered?`
+        );
+      }
+      const found = await resolver.resolveExplicit(model, value, field);
+      if (found === null || found === void 0) throw new RouteModelNotFoundError(model.name, value);
+      bound[name] = found;
+      continue;
+    }
+    if (resolver !== void 0) {
+      const found = await resolver.resolve(name, value, field);
+      if (found === null) throw new RouteModelNotFoundError(Str.studly(name), value);
+      bound[name] = found === void 0 ? value : found;
+      continue;
+    }
+    bound[name] = value;
+  }
+  return bound;
+}
+
+// RouteDefinition.ts
+var PARAMETER = /\{(\w+)(?::(\w+))?(\?)?\}/g;
+var WHOLE_OPTIONAL = /^\{(\w+)(?::\w+)?\?\}$/;
+var escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function parseParameters(uri) {
+  return [...uri.matchAll(PARAMETER)].map((match) => ({ name: match[1], optional: match[3] === "?", field: match[2] }));
+}
+function normalizeUri(uri) {
+  const trimmed = uri.replace(/^\/+|\/+$/g, "");
+  return trimmed === "" ? "/" : trimmed;
+}
+function normalizePath(pathname) {
+  const trimmed = pathname.replace(/^\/+|\/+$/g, "").replace(/\/{2,}/g, "/");
+  return trimmed === "" ? "" : `/${trimmed}`;
+}
+function decode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function compileBody(uri, wheres) {
+  if (uri === "/") return "";
+  const group = (name) => `(?<p_${name}>${wheres[name] ?? "[^/]+"})`;
+  let body = "";
+  for (const segment of uri.split("/")) {
+    const whole = WHOLE_OPTIONAL.exec(segment);
+    if (whole) {
+      body += `(?:/${group(whole[1])})?`;
+      continue;
+    }
+    let piece = "";
+    let last = 0;
+    for (const match of segment.matchAll(PARAMETER)) {
+      piece += escapeRegex(segment.slice(last, match.index)) + group(match[1]) + (match[3] === "?" ? "?" : "");
+      last = match.index + match[0].length;
+    }
+    body += `/${piece}${escapeRegex(segment.slice(last))}`;
+  }
+  return body;
+}
+var FALLBACK_SEGMENT = "{fallbackPlaceholder}";
+function compileFallback(uri, wheres) {
+  const tail = "(?:/(?<p_fallbackPlaceholder>.*))?";
+  if (uri === FALLBACK_SEGMENT) return new RegExp(`^${tail}$`, "s");
+  if (!uri.endsWith(`/${FALLBACK_SEGMENT}`)) return new RegExp(`^${compileBody(uri, { ...wheres, fallbackPlaceholder: ".*" })}$`, "s");
+  return new RegExp(`^${compileBody(uri.slice(0, -FALLBACK_SEGMENT.length - 1), wheres)}${tail}$`, "s");
+}
+function compareRoutes(a, b) {
+  if (a.isFallback !== b.isFallback) return a.isFallback ? 1 : -1;
+  const left = a.rank();
+  const right = b.rank();
+  for (let i = 0; i < Math.max(left.length, right.length); i++) {
+    const x = left[i] ?? -1;
+    const y = right[i] ?? -1;
+    if (x !== y) return x - y;
+  }
+  return 0;
+}
+var RouteDefinition = class {
+  methods;
+  uri;
+  action;
+  controller;
+  isFallback;
+  parameters;
+  #name;
+  #middleware;
+  #excluded = [];
+  #wheres = {};
+  #compiled;
+  constructor(methods, uri, action, attributes = {}) {
+    this.methods = [...new Set(methods.map((method) => method.toUpperCase()))];
+    this.uri = normalizeUri(uri);
+    this.action = action;
+    this.controller = attributes.controller;
+    this.isFallback = attributes.fallback ?? false;
+    this.parameters = parseParameters(this.uri);
+    this.#name = attributes.namePrefix === void 0 || attributes.namePrefix === "" ? void 0 : attributes.namePrefix;
+    this.#middleware = [...attributes.middleware ?? []];
+  }
+  getName() {
+    return this.#name;
+  }
+  /** Appends, like Laravel's $action['as'] .= $name. */
+  name(name) {
+    this.#name = (this.#name ?? "") + name;
+    return this;
+  }
+  middleware(...middleware) {
+    this.#middleware.push(...middleware.flat());
+    return this;
+  }
+  withoutMiddleware(...middleware) {
+    this.#excluded.push(...middleware.flat());
+    return this;
+  }
+  where(parameter, pattern) {
+    if (typeof parameter === "string") this.#wheres[parameter] = pattern ?? "[^/]+";
+    else Object.assign(this.#wheres, parameter);
+    this.#compiled = void 0;
+    return this;
+  }
+  gatherMiddleware() {
+    return [...this.#middleware];
+  }
+  excludedMiddleware() {
+    return [...this.#excluded];
+  }
+  wheres() {
+    return { ...this.#wheres };
+  }
+  getActionName() {
+    if (typeof this.action === "string") return `${this.controller?.name ?? "Controller"}@${this.action}`;
+    if (Array.isArray(this.action)) return `${this.action[0].name}@${String(this.action[1])}`;
+    return "Closure";
+  }
+  /** Decoded parameter values when `path` (normalizePath output) matches, else undefined. */
+  match(path, patterns = {}, version = 0) {
+    const found = this.#regex(patterns, version).exec(path);
+    if (found === null) return void 0;
+    const values = {};
+    for (const { name } of this.parameters) {
+      const raw = found.groups?.[`p_${name}`];
+      values[name] = raw === void 0 ? void 0 : decode(raw);
+    }
+    return values;
+  }
+  /** Per-segment specificity: static 0, parameter 1, optional parameter 2. Lower sorts first. */
+  rank() {
+    if (this.uri === "/") return [];
+    return this.uri.split("/").map((segment) => WHOLE_OPTIONAL.test(segment) ? 2 : segment.includes("{") ? 1 : 0);
+  }
+  #regex(patterns, version) {
+    if (this.#compiled !== void 0 && this.#compiled.version === version) return this.#compiled.regex;
+    const wheres = { ...patterns, ...this.#wheres };
+    const regex = this.isFallback ? compileFallback(this.uri, wheres) : new RegExp(`^${compileBody(this.uri, wheres)}$`);
+    this.#compiled = { regex, version };
+    return regex;
+  }
+};
+
+// dispatch.ts
+var ControllerMethodNotFoundError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "ControllerMethodNotFoundError";
+  constructor(controller, method) {
+    super(`Method ${controller}::${method} does not exist.`);
+  }
+};
+var isClass = (value) => typeof value === "function" && /^class[\s{]/.test(Function.prototype.toString.call(value));
+function findRoute(router, request) {
+  const method = request.method().toUpperCase();
+  const path = normalizePath(new URL(request.raw.url).pathname);
+  const patterns = router.getPatterns();
+  const version = router.getPatternVersion();
+  const allowed = /* @__PURE__ */ new Set();
+  for (const route of router.getRoutesByMatchOrder()) {
+    const values = route.match(path, patterns, version);
+    if (values === void 0) continue;
+    if (route.methods.includes(method)) return { route, values };
+    if (!route.isFallback) for (const verb of route.methods) allowed.add(verb);
+  }
+  if (allowed.size > 0) {
+    if (method === "OPTIONS") return { response: new Response(null, { status: 200, headers: { Allow: [...allowed].join(", ") } }) };
+    throw new MethodNotAllowedHttpError(method, request.path(), [...allowed]);
+  }
+  throw new NotFoundHttpError(request.path());
+}
+async function runAction(scope, route, parameters) {
+  const args = route.parameters.map((parameter) => parameters[parameter.name]);
+  const action = route.action;
+  if (typeof action === "function" && !isClass(action)) return action(...args);
+  const [cls, method] = typeof action === "string" ? [route.controller, action] : isClass(action) ? [action, "__invoke"] : [action[0], String(action[1])];
+  const controller = scope.make(cls);
+  const handler = controller[method];
+  if (typeof handler !== "function") throw new ControllerMethodNotFoundError(cls.name, method);
+  return handler.apply(controller, args);
+}
+async function dispatchRoute(router, request, container) {
+  const scope = currentContainer() ?? container;
+  if (scope === void 0) throw new RoutingError("Cannot dispatch a request: no container is available.");
+  const match = findRoute(router, request);
+  if ("response" in match) return match.response;
+  const { route, values } = match;
+  const state = { route, parameters: { ...values }, middleware: [] };
+  scope.instance(CurrentRoute, state);
+  const middleware = resolveMiddleware(
+    route.gatherMiddleware(),
+    route.excludedMiddleware(),
+    router.getMiddleware(),
+    router.getMiddlewareGroups()
+  );
+  const ordered = orderForBindings(router, middleware);
+  return runMiddleware(scope, request, ordered.middleware, state.middleware, () => runAction(scope, route, state.parameters), {
+    at: ordered.at,
+    run: async () => void Object.assign(state.parameters, await substituteBindings(router, route, values, scope))
+  });
+}
+
+// GroupRegistrar.ts
+var ALL_VERBS = ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+function mergeGroup(parent, child) {
+  const prefix = [parent.prefix, child.prefix].map((part) => (part ?? "").replace(/^\/+|\/+$/g, "")).filter((part) => part !== "").join("/");
+  const merged = {
+    middleware: [...parent.middleware ?? [], ...child.middleware ?? []]
+  };
+  if (prefix !== "") merged.prefix = prefix;
+  const as = (parent.as ?? "") + (child.as ?? "");
+  if (as !== "") merged.as = as;
+  const controller = child.controller ?? parent.controller;
+  if (controller !== void 0) merged.controller = controller;
+  return merged;
+}
+var GroupRegistrar = class {
+  constructor(router) {
+    this.router = router;
+  }
+  router;
+  #attributes = {};
+  prefix(prefix) {
+    this.#attributes.prefix = prefix;
+    return this;
+  }
+  name(prefix) {
+    this.#attributes.as = prefix;
+    return this;
+  }
+  middleware(...middleware) {
+    this.#attributes.middleware = [...this.#attributes.middleware ?? [], ...middleware.flat()];
+    return this;
+  }
+  controller(controller) {
+    this.#attributes.controller = controller;
+    return this;
+  }
+  group(routes) {
+    return this.router.group({ ...this.#attributes }, routes);
+  }
+  get(uri, action) {
+    return this.#one(["GET", "HEAD"], uri, action);
+  }
+  post(uri, action) {
+    return this.#one(["POST"], uri, action);
+  }
+  put(uri, action) {
+    return this.#one(["PUT"], uri, action);
+  }
+  patch(uri, action) {
+    return this.#one(["PATCH"], uri, action);
+  }
+  delete(uri, action) {
+    return this.#one(["DELETE"], uri, action);
+  }
+  options(uri, action) {
+    return this.#one(["OPTIONS"], uri, action);
+  }
+  any(uri, action) {
+    return this.#one(ALL_VERBS, uri, action);
+  }
+  match(methods, uri, action) {
+    return this.#one(methods, uri, action);
+  }
+  resource(name, controller, options) {
+    void this.router.group({ ...this.#attributes }, () => this.router.resource(name, controller, options));
+  }
+  apiResource(name, controller, options) {
+    void this.router.group({ ...this.#attributes }, () => this.router.apiResource(name, controller, options));
+  }
+  #one(methods, uri, action) {
+    let route;
+    void this.router.group({ ...this.#attributes }, () => {
+      route = this.router.addRoute(methods, uri, action);
+    });
+    return route;
+  }
+};
+
+// resource.ts
+import { Str as Str2 } from "@orieljs/support";
+var DEFAULTS = ["index", "create", "store", "show", "edit", "update", "destroy"];
+var API_DEFAULTS = ["index", "store", "show", "update", "destroy"];
+function wildcard(segment, options) {
+  const renamed = options.parameters?.[segment];
+  return (renamed ?? Str2.singular(segment)).replace(/-/g, "_");
+}
+function resourceRoutes(name, options = {}, api = false) {
+  const segments = name.split(".");
+  const last = segments.at(-1);
+  const base = [...segments.slice(0, -1).map((segment) => `${segment}/{${wildcard(segment, options)}}`), last].join("/");
+  const member = `${base}/{${wildcard(last, options)}}`;
+  let methods = api ? API_DEFAULTS : DEFAULTS;
+  if (options.only !== void 0) methods = methods.filter((method) => options.only.includes(method));
+  if (options.except !== void 0) methods = methods.filter((method) => !options.except.includes(method));
+  const table = {
+    index: { verbs: ["GET", "HEAD"], uri: base },
+    create: { verbs: ["GET", "HEAD"], uri: `${base}/create` },
+    store: { verbs: ["POST"], uri: base },
+    show: { verbs: ["GET", "HEAD"], uri: member },
+    edit: { verbs: ["GET", "HEAD"], uri: `${member}/edit` },
+    update: { verbs: ["PUT", "PATCH"], uri: member },
+    destroy: { verbs: ["DELETE"], uri: member }
+  };
+  return methods.map((method) => ({
+    method,
+    verbs: table[method].verbs,
+    uri: table[method].uri,
+    name: options.names?.[method] ?? `${name}.${method}`
+  }));
+}
+
+// BaseRouter.ts
+var BaseRouter = class {
+  /** `container` is the application; request-time lookups use the current (request) container first. */
+  constructor(container) {
+    this.container = container;
+  }
+  container;
+  #routes = [];
+  #sorted;
+  #groupStack = [];
+  #patterns = {};
+  #patternVersion = 0;
+  #aliases = {};
+  #groups = { web: [], api: [] };
+  #binders = /* @__PURE__ */ new Map();
+  #models = /* @__PURE__ */ new Map();
+  get(uri, action) {
+    return this.addRoute(["GET", "HEAD"], uri, action);
+  }
+  post(uri, action) {
+    return this.addRoute(["POST"], uri, action);
+  }
+  put(uri, action) {
+    return this.addRoute(["PUT"], uri, action);
+  }
+  patch(uri, action) {
+    return this.addRoute(["PATCH"], uri, action);
+  }
+  delete(uri, action) {
+    return this.addRoute(["DELETE"], uri, action);
+  }
+  options(uri, action) {
+    return this.addRoute(["OPTIONS"], uri, action);
+  }
+  any(uri, action) {
+    return this.addRoute(ALL_VERBS, uri, action);
+  }
+  match(methods, uri, action) {
+    return this.addRoute(methods, uri, action);
+  }
+  /** Registers a route with the current group's prefix, name prefix, middleware and controller. GET implies HEAD. */
+  addRoute(methods, uri, action, options = {}) {
+    const group = this.#groupStack.at(-1) ?? {};
+    const verbs = methods.map((method) => method.toUpperCase());
+    if (verbs.includes("GET") && !verbs.includes("HEAD")) verbs.push("HEAD");
+    if (typeof action === "string" && group.controller === void 0) {
+      throw new RoutingError(
+        `Route action [${action}] needs a controller. Use Route.controller(X).group(...) or pass [Controller, '${action}'].`
+      );
+    }
+    const prefix = (group.prefix ?? "").replace(/^\/+|\/+$/g, "");
+    const path = uri.replace(/^\/+|\/+$/g, "");
+    const route = new RouteDefinition(verbs, [prefix, path].filter((part) => part !== "").join("/"), action, {
+      ...group.as !== void 0 && { namePrefix: group.as },
+      ...group.middleware !== void 0 && { middleware: group.middleware },
+      ...group.controller !== void 0 && { controller: group.controller },
+      ...options.fallback === true && { fallback: true }
+    });
+    this.#routes.push(route);
+    this.#sorted = void 0;
+    return route;
+  }
+  /** Route.redirect('/here', '/there'): any verb, 302 by default; '{param}' in the target is filled from the URI. */
+  redirect(from, to, status = 302) {
+    const holder = {};
+    const action = (...values) => {
+      const parameters = new Map(holder.route.parameters.map((parameter, index) => [parameter.name, values[index]]));
+      const target = to.replace(/\{(\w+)\??\}/g, (_match, name) => {
+        const value = parameters.get(name);
+        return value === void 0 || value === null ? "" : encodeURIComponent(String(value));
+      });
+      const container = currentContainer2() ?? this.container;
+      const location = container?.bound(UrlGenerator) ? container.make(UrlGenerator).to(target) : target;
+      return new Response(null, { status, headers: { Location: location } });
+    };
+    holder.route = this.any(from, action);
+    return holder.route;
+  }
+  permanentRedirect(from, to) {
+    return this.redirect(from, to, 301);
+  }
+  /** Route.view('/about', 'pages.about', data): GET/HEAD; route parameters are merged into the view data. */
+  view(uri, view, data = {}) {
+    const holder = {};
+    const action = (...values) => {
+      const parameters = Object.fromEntries(holder.route.parameters.map((parameter, index) => [parameter.name, values[index]]));
+      const container = currentContainer2() ?? this.container;
+      if (container === void 0) throw new RoutingError(`Cannot render view [${view}]: no container is available.`);
+      return container.make(ViewFactory).make(view, { ...data, ...parameters });
+    };
+    holder.route = this.addRoute(["GET", "HEAD"], uri, action);
+    return holder.route;
+  }
+  resource(name, controller, options = {}) {
+    this.#registerResource(name, controller, options, false);
+  }
+  apiResource(name, controller, options = {}) {
+    this.#registerResource(name, controller, options, true);
+  }
+  /** Matches any GET path no other route matches. Always tried last. */
+  fallback(action) {
+    return this.addRoute(["GET", "HEAD"], "{fallbackPlaceholder}", action, { fallback: true });
+  }
+  prefix(prefix) {
+    return new GroupRegistrar(this).prefix(prefix);
+  }
+  name(prefix) {
+    return new GroupRegistrar(this).name(prefix);
+  }
+  middleware(...middleware) {
+    return new GroupRegistrar(this).middleware(...middleware);
+  }
+  controller(controller) {
+    return new GroupRegistrar(this).controller(controller);
+  }
+  /**
+   * Laravel's Route::group(attributes, callback). A synchronous callback's attributes are popped before this
+   * returns, so an unawaited group never leaks into later routes; an async callback keeps them until it settles.
+   */
+  group(attributes, routes) {
+    const entry = mergeGroup(this.#groupStack.at(-1) ?? {}, attributes);
+    this.#groupStack.push(entry);
+    const pop = () => {
+      const index = this.#groupStack.lastIndexOf(entry);
+      if (index !== -1) this.#groupStack.splice(index, 1);
+    };
+    let result;
+    try {
+      result = routes();
+    } catch (error) {
+      pop();
+      throw error;
+    }
+    if (result instanceof Promise) return result.finally(pop);
+    pop();
+    return Promise.resolve();
+  }
+  model(parameter, model) {
+    this.#models.set(parameter, model);
+  }
+  bind(parameter, resolver) {
+    this.#binders.set(parameter, resolver);
+  }
+  pattern(parameter, pattern) {
+    this.#patterns[parameter] = pattern;
+    this.#patternVersion++;
+  }
+  patterns(patterns) {
+    for (const [parameter, pattern] of Object.entries(patterns)) this.pattern(parameter, pattern);
+  }
+  getPatterns() {
+    return { ...this.#patterns };
+  }
+  /** Bumped by pattern(); routes recompile their matcher when it changes. */
+  getPatternVersion() {
+    return this.#patternVersion;
+  }
+  getBinder(parameter) {
+    return this.#binders.get(parameter);
+  }
+  getModel(parameter) {
+    return this.#models.get(parameter);
+  }
+  aliasMiddleware(name, middleware) {
+    this.#aliases[name] = middleware;
+    return this;
+  }
+  /** The middleware aliases (Laravel's Router::getMiddleware()). */
+  getMiddleware() {
+    return { ...this.#aliases };
+  }
+  middlewareGroup(name, middleware) {
+    this.#groups[name] = [...middleware];
+    return this;
+  }
+  pushMiddlewareToGroup(group, middleware) {
+    const list = this.#groups[group] ??= [];
+    if (!list.includes(middleware)) list.push(middleware);
+    return this;
+  }
+  prependMiddlewareToGroup(group, middleware) {
+    const list = this.#groups[group] ??= [];
+    if (!list.includes(middleware)) list.unshift(middleware);
+    return this;
+  }
+  hasMiddlewareGroup(name) {
+    return Object.hasOwn(this.#groups, name);
+  }
+  getMiddlewareGroups() {
+    return Object.fromEntries(Object.entries(this.#groups).map(([name, list]) => [name, [...list]]));
+  }
+  /** Every route, in registration order. */
+  getRoutes() {
+    return [...this.#routes];
+  }
+  /** Routes in matching order: static segments first, fallbacks last (cached until a route is added). */
+  getRoutesByMatchOrder() {
+    return this.#sorted ??= [...this.#routes].sort(compareRoutes);
+  }
+  /** The last route registered with this name wins, as in Laravel. */
+  getByName(name) {
+    return this.#routes.findLast((route) => route.getName() === name);
+  }
+  has(...names) {
+    return names.every((name) => this.getByName(name) !== void 0);
+  }
+  /** The route matched for the current request (read from the request scope). */
+  current() {
+    const container = currentContainer2();
+    if (container === void 0 || !container.bound(CurrentRoute2)) return void 0;
+    return container.make(CurrentRoute2).route;
+  }
+  currentRouteName() {
+    return this.current()?.getName();
+  }
+  /** Match, bind and run the route middleware and action (Router.dispatch; called by the Http kernel). */
+  dispatch(request) {
+    return dispatchRoute(this, request, this.container);
+  }
+  #registerResource(name, controller, options, api) {
+    for (const entry of resourceRoutes(name, options, api)) {
+      this.addRoute(entry.verbs, entry.uri, [controller, entry.method]).name(entry.name);
+    }
+  }
+};
+
+// BaseUrlGenerator.ts
+import { ConfigRepository, HttpRequest, Session } from "@orieljs/contracts";
+import { currentContainer as currentContainer3 } from "@orieljs/container";
+var VALID_URL = /^(#|\/\/|https?:\/\/|(mailto|tel|sms):)/i;
+var isPlainObject = (value) => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+function buildQuery(values) {
+  const pairs = [];
+  const add = (key, value) => {
+    if (value === null || value === void 0) return;
+    if (typeof value === "object" && (Array.isArray(value) || isPlainObject(value))) {
+      for (const [child, nested] of Object.entries(value)) add(`${key}[${child}]`, nested);
+      return;
+    }
+    const text = value === true ? "1" : value === false ? "0" : String(value);
+    pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(text)}`);
+  };
+  for (const [key, value] of Object.entries(values)) add(key, value);
+  return pairs.join("&");
+}
+function routeKey(value, field) {
+  if (typeof value !== "object" || value === null) return value;
+  const model = value;
+  if (field !== void 0) return typeof model.getAttribute === "function" ? model.getAttribute(field) : model[field];
+  return typeof model.getRouteKey === "function" ? model.getRouteKey() : value;
+}
+var BaseUrlGenerator = class {
+  constructor(router, container) {
+    this.router = router;
+    this.container = container;
+  }
+  router;
+  container;
+  /** 'http://localhost' (no trailing slash). */
+  root() {
+    const request = this.#request();
+    if (request !== void 0) return new URL(request.url()).origin;
+    const configured = this.#config("app.url", void 0);
+    return (configured ?? "http://localhost").replace(/\/+$/, "");
+  }
+  to(path, query = {}, absolute = true) {
+    const queryString = buildQuery(query);
+    const base = VALID_URL.test(path) ? path : this.#join(path, absolute);
+    if (queryString === "") return base;
+    return `${base}${base.includes("?") ? "&" : "?"}${queryString}`;
+  }
+  /**
+   * route('posts.show', post) / route('posts.show', [post, comment]) / route('posts.show', { post: 1, page: 2 }).
+   * Named values fill their parameters, positional values fill the rest in URI order; extra named values become
+   * the query string, extra positional ones are dropped.
+   */
+  route(name, parameters, absolute = true) {
+    const route = this.router.getByName(name);
+    if (route === void 0) throw new RouteNotDefinedError(name);
+    const named = isPlainObject(parameters) ? { ...parameters } : {};
+    const positional = Array.isArray(parameters) ? [...parameters] : parameters === void 0 || parameters === null || isPlainObject(parameters) ? [] : [parameters];
+    const values = /* @__PURE__ */ new Map();
+    const missing = [];
+    for (const parameter of route.parameters) {
+      let value;
+      if (Object.hasOwn(named, parameter.name)) {
+        value = named[parameter.name];
+        delete named[parameter.name];
+      } else if (positional.length > 0) {
+        value = positional.shift();
+      }
+      const key = routeKey(value, parameter.field);
+      const text = key === void 0 || key === null ? void 0 : String(key);
+      if (text === void 0 && !parameter.optional) missing.push(parameter.name);
+      values.set(parameter.name, text);
+    }
+    if (missing.length > 0) throw new UrlGenerationError(name, route.uri, missing);
+    const path = route.uri === "/" ? "" : route.uri.split("/").filter((segment) => {
+      const whole = WHOLE_OPTIONAL.exec(segment);
+      return whole === null || values.get(whole[1]) !== void 0;
+    }).map(
+      (segment) => segment.replace(PARAMETER, (_match, parameter) => {
+        const value = values.get(parameter);
+        return value === void 0 ? "" : encodeURIComponent(value);
+      })
+    ).join("/");
+    const query = Object.fromEntries(Object.entries(named).map(([key, value]) => [key, routeKey(value, void 0)]));
+    return this.to(path, query, absolute);
+  }
+  asset(path) {
+    if (VALID_URL.test(path)) return path;
+    const base = this.#config("app.asset_url", void 0)?.replace(/\/+$/, "") ?? this.root();
+    const trimmed = path.replace(/^\/+/, "");
+    return trimmed === "" ? base : `${base}/${trimmed}`;
+  }
+  /** The current URL without the query string. */
+  current() {
+    return this.#request()?.url() ?? this.root();
+  }
+  /** The current URL with the query string. */
+  full() {
+    return this.#request()?.fullUrl() ?? this.root();
+  }
+  /** The Referer header, then the session's previous URL, then `fallback`, then the root (Laravel's order). */
+  previous(fallback) {
+    const scope = this.#scope();
+    const request = this.#request();
+    const referer = request?.header("referer");
+    if (referer !== void 0 && referer !== "") return this.to(referer);
+    if (request !== void 0 && scope?.bound(Session)) {
+      const previous = scope.make(Session).previousUrl();
+      if (previous !== void 0 && previous !== "") return this.to(previous);
+    }
+    return this.to(fallback ?? "/");
+  }
+  hasRoute(name) {
+    return this.router.getByName(name) !== void 0;
+  }
+  #join(path, absolute) {
+    const trimmed = path.replace(/^\/+|\/+$/g, "");
+    if (!absolute) return `/${trimmed}`;
+    return trimmed === "" ? this.root() : `${this.root()}/${trimmed}`;
+  }
+  #scope() {
+    return currentContainer3() ?? this.container;
+  }
+  /** The HttpRequest, only when running inside a request scope. */
+  #request() {
+    const scope = this.#scope();
+    return scope?.bound(HttpRequest) ? scope.make(HttpRequest) : void 0;
+  }
+  #config(key, fallback) {
+    const scope = this.#scope();
+    return scope?.bound(ConfigRepository) ? scope.make(ConfigRepository).get(key, fallback) : fallback;
+  }
+};
+
+// facade.ts
+import { Router } from "@orieljs/contracts";
+import { facade } from "@orieljs/support";
+var Route = facade(Router);
+
+// routeFiles.ts
+import { pathToFileURL } from "url";
+var generation = 0;
+async function loadRoutesFrom(app, router, file) {
+  const url = `${pathToFileURL(file).href}?oriel-routes=${++generation}`;
+  const module = await app.run(() => import(
+    /* @vite-ignore */
+    url
+  ));
+  if (typeof module.default === "function") await app.run(() => module.default(router));
+}
+function healthResponse() {
+  const html2 = '<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="utf-8">\n<title>Application up</title>\n</head>\n<body><h1>Application up</h1></body>\n</html>';
+  return new Response(html2, { status: 200, headers: { "content-type": "text/html; charset=utf-8" } });
+}
+
+// RoutingServiceProvider.ts
+import { Router as Router2, RoutingPaths, UrlGenerator as UrlGenerator2 } from "@orieljs/contracts";
+import { ServiceProvider } from "@orieljs/support";
+var RoutingServiceProvider = class extends ServiceProvider {
+  register() {
+    this.app.singleton(Router2, () => new BaseRouter(this.app));
+    this.app.singleton(UrlGenerator2, () => {
+      const router = this.app.make(Router2);
+      if (!(router instanceof BaseRouter)) {
+        throw new RoutingError("The UrlGenerator needs the BaseRouter: the bound Router was replaced by another implementation.");
+      }
+      return new BaseUrlGenerator(router, this.app);
+    });
+  }
+  /**
+   * The files load in a booted() callback, after every provider's boot() (Laravel's withRouting does the same), so
+   * what the app's own providers set up at boot (Route.pattern/bind/model, gates, shared view data) is in place
+   * when the route files run.
+   */
+  boot() {
+    this.app.booted(async () => {
+      if (!this.app.bound(RoutingPaths)) return;
+      const { web, api, health, apiPrefix } = this.app.make(RoutingPaths);
+      const router = this.app.make(Router2);
+      if (health !== void 0) router.get(health, () => healthResponse());
+      if (web !== void 0) await router.middleware("web").group(() => loadRoutesFrom(this.app, router, web));
+      if (api !== void 0) await router.prefix(apiPrefix).middleware("api").group(() => loadRoutesFrom(this.app, router, api));
+    });
+  }
+};
+export {
+  BaseRouter,
+  BaseUrlGenerator,
+  ControllerMethodNotFoundError,
+  GroupRegistrar,
+  MethodNotAllowedHttpError,
+  MiddlewareNotFoundError,
+  NotFoundHttpError,
+  Route,
+  RouteDefinition,
+  RouteModelNotFoundError,
+  RouteNotDefinedError,
+  RoutingError,
+  RoutingServiceProvider,
+  UrlGenerationError,
+  buildQuery,
+  compareRoutes,
+  dispatchRoute,
+  healthResponse,
+  loadRoutesFrom,
+  mergeGroup,
+  normalizePath,
+  normalizeUri,
+  orderForBindings,
+  parseParameters,
+  renderError,
+  resolveMiddleware,
+  resourceRoutes,
+  runMiddleware,
+  substituteBindings,
+  toResponse
+};
+//# sourceMappingURL=index.js.map