@orieljs/session 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,801 @@
+// Store.ts
+import { Arr, Str } from "@orieljs/support";
+var unique = (values) => [...new Set(values)];
+var Store = class {
+  #id = "";
+  #name;
+  #attributes = {};
+  #started = false;
+  #handler;
+  #encrypter;
+  constructor(name, handler, id, encrypter) {
+    this.#name = name;
+    this.#handler = handler;
+    this.#encrypter = encrypter;
+    this.setId(id);
+  }
+  /** Loads the session from the handler and makes sure it has a CSRF token. */
+  async start() {
+    this.#attributes = { ...this.#attributes, ...await this.#readFromHandler() };
+    if (!this.has("_token")) this.regenerateToken();
+    this.#started = true;
+  }
+  /** Ages the flash data and writes the session through the handler. */
+  async save() {
+    this.ageFlashData();
+    const payload = JSON.stringify(this.#attributes);
+    await this.#handler.write(this.getId(), this.#encrypter === void 0 ? payload : this.#encrypter.encrypt(payload, false));
+    this.#started = false;
+  }
+  /** Forgets last request's flash data and marks this request's flash data as old. */
+  ageFlashData() {
+    this.forget(...this.get("_flash.old", []));
+    this.put("_flash.old", this.get("_flash.new", []));
+    this.put("_flash.new", []);
+  }
+  all() {
+    return { ...this.#attributes };
+  }
+  only(keys) {
+    return Arr.only(this.#attributes, keys);
+  }
+  except(keys) {
+    return Arr.except(this.#attributes, keys);
+  }
+  /** Whether the key is present, even with a null value. */
+  exists(...keys) {
+    return keys.every((key) => Arr.has(this.#attributes, key));
+  }
+  missing(...keys) {
+    return !this.exists(...keys);
+  }
+  /** Whether the key is present and not null/undefined. */
+  has(key) {
+    const value = this.get(key);
+    return value !== void 0 && value !== null;
+  }
+  get(key, defaultValue) {
+    return Arr.get(this.#attributes, key, defaultValue);
+  }
+  pull(key, defaultValue) {
+    const value = this.get(key, defaultValue);
+    this.forget(key);
+    return value;
+  }
+  put(key, value) {
+    const values = typeof key === "string" ? { [key]: value } : key;
+    for (const [name, item] of Object.entries(values)) Arr.set(this.#attributes, name, item);
+  }
+  push(key, value) {
+    const list = this.get(key, []);
+    this.put(key, [...Array.isArray(list) ? list : [list], value]);
+  }
+  increment(key, amount = 1) {
+    const value = Number(this.get(key, 0)) + amount;
+    this.put(key, value);
+    return value;
+  }
+  decrement(key, amount = 1) {
+    return this.increment(key, -amount);
+  }
+  forget(...keys) {
+    for (const key of keys) Arr.forget(this.#attributes, key);
+  }
+  /** Removes a key and returns its value. */
+  remove(key) {
+    return this.pull(key);
+  }
+  flush() {
+    this.#attributes = {};
+  }
+  /** Available on this request and the next one. */
+  flash(key, value = true) {
+    this.put(key, value);
+    this.push("_flash.new", key);
+    this.#removeFromOldFlashData([key]);
+  }
+  /** Available on this request only. */
+  now(key, value) {
+    this.put(key, value);
+    this.push("_flash.old", key);
+  }
+  /** Keeps all of last request's flash data for one more request. */
+  reflash() {
+    this.#mergeNewFlashes(this.get("_flash.old", []));
+    this.put("_flash.old", []);
+  }
+  /** Keeps some of last request's flash data for one more request. */
+  keep(...keys) {
+    this.#mergeNewFlashes(keys);
+    this.#removeFromOldFlashData(keys);
+  }
+  flashInput(input) {
+    this.flash("_old_input", input);
+  }
+  hasOldInput(key) {
+    const old2 = this.getOldInput(key);
+    return key === void 0 ? typeof old2 === "object" && old2 !== null && Object.keys(old2).length > 0 : old2 !== void 0 && old2 !== null;
+  }
+  getOldInput(key, defaultValue) {
+    return Arr.get(this.get("_old_input", {}), key, defaultValue);
+  }
+  token() {
+    return this.get("_token");
+  }
+  regenerateToken() {
+    this.put("_token", Str.random(40));
+  }
+  /** New session id and CSRF token. With destroy, the old record is deleted. */
+  async regenerate(destroy = false) {
+    await this.migrate(destroy);
+    this.regenerateToken();
+  }
+  /** New session id, keeping the data (and the CSRF token). With destroy, the old record is deleted. */
+  async migrate(destroy = false) {
+    if (destroy) await this.#handler.destroy(this.getId());
+    this.#handler.setExists?.(false);
+    this.setId(this.#generateSessionId());
+  }
+  /** Flushes the data and migrates to a new id, destroying the old record. */
+  async invalidate() {
+    this.flush();
+    await this.migrate(true);
+  }
+  previousUrl() {
+    return this.get("_previous.url");
+  }
+  setPreviousUrl(url) {
+    this.put("_previous.url", url);
+  }
+  isStarted() {
+    return this.#started;
+  }
+  getName() {
+    return this.#name;
+  }
+  setName(name) {
+    this.#name = name;
+  }
+  getId() {
+    return this.#id;
+  }
+  /** Invalid ids (anything but 40 alphanumerics) are replaced by a fresh one, so ids from cookies can't be forged. */
+  setId(id) {
+    this.#id = this.isValidId(id) ? id : this.#generateSessionId();
+  }
+  isValidId(id) {
+    return typeof id === "string" && /^[a-zA-Z0-9]{40}$/.test(id);
+  }
+  getHandler() {
+    return this.#handler;
+  }
+  #generateSessionId() {
+    return Str.random(40);
+  }
+  async #readFromHandler() {
+    let data = await this.#handler.read(this.getId());
+    if (data === "") return {};
+    if (this.#encrypter !== void 0) {
+      try {
+        data = this.#encrypter.decrypt(data, false);
+      } catch {
+        return {};
+      }
+    }
+    try {
+      const parsed = JSON.parse(data);
+      return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  #mergeNewFlashes(keys) {
+    this.put("_flash.new", unique([...this.get("_flash.new", []), ...keys]));
+  }
+  #removeFromOldFlashData(keys) {
+    this.put("_flash.old", this.get("_flash.old", []).filter((key) => !keys.includes(key)));
+  }
+};
+
+// handlers/ArraySessionHandler.ts
+var ArraySessionHandler = class {
+  constructor(minutes, clock = Date.now) {
+    this.minutes = minutes;
+    this.clock = clock;
+  }
+  minutes;
+  clock;
+  #storage = /* @__PURE__ */ new Map();
+  async read(id) {
+    const session2 = this.#storage.get(id);
+    if (session2 === void 0) return "";
+    return session2.time >= this.clock() - this.minutes * 6e4 ? session2.data : "";
+  }
+  async write(id, data) {
+    this.#storage.set(id, { data, time: this.clock() });
+  }
+  async destroy(id) {
+    this.#storage.delete(id);
+  }
+  async gc(maxLifetimeSeconds) {
+    const expiration = this.clock() - maxLifetimeSeconds * 1e3;
+    for (const [id, session2] of this.#storage) if (session2.time <= expiration) this.#storage.delete(id);
+  }
+  /** The raw stored payload (for tests and debugging). */
+  raw(id) {
+    return this.#storage.get(id)?.data;
+  }
+};
+
+// handlers/FileSessionHandler.ts
+import { mkdir, readdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import { join } from "path";
+import { Str as Str2 } from "@orieljs/support";
+var VALID_ID = /^[a-zA-Z0-9]{40}$/;
+var FileSessionHandler = class {
+  constructor(path, minutes, clock = Date.now) {
+    this.path = path;
+    this.minutes = minutes;
+    this.clock = clock;
+  }
+  path;
+  minutes;
+  clock;
+  async read(id) {
+    if (!VALID_ID.test(id)) return "";
+    const file = join(this.path, id);
+    try {
+      const { mtimeMs } = await stat(file);
+      if (mtimeMs < this.clock() - this.minutes * 6e4) return "";
+      return await readFile(file, "utf8");
+    } catch {
+      return "";
+    }
+  }
+  async write(id, data) {
+    if (!VALID_ID.test(id)) return;
+    await mkdir(this.path, { recursive: true });
+    const temporary = join(this.path, `.${id}.${Str2.random(8)}.tmp`);
+    await writeFile(temporary, data, "utf8");
+    await rename(temporary, join(this.path, id));
+  }
+  async destroy(id) {
+    if (VALID_ID.test(id)) await rm(join(this.path, id), { force: true });
+  }
+  async gc(maxLifetimeSeconds) {
+    const expiration = this.clock() - maxLifetimeSeconds * 1e3;
+    const files = await readdir(this.path).catch(() => []);
+    for (const file of files) {
+      if (!VALID_ID.test(file)) continue;
+      const { mtimeMs } = await stat(join(this.path, file)).catch(() => ({ mtimeMs: Number.POSITIVE_INFINITY }));
+      if (mtimeMs <= expiration) await rm(join(this.path, file), { force: true });
+    }
+  }
+};
+
+// handlers/DatabaseSessionHandler.ts
+import { AuthFactory, ExceptionHandler, HttpRequest } from "@orieljs/contracts";
+var DatabaseSessionHandler = class {
+  constructor(connection, table, minutes, container = () => void 0, clock = Date.now) {
+    this.connection = connection;
+    this.table = table;
+    this.minutes = minutes;
+    this.container = container;
+    this.clock = clock;
+  }
+  connection;
+  table;
+  minutes;
+  container;
+  clock;
+  #exists = false;
+  async read(id) {
+    const session2 = await this.#query().where("id", id).first();
+    if (session2 === void 0) return "";
+    this.#exists = true;
+    if (Number(session2.last_activity) < this.#now() - this.minutes * 60) return "";
+    return typeof session2.payload === "string" ? Buffer.from(session2.payload, "base64").toString("utf8") : "";
+  }
+  async write(id, data) {
+    const payload = await this.#payload(data);
+    if (this.#exists) {
+      await this.#query().where("id", id).update(payload);
+      return;
+    }
+    try {
+      await this.#query().insert({ id, ...payload });
+    } catch {
+      await this.#query().where("id", id).update(payload);
+    }
+    this.#exists = true;
+  }
+  async destroy(id) {
+    await this.#query().where("id", id).delete();
+  }
+  async gc(maxLifetimeSeconds) {
+    await this.#query().where("last_activity", "<=", this.#now() - maxLifetimeSeconds).delete();
+  }
+  /** Called by Store.migrate(): the next write inserts a new row. */
+  setExists(exists) {
+    this.#exists = exists;
+  }
+  #query() {
+    return this.connection().table(this.table);
+  }
+  #now() {
+    return Math.floor(this.clock() / 1e3);
+  }
+  async #payload(data) {
+    const payload = { payload: Buffer.from(data, "utf8").toString("base64"), last_activity: this.#now() };
+    const container = this.container();
+    if (container === void 0) return payload;
+    if (container.bound(HttpRequest)) {
+      const request = container.make(HttpRequest);
+      payload.ip_address = request.ip() ?? null;
+      payload.user_agent = (request.header("user-agent") ?? "").slice(0, 500);
+    }
+    if (container.bound(AuthFactory)) {
+      const guard = await this.#guard(container);
+      payload.user_id = guard?.hasUser() ? await guard.id() ?? null : null;
+    }
+    return payload;
+  }
+  /** The default guard, or undefined when it can't be built (the error is reported, not thrown). */
+  async #guard(container) {
+    try {
+      return container.make(AuthFactory).guard();
+    } catch (error) {
+      try {
+        if (container.bound(ExceptionHandler)) await container.make(ExceptionHandler).report(error);
+      } catch {
+      }
+      return void 0;
+    }
+  }
+};
+
+// handlers/CookieSessionHandler.ts
+var CookieSessionHandler = class {
+  constructor(jar, request, minutes, expireOnClose = false, clock = Date.now) {
+    this.jar = jar;
+    this.request = request;
+    this.minutes = minutes;
+    this.expireOnClose = expireOnClose;
+    this.clock = clock;
+  }
+  jar;
+  request;
+  minutes;
+  expireOnClose;
+  clock;
+  async read(id) {
+    const value = this.request()?.cookie(id);
+    if (value === void 0 || value === "") return "";
+    try {
+      const decoded = JSON.parse(value);
+      return typeof decoded.data === "string" && typeof decoded.expires === "number" && decoded.expires >= this.#now() ? decoded.data : "";
+    } catch {
+      return "";
+    }
+  }
+  async write(id, data) {
+    const jar = this.jar();
+    const value = JSON.stringify({ data, expires: this.#now() + this.minutes * 60 });
+    jar.queue(jar.make(id, value, this.expireOnClose ? 0 : this.minutes));
+  }
+  async destroy(id) {
+    const jar = this.jar();
+    jar.queue(jar.forget(id));
+  }
+  async gc() {
+  }
+  #now() {
+    return Math.floor(this.clock() / 1e3);
+  }
+};
+
+// handlers/RedisSessionHandler.ts
+var RedisSessionHandler = class {
+  constructor(client, minutes, prefix = "oriel_session:") {
+    this.client = client;
+    this.minutes = minutes;
+    this.prefix = prefix;
+  }
+  client;
+  minutes;
+  prefix;
+  async read(id) {
+    return await this.client.get(this.prefix + id) ?? "";
+  }
+  async write(id, data) {
+    await this.client.set(this.prefix + id, data, "EX", Math.max(1, this.minutes * 60));
+  }
+  async destroy(id) {
+    await this.client.del(this.prefix + id);
+  }
+  /** Redis expires keys itself. */
+  async gc() {
+  }
+};
+
+// SessionManager.ts
+import { Redis } from "ioredis";
+import {
+  ConfigRepository,
+  CookieJar,
+  DatabaseManager,
+  Encrypter,
+  HttpRequest as HttpRequest2
+} from "@orieljs/contracts";
+function makeRedisClient(config = {}) {
+  const options = {};
+  for (const key of ["host", "port", "password", "username", "db", "lazyConnect"]) if (config[key] !== void 0) options[key] = config[key];
+  return typeof config.url === "string" && config.url !== "" ? new Redis(config.url, options) : new Redis(options);
+}
+var SessionManager = class {
+  constructor(app) {
+    this.app = app;
+  }
+  app;
+  #custom = /* @__PURE__ */ new Map();
+  #shared = /* @__PURE__ */ new Map();
+  #redis;
+  getSessionConfig() {
+    return this.app.make(ConfigRepository).get("session", {});
+  }
+  getDefaultDriver() {
+    return this.getSessionConfig().driver ?? void 0;
+  }
+  /** Register a custom driver: Session.extend('mongo', (container, config) => new MongoHandler(...)). */
+  extend(driver, factory) {
+    this.#custom.set(driver, factory);
+    return this;
+  }
+  /** A new Store for `container` (the request or job scope). */
+  build(container, driver) {
+    const config = this.getSessionConfig();
+    const handler = this.handler(driver ?? config.driver ?? "array", container);
+    const encrypter = config.encrypt === true ? container.make(Encrypter) : void 0;
+    return new Store(config.cookie ?? "oriel_session", handler, void 0, encrypter);
+  }
+  handler(driver, container) {
+    const config = this.getSessionConfig();
+    const lifetime = config.lifetime ?? 120;
+    const custom = this.#custom.get(driver);
+    if (custom !== void 0) return custom(container, config);
+    switch (driver) {
+      case "array":
+        return this.#share("array", () => new ArraySessionHandler(lifetime));
+      case "file":
+        return this.#share("file", () => new FileSessionHandler(config.files ?? "storage/framework/sessions", lifetime));
+      case "redis":
+        return this.#share("redis", () => new RedisSessionHandler(this.redis(), lifetime));
+      case "database":
+        return new DatabaseSessionHandler(
+          () => container.make(DatabaseManager).connection(config.connection ?? void 0),
+          config.table ?? "sessions",
+          lifetime,
+          () => container
+        );
+      case "cookie":
+        return new CookieSessionHandler(
+          () => container.make(CookieJar),
+          () => container.bound(HttpRequest2) ? container.make(HttpRequest2) : void 0,
+          lifetime,
+          config.expire_on_close === true
+        );
+      default:
+        throw new Error(`Driver [${driver}] not supported.`);
+    }
+  }
+  /** The redis client for config('session.connection') (an entry of config('database.redis'), default 'default'). */
+  redis() {
+    if (this.#redis === void 0) {
+      const name = this.getSessionConfig().connection ?? "default";
+      this.#redis = makeRedisClient(this.app.make(ConfigRepository).get(`database.redis.${name}`, {}));
+    }
+    return this.#redis;
+  }
+  /** Closes the redis connection, if one was opened. */
+  async disconnect() {
+    await this.#redis?.quit();
+    this.#redis = void 0;
+  }
+  #share(driver, make) {
+    let handler = this.#shared.get(driver);
+    if (handler === void 0) {
+      handler = make();
+      this.#shared.set(driver, handler);
+    }
+    return handler;
+  }
+};
+
+// errors.ts
+var TokenMismatchError = class extends Error {
+  kind = "TokenMismatch";
+  status = 419;
+  name = "TokenMismatchError";
+  constructor(message = "CSRF token mismatch.") {
+    super(message);
+  }
+};
+
+// middleware/StartSession.ts
+import { randomInt } from "crypto";
+import { ConfigRepository as ConfigRepository2, Container, Session } from "@orieljs/contracts";
+import { inject } from "@orieljs/container";
+
+// middleware/cookies.ts
+function serialize(cookie) {
+  const parts = [`${cookie.name}=${encodeURIComponent(cookie.value)}`];
+  if (cookie.minutes > 0) {
+    parts.push(`Expires=${new Date(Date.now() + cookie.minutes * 6e4).toUTCString()}`, `Max-Age=${cookie.minutes * 60}`);
+  }
+  parts.push(`Path=${cookie.path}`);
+  if (cookie.domain !== void 0 && cookie.domain !== "") parts.push(`Domain=${cookie.domain}`);
+  if (cookie.secure) parts.push("Secure");
+  if (cookie.httpOnly) parts.push("HttpOnly");
+  parts.push(`SameSite=${cookie.sameSite.charAt(0).toUpperCase()}${cookie.sameSite.slice(1)}`);
+  return parts.join("; ");
+}
+function attachCookie(response, cookie) {
+  const headers = new Headers(response.headers);
+  headers.append("Set-Cookie", serialize(cookie));
+  return new Response(response.body, { status: response.status, statusText: response.statusText, headers });
+}
+function resolveSecure(secure, request) {
+  return secure ?? (request !== void 0 && request.url().startsWith("https:"));
+}
+function sessionCookie(config, options, request) {
+  return {
+    name: options.name,
+    value: options.value,
+    minutes: config.expire_on_close === true ? 0 : config.lifetime ?? 120,
+    path: config.path ?? "/",
+    ...config.domain ? { domain: config.domain } : {},
+    secure: resolveSecure(config.secure, request),
+    httpOnly: options.httpOnly,
+    sameSite: config.same_site ?? "lax"
+  };
+}
+
+// middleware/StartSession.ts
+var StartSession = class {
+  #container = inject(Container);
+  #config = inject(ConfigRepository2);
+  async handle(request, next) {
+    const config = this.#config.get("session", {});
+    if (config.driver === void 0 || config.driver === null) return next(request);
+    const session2 = this.#container.make(Session);
+    session2.setId?.(request.cookie(session2.getName?.() ?? config.cookie ?? "oriel_session"));
+    await session2.start();
+    await this.#collectGarbage(session2, config);
+    let response = await next(request);
+    this.#storeCurrentUrl(request, session2);
+    response = attachCookie(
+      response,
+      sessionCookie(
+        config,
+        {
+          name: session2.getName?.() ?? config.cookie ?? "oriel_session",
+          value: session2.getId(),
+          httpOnly: config.http_only ?? true
+        },
+        request
+      )
+    );
+    await session2.save();
+    return response;
+  }
+  /** Laravel's lottery: on average lottery[0] requests out of lottery[1] clean up expired sessions. */
+  async #collectGarbage(session2, config) {
+    const [chances, outOf] = config.lottery ?? [2, 100];
+    if (session2.getHandler !== void 0 && randomInt(1, outOf + 1) <= chances) {
+      await session2.getHandler().gc((config.lifetime ?? 120) * 60);
+    }
+  }
+  #storeCurrentUrl(request, session2) {
+    const prefetch = request.header("purpose") === "prefetch" || request.header("sec-purpose") === "prefetch";
+    if (request.isMethod("GET") && !request.ajax() && !prefetch) session2.setPreviousUrl(request.fullUrl());
+  }
+};
+
+// middleware/VerifyCsrfToken.ts
+import {
+  Application,
+  ConfigRepository as ConfigRepository3,
+  Container as Container2,
+  Encrypter as Encrypter2,
+  Session as Session2
+} from "@orieljs/contracts";
+import { inject as inject2 } from "@orieljs/container";
+import { Str as Str3 } from "@orieljs/support";
+
+// equals.ts
+import { timingSafeEqual } from "crypto";
+function equals(known, user) {
+  const a = Buffer.from(known);
+  const b = Buffer.from(user);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+
+// middleware/VerifyCsrfToken.ts
+var VerifyCsrfToken = class {
+  /** URIs (wildcards allowed) excluded from the check, in addition to config('http.csrf_except'). */
+  except = [];
+  /** Whether to send the XSRF-TOKEN cookie. */
+  addHttpCookie = true;
+  #container = inject2(Container2);
+  #config = inject2(ConfigRepository3);
+  async handle(request, next) {
+    if (this.isReading(request) || this.runningUnitTests() || this.inExceptArray(request) || this.tokensMatch(request)) {
+      const response = await next(request);
+      return this.addHttpCookie ? this.addCookieToResponse(response, request) : response;
+    }
+    throw new TokenMismatchError();
+  }
+  isReading(request) {
+    return ["HEAD", "GET", "OPTIONS"].includes(request.method().toUpperCase());
+  }
+  runningUnitTests() {
+    if (!this.#container.bound(Application)) return false;
+    const app = this.#container.make(Application);
+    return app.runningInConsole() && app.runningUnitTests();
+  }
+  inExceptArray(request) {
+    const configured = this.#config.get("http.csrf_except", []);
+    const patterns = [...this.except, ...Array.isArray(configured) ? configured.map(String) : []];
+    return patterns.some((pattern) => {
+      const trimmed = pattern === "/" ? pattern : pattern.replace(/^\/+|\/+$/g, "");
+      return Str3.is(trimmed, request.fullUrl()) || request.is(trimmed);
+    });
+  }
+  tokensMatch(request) {
+    const sessionToken = this.#container.make(Session2).token();
+    const token = this.getTokenFromRequest(request);
+    return typeof sessionToken === "string" && typeof token === "string" && token !== "" && equals(sessionToken, token);
+  }
+  getTokenFromRequest(request) {
+    const input = request.input("_token");
+    const token = (typeof input === "string" && input !== "" ? input : void 0) ?? request.header("X-CSRF-TOKEN");
+    if (token !== void 0 && token !== "") return token;
+    const header = request.header("X-XSRF-TOKEN");
+    if (header === void 0 || header === "" || !this.#container.bound(Encrypter2)) return void 0;
+    try {
+      return this.#container.make(Encrypter2).decrypt(header, false).slice(41);
+    } catch {
+      return void 0;
+    }
+  }
+  addCookieToResponse(response, request) {
+    const token = this.#container.make(Session2).token();
+    if (!token) return response;
+    const config = this.#config.get("session", {});
+    return attachCookie(
+      response,
+      sessionCookie(config, { name: "XSRF-TOKEN", value: token, httpOnly: false }, request)
+    );
+  }
+};
+
+// ViewErrorBag.ts
+var SessionMessageBag = class {
+  #messages;
+  constructor(messages = {}) {
+    this.#messages = messages;
+  }
+  has(key) {
+    return this.get(key).length > 0;
+  }
+  first(key) {
+    return key === void 0 ? this.all()[0] : this.get(key)[0];
+  }
+  get(key) {
+    const messages = Object.hasOwn(this.#messages, key) ? this.#messages[key] : void 0;
+    return Array.isArray(messages) ? messages.map(String) : [];
+  }
+  all() {
+    return Object.values(this.#messages).flatMap((messages) => Array.isArray(messages) ? messages.map(String) : []);
+  }
+  isEmpty() {
+    return this.count() === 0;
+  }
+  count() {
+    return this.all().length;
+  }
+  toObject() {
+    return Object.fromEntries(Object.keys(this.#messages).map((key) => [key, this.get(key)]));
+  }
+};
+function errorBagFrom(errors2, bag = "default") {
+  if (typeof errors2 !== "object" || errors2 === null) return new SessionMessageBag();
+  const messages = errors2[bag];
+  return new SessionMessageBag(typeof messages === "object" && messages !== null ? messages : {});
+}
+
+// facade.ts
+import { Application as Application2, Session as Session3 } from "@orieljs/contracts";
+import { currentContainer, inject as inject3 } from "@orieljs/container";
+import { facade } from "@orieljs/support";
+function scopeSession() {
+  const container = currentContainer();
+  if (container === void 0 || !container.bound(Session3)) return void 0;
+  if (container.bound(Application2) && container.make(Application2) === container) return void 0;
+  return container.make(Session3);
+}
+var SessionFacade = facade(Session3, {
+  extend: (driver, factory) => inject3(SessionManager).extend(driver, factory)
+});
+function session(key, defaultValue) {
+  const store = inject3(Session3);
+  if (key === void 0) return store;
+  if (typeof key === "string") return store.get(key, defaultValue);
+  store.put(key);
+  return void 0;
+}
+function old(key, defaultValue) {
+  const store = scopeSession();
+  return store === void 0 ? defaultValue : store.getOldInput(key, defaultValue);
+}
+function csrfToken() {
+  return inject3(Session3).token();
+}
+function errors(bag = "default") {
+  return errorBagFrom(scopeSession()?.get("errors"), bag);
+}
+
+// SessionServiceProvider.ts
+import { Router, Session as Session4 } from "@orieljs/contracts";
+import { ServiceProvider } from "@orieljs/support";
+var SessionServiceProvider = class extends ServiceProvider {
+  register() {
+    this.mergeConfigFrom(
+      {
+        driver: "database",
+        lifetime: 120,
+        expire_on_close: false,
+        encrypt: false,
+        files: this.app.storagePath("framework/sessions"),
+        connection: null,
+        table: "sessions",
+        lottery: [2, 100],
+        cookie: "oriel_session",
+        path: "/",
+        domain: null,
+        secure: null,
+        http_only: true,
+        same_site: "lax"
+      },
+      "session"
+    );
+    this.app.singleton(SessionManager, (container) => new SessionManager(container));
+    this.app.scoped(Session4, (container) => container.make(SessionManager).build(container));
+  }
+  boot() {
+    if (!this.app.bound(Router)) return;
+    this.app.make(Router).pushMiddlewareToGroup("web", StartSession).pushMiddlewareToGroup("web", VerifyCsrfToken);
+  }
+};
+export {
+  ArraySessionHandler,
+  CookieSessionHandler,
+  DatabaseSessionHandler,
+  FileSessionHandler,
+  RedisSessionHandler,
+  SessionFacade as Session,
+  SessionManager,
+  SessionMessageBag,
+  SessionServiceProvider,
+  StartSession,
+  Store,
+  TokenMismatchError,
+  VerifyCsrfToken,
+  csrfToken,
+  errorBagFrom,
+  errors,
+  makeRedisClient,
+  old,
+  session
+};
+//# sourceMappingURL=index.js.map