@arkstack/http 0.8.0 → 0.9.1

package/dist/app.d.ts

@@ -0,0 +1,7 @@
+import { ErrorBag } from '.'
+
+declare module 'clear-router' {
+  interface ClearHttpContext {
+    errors: ErrorBag
+  }
+} 

package/dist/index-BfxuYaPt.d.ts

@@ -0,0 +1,363 @@
+import * as _$clear_router0 from "clear-router";
+import { Request, Response } from "clear-router";
+import * as _$kanun from "kanun";
+import { RequestData } from "clear-router/types/basic";
+
+//#region src/Response.d.ts
+declare class Response$1<TBody = unknown> extends Response {
+  body: TBody;
+  readonly source?: unknown;
+  constructor(options?: {
+    statusCode?: number;
+    headers?: HeaderSource;
+    body?: TBody;
+    source?: unknown;
+  });
+  static from<TBody extends RequestData = RequestData>(source?: Response$1<TBody> | ResponseSource): Response$1<TBody> | undefined;
+  status(code: number): this;
+  header(name: string, value: string): this;
+  getHeaders(): HeaderMap;
+  json(body: TBody): any;
+  send(body: TBody): any;
+}
+//#endregion
+//#region src/session/FlashBag.d.ts
+declare class FlashBag<T = unknown> {
+  protected bag: Record<string, T>;
+  private sweepKeys;
+  constructor(items?: Record<string, T>);
+  put(key: string, value: T): this;
+  set(key: string, value: T): this;
+  get(key: string, defaultValue?: T): T;
+  has(key?: string | string[] | null): boolean;
+  any(): boolean;
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+  keys(): string[];
+  all(): {
+    [x: string]: T;
+  };
+  clear(key?: string | string[]): this;
+  forget(key: string): this;
+  markForSweep(keys?: string[]): this;
+  sweep(): this;
+  toJSON(): {
+    [x: string]: T;
+  };
+}
+//#endregion
+//#region src/session/types.d.ts
+type SessionDriverType = 'file' | 'cookie' | 'database' | SessionDriver;
+type SessionErrorValue = string | string[] | Error | unknown;
+type SessionErrorRecord = Record<string, SessionErrorValue>;
+interface SessionMessageProvider {
+  getMessageBag?: () => SessionMessageProvider;
+  getMessages?: () => SessionErrorRecord;
+  messagesRaw?: () => SessionErrorRecord;
+  toArray?: () => SessionErrorRecord;
+  all?: (...args: any[]) => SessionErrorRecord | string[];
+  errors?: (() => SessionErrorRecord | SessionMessageProvider) | SessionErrorRecord | SessionMessageProvider;
+}
+type SessionErrorSource = SessionErrorRecord | ErrorBag | SessionMessageProvider;
+interface SessionInitialState {
+  data?: Record<string, any>;
+  errors?: SessionErrorSource;
+  flash?: Record<string, any> | FlashBag;
+}
+type SessionPayload = {
+  data?: Record<string, any>;
+  errors?: SessionErrorRecord;
+  flash?: Record<string, any>;
+};
+type cookie_options = {
+  path?: string;
+  domain?: string;
+  httpOnly?: boolean;
+  secure?: boolean;
+  sameSite?: 'Strict' | 'Lax' | 'None';
+  maxAge?: number;
+  expires?: Date;
+};
+type HttpContextLike = Record<string, any>;
+type SessionDriverResult = {
+  id: string;
+  state?: SessionPayload;
+  save: (payload: SessionPayload) => void | Promise<void>;
+  destroy?: () => void | Promise<void>;
+};
+interface SessionDriver {
+  start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+type BaseSessionDriverOptions = {
+  cookie?: string;
+  secret?: string;
+  ttl?: number;
+  cookie_options?: cookie_options;
+};
+type DatabaseSessionDriverOptions = BaseSessionDriverOptions & {
+  table?: string;
+};
+type PersistentSessionConfig = {
+  driver?: SessionDriverType;
+  cookie?: string;
+  secret?: string;
+  ttl?: number;
+  cookie_options?: cookie_options;
+  file?: {
+    directory?: string;
+  };
+  database?: {
+    table?: string;
+  };
+};
+type SessionConfig = {
+  secret?: string;
+  driver?: SessionDriverType;
+  cookie?: string;
+  ttl?: number;
+  http_only?: boolean;
+  secure?: boolean;
+  same_site?: cookie_options['sameSite'];
+  path?: string;
+  table?: string;
+  directory?: string;
+};
+//#endregion
+//#region src/session/ErrorBag.d.ts
+declare class ErrorBag extends FlashBag<string[]> {
+  constructor(errors?: SessionErrorSource);
+  add(field: string, message: SessionErrorValue): this;
+  addIf(condition: boolean, field: string, message: SessionErrorValue): this;
+  merge(errors: SessionErrorSource): ErrorBag;
+  validation(error: unknown): ErrorBag;
+  keys(): string[];
+  get(field?: string): string[];
+  first(field?: string | null): string;
+  has(field?: string | string[] | null): boolean;
+  hasAny(fields: string | string[]): boolean;
+  missing(fields: string | string[]): boolean;
+  any(): boolean;
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+  count(): number;
+  all(): never;
+  unique(): unknown[];
+  clear(field?: string | string[]): this;
+  forget(field: string): this;
+  messagesRaw(): Record<string, string[]>;
+  getMessages(): Record<string, string[]>;
+  getMessageBag(): this;
+  toArray(): Record<string, string[]>;
+  toJSON(): Record<string, string[]>;
+}
+//#endregion
+//#region src/session/Session.d.ts
+declare class Session {
+  readonly errors: ErrorBag;
+  readonly flashBag: FlashBag;
+  readonly id?: string;
+  private data;
+  private persistent?;
+  private saveQueue;
+  constructor(initial?: SessionInitialState | Record<string, any> | Session, persistent?: SessionDriverResult);
+  private snapshot;
+  private queuePersist;
+  save(): Promise<this>;
+  destroy(): Promise<this>;
+  get<T = any>(key: string, defaultValue?: T): T;
+  put<T = any>(key: string, value: T): this;
+  set<T = any>(key: string, value: T): this;
+  has(key: string): boolean;
+  forget(key: string): this;
+  clear(): this;
+  all(): {
+    [x: string]: any;
+  };
+  flash<T = any>(key: string, value: T): this;
+  getFlash<T = any>(key: string, defaultValue?: T): T;
+  sweepFlash(): Promise<this>;
+  addError(field: string, message: SessionErrorValue): this;
+  addErrors(errors: SessionErrorRecord | ErrorBag): this;
+  addValidationErrors(error: unknown): this;
+  hasErrors(field?: string): boolean;
+  clearErrors(field?: string): this;
+  forView(): {
+    errors: ErrorBag;
+    flash: FlashBag<unknown>;
+  };
+  toJSON(): {
+    errors: Record<string, string[]>;
+    flash: {
+      [x: string]: unknown;
+    };
+  };
+}
+//#endregion
+//#region src/session/plugins.d.ts
+declare const arkstackHttpPlugin: _$clear_router0.ClearRouterPlugin<any, HttpContext>;
+declare const kanunSessionPlugin: _$kanun.ValidatorPlugin;
+//#endregion
+//#region src/session/helpers.d.ts
+declare const registerResponseFlashSweep: (target: unknown, session?: Session) => void;
+declare const attachViewState: (target: Record<PropertyKey, any>, session: Session) => void;
+declare const ensureSession: (ctx: unknown, initial?: SessionInitialState | Record<string, any>, persistent?: SessionDriverResult) => Session;
+declare const getSession: (ctx: unknown) => Session | undefined;
+//#endregion
+//#region src/session/config.d.ts
+declare const createSessionDriver: (config?: PersistentSessionConfig) => SessionDriver;
+declare const configureSession: (config: PersistentSessionConfig | SessionDriver) => SessionDriver;
+declare const getSessionDriver: () => SessionDriver;
+//#endregion
+//#region src/session/cookie.d.ts
+declare const generateSessionId: () => string;
+declare const signValue: (value: string, secret: string) => string;
+declare const encodeSignedValue: (value: string, secret: string) => string;
+declare const decodeSignedValue: (value: string | undefined, secret: string) => string | undefined;
+declare const encodeJson: (value: unknown) => string;
+declare const decodeJson: <T = unknown>(value: string | undefined) => T | undefined;
+declare const parseCookies: (header?: string | string[] | null) => Record<string, string>;
+declare const getCookie: (context: HttpContextLike, name: string) => string;
+declare const serializeCookie: (name: string, value: string, options?: cookie_options) => string;
+declare const setCookie: (context: HttpContextLike, name: string, value: string, options?: cookie_options) => string;
+//#endregion
+//#region src/session/encryption.d.ts
+declare const encryptSessionValue: (value: string, secret: string) => string;
+declare const decryptSessionValue: (payload: string | undefined, secret: string) => string | undefined;
+//#endregion
+//#region src/session/serialization.d.ts
+declare const encodeSessionPayload: (payload: SessionPayload & {
+  id?: string;
+}) => string;
+declare const decodeSessionPayload: <T extends SessionPayload & {
+  id?: string;
+} = SessionPayload & {
+  id?: string;
+}>(value: string | undefined) => T | undefined;
+//#endregion
+//#region src/session/drivers/BaseSessionDriver.d.ts
+declare abstract class BaseSessionDriver implements SessionDriver {
+  readonly cookie: string;
+  readonly secret: string;
+  readonly ttl?: number;
+  readonly cookie_options: cookie_options;
+  constructor(options?: BaseSessionDriverOptions);
+  protected readSessionId(context: HttpContextLike): string | undefined;
+  protected encryptPayload(value: string): string;
+  protected decryptPayload(value: string | undefined): string | undefined;
+  protected writeSessionId(context: HttpContextLike, id: string): void;
+  abstract start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+//#endregion
+//#region src/session/drivers/CookieSessionDriver.d.ts
+declare class CookieSessionDriver extends BaseSessionDriver {
+  start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+//#endregion
+//#region src/session/drivers/DatabaseSessionDriver.d.ts
+declare class DatabaseSessionDriver extends BaseSessionDriver {
+  readonly tableName: string;
+  constructor(options?: DatabaseSessionDriverOptions);
+  private table;
+  start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+//#endregion
+//#region src/session/drivers/FileSessionDriver.d.ts
+declare class FileSessionDriver extends BaseSessionDriver {
+  readonly directory: string;
+  constructor(options?: BaseSessionDriverOptions & {
+    directory?: string;
+  });
+  private path;
+  start(context: HttpContextLike): Promise<SessionDriverResult>;
+}
+//#endregion
+//#region src/types/Http.d.ts
+type HeaderValue = string | string[] | number | boolean | null | undefined;
+type HeaderMap = Record<string, string>;
+type HeaderSource = Headers | Record<string, HeaderValue>;
+type RequestSource<TUser = unknown> = {
+  headers?: HeaderSource;
+  method?: string;
+  url?: string;
+  originalUrl?: string;
+  path?: string;
+  ip?: string;
+  user?: TUser;
+  authToken?: string;
+  req?: RequestSource<TUser>;
+  request?: RequestSource<TUser>;
+};
+type ResponseSource = {
+  statusCode?: number;
+  status?: number | ((code: number) => unknown);
+  headers?: HeaderSource;
+  setHeader?: (name: string, value: string | string[]) => unknown;
+  getHeader?: (name: string) => string | string[] | number | undefined;
+  json?: (body: unknown) => unknown;
+  send?: (body: unknown) => unknown;
+  redirect?: (status: number, path: string) => unknown;
+};
+type RequestOptions<TUser = unknown> = {
+  headers?: HeaderSource;
+  method?: string;
+  url?: string;
+  path?: string;
+  ip?: string | null;
+  user?: TUser;
+  authToken?: string;
+  source?: unknown;
+};
+interface RequestHelper<TUser = unknown> {
+  (): Request$1;
+  <X extends string>(key: X): Request$1<TUser>['body'][X];
+}
+interface SessionHelper {
+  (): Session;
+  <X extends string>(key: X): any;
+}
+interface RedirectHelper {
+  (): Response$1;
+  (to?: string, status?: number): Response$1;
+}
+interface OldHelper {
+  (): Record<string, any>;
+  <T = any>(key: string, defaultValue?: T): T;
+}
+//#endregion
+//#region src/Request.d.ts
+declare class Request$1<TUser = unknown> extends Request {
+  readonly headers: HeaderMap;
+  readonly ip: string | null;
+  readonly source?: unknown;
+  user?: TUser;
+  authToken?: string;
+  constructor(options?: RequestOptions<TUser>);
+  static from<TUser = unknown>(source?: Request$1<TUser> | RequestSource<TUser>): Request$1<TUser> | undefined;
+  header(name: string): string;
+  bearerToken(): string | null;
+  setUser(user: TUser): this;
+}
+//#endregion
+//#region src/helpers.d.ts
+declare const unwrapRequestSource: <TUser>(source: RequestSource<TUser>) => RequestSource<TUser>;
+declare const makeHeaders: (headers?: HeaderSource) => Headers;
+declare const normalizeHeaders: (headers?: HeaderSource) => HeaderMap;
+declare const normalizeHeaderValue: (value: HeaderValue) => string | undefined;
+declare const isHeaders: (value: unknown) => value is Headers;
+declare const isRecord: (value: unknown) => value is Record<PropertyKey, any>;
+//#endregion
+//#region src/redirect.d.ts
+declare const redirectBackTarget: (fallback?: string) => string;
+declare const resolveRedirectTarget: (to?: string, fallback?: string) => string;
+declare const redirect: (to?: string, status?: number) => Response$1<unknown>;
+//#endregion
+//#region src/old.d.ts
+declare const old: <T = any>(key?: string, defaultValue?: T) => T;
+//#endregion
+//#region src/middlewares/web.d.ts
+declare const webMiddlewareKey: unique symbol;
+declare const web: (...args: any[]) => Promise<any>;
+declare const isWebRequest: (target: unknown) => boolean;
+//#endregion
+export { ErrorBag as $, encodeSessionPayload as A, serializeCookie as B, ResponseSource as C, CookieSessionDriver as D, DatabaseSessionDriver as E, encodeJson as F, getSessionDriver as G, signValue as H, encodeSignedValue as I, getSession as J, attachViewState as K, generateSessionId as L, encryptSessionValue as M, decodeJson as N, BaseSessionDriver as O, decodeSignedValue as P, Session as Q, getCookie as R, RequestSource as S, FileSessionDriver as T, configureSession as U, setCookie as V, createSessionDriver as W, arkstackHttpPlugin as X, registerResponseFlashSweep as Y, kanunSessionPlugin as Z, HeaderValue as _, redirect as a, SessionDriver as at, RequestHelper as b, isHeaders as c, SessionErrorRecord as ct, normalizeHeaderValue as d, SessionInitialState as dt, BaseSessionDriverOptions as et, normalizeHeaders as f, SessionMessageProvider as ft, HeaderSource as g, Response$1 as gt, HeaderMap as h, FlashBag as ht, old as i, SessionConfig as it, decryptSessionValue as j, decodeSessionPayload as k, isRecord as l, SessionErrorSource as lt, Request$1 as m, cookie_options as mt, web as n, HttpContextLike as nt, redirectBackTarget as o, SessionDriverResult as ot, unwrapRequestSource as p, SessionPayload as pt, ensureSession as q, webMiddlewareKey as r, PersistentSessionConfig as rt, resolveRedirectTarget as s, SessionDriverType as st, isWebRequest as t, DatabaseSessionDriverOptions as tt, makeHeaders as u, SessionErrorValue as ut, OldHelper as v, SessionHelper as w, RequestOptions as x, RedirectHelper as y, parseCookies as z };
+//# sourceMappingURL=index-BfxuYaPt.d.ts.map

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-import { C as Session, D as SessionErrorValue, E as SessionErrorSource, O as SessionInitialState, S as kanunSessionPlugin, T as SessionErrorRecord, _ as SessionHelper, a as normalizeHeaders, b as getSession, c as Request, d as HeaderValue, f as HttpContext, g as ResponseSource, h as RequestSource, i as normalizeHeaderValue, k as SessionMessageProvider, l as HeaderMap, m as RequestOptions, n as isRecord, o as unwrapRequestSource, p as RequestHelper, r as makeHeaders, s as Response, t as isHeaders, u as HeaderSource, v as attachViewState, w as ErrorBag, x as clearRouterSessionPlugin, y as ensureSession } from "./index-_YjYYnYr.js";
-export { ErrorBag, HeaderMap, HeaderSource, HeaderValue, HttpContext, Request, RequestHelper, RequestOptions, RequestSource, Response, ResponseSource, Session, SessionErrorRecord, SessionErrorSource, SessionErrorValue, SessionHelper, SessionInitialState, SessionMessageProvider, attachViewState, clearRouterSessionPlugin, ensureSession, getSession, isHeaders, isRecord, kanunSessionPlugin, makeHeaders, normalizeHeaderValue, normalizeHeaders, unwrapRequestSource };
+/// <reference path="./app.d.ts" />
+import { $ as ErrorBag, A as encodeSessionPayload, B as serializeCookie, C as ResponseSource, D as CookieSessionDriver, E as DatabaseSessionDriver, F as encodeJson, G as getSessionDriver, H as signValue, I as encodeSignedValue, J as getSession, K as attachViewState, L as generateSessionId, M as encryptSessionValue, N as decodeJson, O as BaseSessionDriver, P as decodeSignedValue, Q as Session, R as getCookie, S as RequestSource, T as FileSessionDriver, U as configureSession, V as setCookie, W as createSessionDriver, X as arkstackHttpPlugin, Y as registerResponseFlashSweep, Z as kanunSessionPlugin, _ as HeaderValue, a as redirect, at as SessionDriver, b as RequestHelper, c as isHeaders, ct as SessionErrorRecord, d as normalizeHeaderValue, dt as SessionInitialState, et as BaseSessionDriverOptions, f as normalizeHeaders, ft as SessionMessageProvider, g as HeaderSource, gt as Response, h as HeaderMap, ht as FlashBag, i as old, it as SessionConfig, j as decryptSessionValue, k as decodeSessionPayload, l as isRecord, lt as SessionErrorSource, m as Request, mt as cookie_options, n as web, nt as HttpContextLike, o as redirectBackTarget, ot as SessionDriverResult, p as unwrapRequestSource, pt as SessionPayload, q as ensureSession, r as webMiddlewareKey, rt as PersistentSessionConfig, s as resolveRedirectTarget, st as SessionDriverType, t as isWebRequest, tt as DatabaseSessionDriverOptions, u as makeHeaders, ut as SessionErrorValue, v as OldHelper, w as SessionHelper, x as RequestOptions, y as RedirectHelper, z as parseCookies } from "./index-BfxuYaPt.js";
+export { BaseSessionDriver, BaseSessionDriverOptions, CookieSessionDriver, DatabaseSessionDriver, DatabaseSessionDriverOptions, ErrorBag, FileSessionDriver, FlashBag, HeaderMap, HeaderSource, HeaderValue, HttpContextLike, OldHelper, PersistentSessionConfig, RedirectHelper, Request, RequestHelper, RequestOptions, RequestSource, Response, ResponseSource, Session, SessionConfig, SessionDriver, SessionDriverResult, SessionDriverType, SessionErrorRecord, SessionErrorSource, SessionErrorValue, SessionHelper, SessionInitialState, SessionMessageProvider, SessionPayload, arkstackHttpPlugin, attachViewState, configureSession, cookie_options, createSessionDriver, decodeJson, decodeSessionPayload, decodeSignedValue, decryptSessionValue, encodeJson, encodeSessionPayload, encodeSignedValue, encryptSessionValue, ensureSession, generateSessionId, getCookie, getSession, getSessionDriver, isHeaders, isRecord, isWebRequest, kanunSessionPlugin, makeHeaders, normalizeHeaderValue, normalizeHeaders, old, parseCookies, redirect, redirectBackTarget, registerResponseFlashSweep, resolveRedirectTarget, serializeCookie, setCookie, signValue, unwrapRequestSource, web, webMiddlewareKey };

package/dist/index.js

@@ -1,2 +1,50 @@
-import { a as getSession, c as Response, d as isRecord, f as makeHeaders, h as unwrapRequestSource, i as ensureSession, l as Request, m as normalizeHeaders, n as kanunSessionPlugin, o as Session, p as normalizeHeaderValue, r as attachViewState, s as ErrorBag, t as clearRouterSessionPlugin, u as isHeaders } from "./session-gK9S8Go9.js";
-export { ErrorBag, Request, Response, Session, attachViewState, clearRouterSessionPlugin, ensureSession, getSession, isHeaders, isRecord, kanunSessionPlugin, makeHeaders, normalizeHeaderValue, normalizeHeaders, unwrapRequestSource };
+import { A as registerResponseFlashSweep, B as normalizeHeaderValue, C as parseCookies, D as attachViewState, E as signValue, F as Response, H as unwrapRequestSource, I as Request, L as isHeaders, M as Session, N as ErrorBag, O as ensureSession, P as FlashBag, R as isRecord, S as getCookie, T as setCookie, V as normalizeHeaders, _ as decodeJson, a as kanunSessionPlugin, b as encodeSignedValue, c as getSessionDriver, d as CookieSessionDriver, f as BaseSessionDriver, g as encodeSessionPayload, h as decodeSessionPayload, i as arkstackHttpPlugin, j as old, k as getSession, l as FileSessionDriver, m as encryptSessionValue, n as redirectBackTarget, o as configureSession, p as decryptSessionValue, r as resolveRedirectTarget, s as createSessionDriver, t as redirect, u as DatabaseSessionDriver, v as decodeSignedValue, w as serializeCookie, x as generateSessionId, y as encodeJson, z as makeHeaders } from "./redirect-CZvhBHqO.js";
+//#region src/middlewares/web.ts
+const webMiddlewareKey = Symbol.for("arkstack:http:web");
+const markWebRequest = (target) => {
+	if (isRecord(target)) {
+		target[webMiddlewareKey] = true;
+		target.arkstackWeb = true;
+	}
+};
+const startWebSession = async (args) => {
+	const [first, second, third] = args;
+	const context = typeof third === "function" ? {
+		ctx: {
+			req: first,
+			res: second
+		},
+		req: first,
+		res: second
+	} : first;
+	if (!isRecord(context)) return;
+	const existingSession = context.httpSession || (context.session instanceof Session ? context.session : void 0) || (isRecord(context.req) ? context.req.httpSession : void 0) || (isRecord(context.context) ? context.context.httpSession : void 0);
+	if (existingSession instanceof Session) return existingSession;
+	const persistent = await getSessionDriver().start(context);
+	return ensureSession(context, persistent.state, persistent);
+};
+const web = async (...args) => {
+	const [first, second, third] = args;
+	markWebRequest(first);
+	markWebRequest(first?.context);
+	markWebRequest(first?.req);
+	if (isRecord(second)) markWebRequest(second);
+	const session = await startWebSession(args);
+	if (typeof third === "function") {
+		registerResponseFlashSweep({ res: second }, session);
+		return third();
+	}
+	if (typeof second === "function") {
+		const result = await second();
+		await session?.sweepFlash();
+		return result;
+	}
+};
+const isWebRequest = (target) => {
+	if (!isRecord(target)) return false;
+	return target[webMiddlewareKey] === true || target.arkstackWeb === true || isWebRequest(target.context) || isWebRequest(target.req);
+};
+//#endregion
+export { BaseSessionDriver, CookieSessionDriver, DatabaseSessionDriver, ErrorBag, FileSessionDriver, FlashBag, Request, Response, Session, arkstackHttpPlugin, attachViewState, configureSession, createSessionDriver, decodeJson, decodeSessionPayload, decodeSignedValue, decryptSessionValue, encodeJson, encodeSessionPayload, encodeSignedValue, encryptSessionValue, ensureSession, generateSessionId, getCookie, getSession, getSessionDriver, isHeaders, isRecord, isWebRequest, kanunSessionPlugin, makeHeaders, normalizeHeaderValue, normalizeHeaders, old, parseCookies, redirect, redirectBackTarget, registerResponseFlashSweep, resolveRedirectTarget, serializeCookie, setCookie, signValue, unwrapRequestSource, web, webMiddlewareKey };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/middlewares/web.ts"],"sourcesContent":["import { getSessionDriver } from '../session/config'\nimport { ensureSession, registerResponseFlashSweep } from '../session/helpers'\nimport { Session } from '../session/Session'\nimport { isRecord } from '../helpers'\n\nexport const webMiddlewareKey = Symbol.for('arkstack:http:web')\n\nconst markWebRequest = (target: unknown) => {\n    if (isRecord(target)) {\n        target[webMiddlewareKey] = true\n        target.arkstackWeb = true\n    }\n}\n\nconst startWebSession = async (args: any[]): Promise<Session | undefined> => {\n    const [first, second, third] = args\n    const context = typeof third === 'function'\n        ? {\n            ctx: { req: first, res: second },\n            req: first,\n            res: second,\n        }\n        : first\n\n    if (!isRecord(context)) {\n        return\n    }\n\n    const existingSession = context.httpSession\n        || (context.session instanceof Session ? context.session : undefined)\n        || (isRecord(context.req) ? context.req.httpSession : undefined)\n        || (isRecord(context.context) ? context.context.httpSession : undefined)\n\n    if (existingSession instanceof Session) {\n        return existingSession\n    }\n\n    const persistent = await getSessionDriver().start(context)\n\n    return ensureSession(context, persistent.state, persistent)\n}\n\nexport const web = async (...args: any[]) => {\n    const [first, second, third] = args\n\n    markWebRequest(first)\n    markWebRequest(first?.context)\n    markWebRequest(first?.req)\n\n    if (isRecord(second)) {\n        markWebRequest(second)\n    }\n\n    const session = await startWebSession(args)\n\n    if (typeof third === 'function') {\n        registerResponseFlashSweep({ res: second }, session)\n\n        return third()\n    }\n\n    if (typeof second === 'function') {\n        const result = await second()\n\n        await session?.sweepFlash()\n\n        return result\n    }\n}\n\nexport const isWebRequest = (target: unknown): boolean => {\n    if (!isRecord(target)) {\n        return false\n    }\n\n    return target[webMiddlewareKey] === true\n        || target.arkstackWeb === true\n        || isWebRequest(target.context)\n        || isWebRequest(target.req)\n}\n"],"mappings":";;AAKA,MAAa,mBAAmB,OAAO,IAAI,oBAAoB;AAE/D,MAAM,kBAAkB,WAAoB;CACxC,IAAI,SAAS,OAAO,EAAE;EAClB,OAAO,oBAAoB;EAC3B,OAAO,cAAc;;;AAI7B,MAAM,kBAAkB,OAAO,SAA8C;CACzE,MAAM,CAAC,OAAO,QAAQ,SAAS;CAC/B,MAAM,UAAU,OAAO,UAAU,aAC3B;EACE,KAAK;GAAE,KAAK;GAAO,KAAK;GAAQ;EAChC,KAAK;EACL,KAAK;EACR,GACC;CAEN,IAAI,CAAC,SAAS,QAAQ,EAClB;CAGJ,MAAM,kBAAkB,QAAQ,gBACxB,QAAQ,mBAAmB,UAAU,QAAQ,UAAU,KAAA,OACvD,SAAS,QAAQ,IAAI,GAAG,QAAQ,IAAI,cAAc,KAAA,OAClD,SAAS,QAAQ,QAAQ,GAAG,QAAQ,QAAQ,cAAc,KAAA;CAElE,IAAI,2BAA2B,SAC3B,OAAO;CAGX,MAAM,aAAa,MAAM,kBAAkB,CAAC,MAAM,QAAQ;CAE1D,OAAO,cAAc,SAAS,WAAW,OAAO,WAAW;;AAG/D,MAAa,MAAM,OAAO,GAAG,SAAgB;CACzC,MAAM,CAAC,OAAO,QAAQ,SAAS;CAE/B,eAAe,MAAM;CACrB,eAAe,OAAO,QAAQ;CAC9B,eAAe,OAAO,IAAI;CAE1B,IAAI,SAAS,OAAO,EAChB,eAAe,OAAO;CAG1B,MAAM,UAAU,MAAM,gBAAgB,KAAK;CAE3C,IAAI,OAAO,UAAU,YAAY;EAC7B,2BAA2B,EAAE,KAAK,QAAQ,EAAE,QAAQ;EAEpD,OAAO,OAAO;;CAGlB,IAAI,OAAO,WAAW,YAAY;EAC9B,MAAM,SAAS,MAAM,QAAQ;EAE7B,MAAM,SAAS,YAAY;EAE3B,OAAO;;;AAIf,MAAa,gBAAgB,WAA6B;CACtD,IAAI,CAAC,SAAS,OAAO,EACjB,OAAO;CAGX,OAAO,OAAO,sBAAsB,QAC7B,OAAO,gBAAgB,QACvB,aAAa,OAAO,QAAQ,IAC5B,aAAa,OAAO,IAAI"}