@adonisjs/session 8.0.0-next.0 → 8.0.0-next.2

package/build/redis-D8D9UtiD.js

@@ -0,0 +1,91 @@
+import { t as debug_default } from "./debug-BZVg83L1.js";
+import string from "@adonisjs/core/helpers/string";
+import { MessageBuilder } from "@adonisjs/core/helpers";
+var RedisStore = class {
+	#connection;
+	#ttlSeconds;
+	constructor(connection, age) {
+		this.#connection = connection;
+		this.#ttlSeconds = string.seconds.parse(age);
+		debug_default("initiating redis store");
+	}
+	#processSessionResult(options) {
+		if (!options.contents) return {
+			session: null,
+			isInvalid: true
+		};
+		const data = this.#parseSessionData(options.contents, options.sessionId);
+		if (!data) return {
+			session: null,
+			isInvalid: true
+		};
+		return {
+			session: {
+				id: options.sessionId,
+				data
+			},
+			isInvalid: false
+		};
+	}
+	async #fetchSessionContents(sessionIds) {
+		const pipeline = this.#connection.pipeline();
+		sessionIds.forEach((sessionId) => pipeline.get(sessionId));
+		return (await pipeline.exec())?.map((result) => result[1]) ?? [];
+	}
+	async #cleanupInvalidSessions(userId, invalidSessionIds) {
+		if (invalidSessionIds.length === 0) return;
+		await this.#connection.srem(this.#getTagKey(userId), ...invalidSessionIds);
+	}
+	#getTagKey(userId) {
+		return `session_tag:${userId}`;
+	}
+	#parseSessionData(contents, sessionId) {
+		try {
+			return new MessageBuilder().verify(contents, sessionId);
+		} catch {
+			return null;
+		}
+	}
+	async read(sessionId) {
+		debug_default("redis store: reading session data %s", sessionId);
+		const contents = await this.#connection.get(sessionId);
+		if (!contents) return null;
+		try {
+			return new MessageBuilder().verify(contents, sessionId);
+		} catch {
+			return null;
+		}
+	}
+	async write(sessionId, values) {
+		debug_default("redis store: writing session data %s, %O", sessionId, values);
+		const message = new MessageBuilder().build(values, void 0, sessionId);
+		await this.#connection.setex(sessionId, this.#ttlSeconds, message);
+	}
+	async destroy(sessionId) {
+		debug_default("redis store: destroying session data %s", sessionId);
+		await this.#connection.del(sessionId);
+	}
+	async touch(sessionId) {
+		debug_default("redis store: touching session data %s", sessionId);
+		await this.#connection.expire(sessionId, this.#ttlSeconds);
+	}
+	async tag(sessionId, userId) {
+		debug_default("redis store: tagging session %s with user %s", sessionId, userId);
+		await this.#connection.sadd(this.#getTagKey(userId), sessionId);
+	}
+	async tagged(userId) {
+		debug_default("redis store: getting sessions tagged with user %s", userId);
+		const sessionIds = await this.#connection.smembers(this.#getTagKey(userId));
+		if (sessionIds.length === 0) return [];
+		const contents = await this.#fetchSessionContents(sessionIds);
+		const results = sessionIds.map((sessionId, index) => this.#processSessionResult({
+			sessionId,
+			contents: contents[index]
+		}));
+		const validSessions = results.filter((r) => r.session !== null).map((r) => r.session);
+		const invalidSessionIds = results.map((result, index) => result.isInvalid ? sessionIds[index] : null).filter((id) => id !== null);
+		await this.#cleanupInvalidSessions(userId, invalidSessionIds);
+		return validSessions;
+	}
+};
+export { RedisStore };

package/build/session-C9DdRahS.js

@@ -0,0 +1,215 @@
+import { t as debug_default } from "./debug-BZVg83L1.js";
+import { n as ValuesStore, t as ReadOnlyValuesStore } from "./values_store-CvR1Sn37.js";
+import "node:module";
+import { createError } from "@adonisjs/core/exceptions";
+import { randomUUID } from "node:crypto";
+import Macroable from "@poppinss/macroable";
+import lodash from "@poppinss/utils/lodash";
+var __defProp = Object.defineProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var errors_exports = /* @__PURE__ */ __export({
+	E_SESSION_NOT_MUTABLE: () => E_SESSION_NOT_MUTABLE,
+	E_SESSION_NOT_READY: () => E_SESSION_NOT_READY,
+	E_SESSION_TAGGING_NOT_SUPPORTED: () => E_SESSION_TAGGING_NOT_SUPPORTED
+});
+const E_SESSION_NOT_MUTABLE = createError("Session store is in readonly mode and cannot be mutated", "E_SESSION_NOT_MUTABLE", 500);
+const E_SESSION_NOT_READY = createError("Session store has not been initiated. Make sure you have registered the session middleware", "E_SESSION_NOT_READY", 500);
+const E_SESSION_TAGGING_NOT_SUPPORTED = createError("Session store does not support tagging. Use memory, redis, or database store instead", "E_SESSION_TAGGING_NOT_SUPPORTED", 500);
+var Session = class extends Macroable {
+	#store;
+	#emitter;
+	#ctx;
+	#readonly = false;
+	#valuesStore;
+	#sessionId;
+	#sessionIdFromCookie;
+	responseFlashMessages = new ValuesStore({});
+	flashMessages = new ValuesStore({});
+	flashKey = "__flash__";
+	get sessionId() {
+		return this.#sessionId;
+	}
+	get fresh() {
+		return this.#sessionIdFromCookie === void 0;
+	}
+	get readonly() {
+		return this.#readonly;
+	}
+	get initiated() {
+		return !!this.#valuesStore;
+	}
+	get hasRegeneratedSession() {
+		return !!(this.#sessionIdFromCookie && this.#sessionIdFromCookie !== this.#sessionId);
+	}
+	get isEmpty() {
+		return this.#valuesStore?.isEmpty ?? true;
+	}
+	get hasBeenModified() {
+		return this.#valuesStore?.hasBeenModified ?? false;
+	}
+	constructor(config, storeFactory, emitter, ctx) {
+		super();
+		this.config = config;
+		this.#ctx = ctx;
+		this.#emitter = emitter;
+		this.#store = storeFactory(ctx, config);
+		this.#sessionIdFromCookie = ctx.request.cookie(config.cookieName, void 0);
+		this.#sessionId = this.#sessionIdFromCookie || randomUUID();
+	}
+	#getFlashStore(mode) {
+		if (!this.#valuesStore) throw new E_SESSION_NOT_READY();
+		if (mode === "write" && this.readonly) throw new E_SESSION_NOT_MUTABLE();
+		return this.responseFlashMessages;
+	}
+	#getValuesStore(mode) {
+		if (!this.#valuesStore) throw new E_SESSION_NOT_READY();
+		if (mode === "write" && this.readonly) throw new E_SESSION_NOT_MUTABLE();
+		return this.#valuesStore;
+	}
+	async initiate(readonly) {
+		if (this.#valuesStore) return;
+		debug_default("initiating session (readonly: %s)", readonly);
+		this.#readonly = readonly;
+		this.#valuesStore = new ValuesStore(await this.#store.read(this.#sessionId));
+		if (this.has(this.flashKey)) {
+			debug_default("reading flash data");
+			if (this.#readonly) this.flashMessages.update(this.get(this.flashKey, null));
+			else this.flashMessages.update(this.pull(this.flashKey, null));
+		}
+		if ("view" in this.#ctx) this.#ctx.view.share({
+			session: new ReadOnlyValuesStore(this.#valuesStore.all()),
+			flashMessages: new ReadOnlyValuesStore(this.flashMessages.all()),
+			old: function(key, defaultValue) {
+				return this.flashMessages.get(key, defaultValue);
+			}
+		});
+		this.#emitter.emit("session:initiated", { session: this });
+	}
+	put(key, value) {
+		this.#getValuesStore("write").set(key, value);
+	}
+	has(key) {
+		return this.#getValuesStore("read").has(key);
+	}
+	get(key, defaultValue) {
+		return this.#getValuesStore("read").get(key, defaultValue);
+	}
+	all() {
+		return this.#getValuesStore("read").all();
+	}
+	forget(key) {
+		return this.#getValuesStore("write").unset(key);
+	}
+	pull(key, defaultValue) {
+		return this.#getValuesStore("write").pull(key, defaultValue);
+	}
+	increment(key, steps = 1) {
+		return this.#getValuesStore("write").increment(key, steps);
+	}
+	decrement(key, steps = 1) {
+		return this.#getValuesStore("write").decrement(key, steps);
+	}
+	clear() {
+		return this.#getValuesStore("write").clear();
+	}
+	flash(key, value) {
+		if (typeof key === "string") {
+			if (value) this.#getFlashStore("write").set(key, value);
+		} else this.#getFlashStore("write").merge(key);
+	}
+	flashErrors(errorsCollection) {
+		this.flash({ errorsBag: errorsCollection });
+	}
+	flashValidationErrors(error, withInput = true) {
+		const errorsBag = error.messages.reduce((result, message) => {
+			if (result[message.field]) result[message.field].push(message.message);
+			else result[message.field] = [message.message];
+			return result;
+		}, {});
+		if (withInput) this.flashExcept([
+			"_csrf",
+			"_method",
+			"password",
+			"password_confirmation"
+		]);
+		let summary = "The form could not be saved. Please check the errors below.";
+		if ("i18n" in this.#ctx) summary = this.#ctx.i18n.t(`errors.${error.code}`, { count: error.messages.length }, summary);
+		this.flashErrors({ [String(error.code)]: summary });
+		this.flash("inputErrorsBag", errorsBag);
+	}
+	flashAll() {
+		return this.#getFlashStore("write").set("input", this.#ctx.request.original());
+	}
+	flashExcept(keys) {
+		this.#getFlashStore("write").set("input", lodash.omit(this.#ctx.request.original(), keys));
+	}
+	flashOnly(keys) {
+		this.#getFlashStore("write").set("input", lodash.pick(this.#ctx.request.original(), keys));
+	}
+	reflash() {
+		this.#getFlashStore("write").set("reflashed", this.flashMessages.all());
+	}
+	reflashOnly(keys) {
+		this.#getFlashStore("write").set("reflashed", lodash.pick(this.flashMessages.all(), keys));
+	}
+	reflashExcept(keys) {
+		this.#getFlashStore("write").set("reflashed", lodash.omit(this.flashMessages.all(), keys));
+	}
+	async tag(userId) {
+		if (!("tag" in this.#store)) throw new E_SESSION_TAGGING_NOT_SUPPORTED();
+		await this.#store.tag(this.#sessionId, userId);
+	}
+	regenerate() {
+		this.#sessionId = randomUUID();
+	}
+	async commit() {
+		if (!this.#valuesStore || this.readonly) return;
+		if (!this.responseFlashMessages.isEmpty) {
+			const { input, reflashed, ...others } = this.responseFlashMessages.all();
+			this.put(this.flashKey, {
+				...reflashed,
+				...input,
+				...others
+			});
+		}
+		debug_default("committing session data");
+		this.#ctx.response.cookie(this.config.cookieName, this.#sessionId, this.config.cookie);
+		if (this.isEmpty) {
+			if (this.#sessionIdFromCookie) await this.#store.destroy(this.#sessionIdFromCookie);
+			this.#emitter.emit("session:committed", { session: this });
+			return;
+		}
+		if (!this.hasBeenModified) {
+			if (this.#sessionIdFromCookie && this.#sessionIdFromCookie !== this.#sessionId) {
+				await this.#store.destroy(this.#sessionIdFromCookie);
+				await this.#store.write(this.#sessionId, this.#valuesStore.toJSON());
+				this.#emitter.emit("session:migrated", {
+					fromSessionId: this.#sessionIdFromCookie,
+					toSessionId: this.sessionId,
+					session: this
+				});
+			} else await this.#store.touch(this.#sessionId);
+			this.#emitter.emit("session:committed", { session: this });
+			return;
+		}
+		if (this.#sessionIdFromCookie && this.#sessionIdFromCookie !== this.#sessionId) {
+			await this.#store.destroy(this.#sessionIdFromCookie);
+			await this.#store.write(this.#sessionId, this.#valuesStore.toJSON());
+			this.#emitter.emit("session:migrated", {
+				fromSessionId: this.#sessionIdFromCookie,
+				toSessionId: this.sessionId,
+				session: this
+			});
+		} else await this.#store.write(this.#sessionId, this.#valuesStore.toJSON());
+		this.#emitter.emit("session:committed", { session: this });
+	}
+};
+export { E_SESSION_TAGGING_NOT_SUPPORTED as n, errors_exports as r, Session as t };

package/build/session-Cb9-DoMh.js

@@ -0,0 +1,139 @@
+import { t as stubsRoot } from "./main-kn40V-hF.js";
+import { t as debug_default } from "./debug-BZVg83L1.js";
+import { InvalidArgumentsException, RuntimeException } from "@adonisjs/core/exceptions";
+import { configProvider } from "@adonisjs/core";
+import string from "@adonisjs/core/helpers/string";
+async function configure(command) {
+	const codemods = await command.createCodemods();
+	await codemods.makeUsingStub(stubsRoot, "config/session.stub", {});
+	await codemods.defineEnvVariables({ SESSION_DRIVER: "cookie" });
+	await codemods.defineEnvValidations({
+		variables: { SESSION_DRIVER: `Env.schema.enum(['cookie', 'memory'] as const)` },
+		leadingComment: "Variables for configuring session package"
+	});
+	await codemods.registerMiddleware("router", [{ path: "@adonisjs/session/session_middleware" }]);
+	await codemods.updateRcFile((rcFile) => {
+		rcFile.addProvider("@adonisjs/session/session_provider");
+		rcFile.addCommand("@adonisjs/session/commands");
+	});
+}
+var MemoryStore = class MemoryStore {
+	static sessions = /* @__PURE__ */ new Map();
+	static tags = /* @__PURE__ */ new Map();
+	read(sessionId) {
+		return MemoryStore.sessions.get(sessionId) || null;
+	}
+	write(sessionId, values) {
+		MemoryStore.sessions.set(sessionId, values);
+	}
+	destroy(sessionId) {
+		MemoryStore.sessions.delete(sessionId);
+		MemoryStore.tags.delete(sessionId);
+	}
+	touch(_) {}
+	tag(sessionId, userId) {
+		MemoryStore.tags.set(sessionId, userId);
+	}
+	tagged(userId) {
+		const sessions = [];
+		for (const [sessionId, tagUserId] of MemoryStore.tags) {
+			if (tagUserId !== userId) continue;
+			const data = MemoryStore.sessions.get(sessionId);
+			if (data) sessions.push({
+				id: sessionId,
+				data
+			});
+		}
+		return sessions;
+	}
+};
+function defineConfig(config) {
+	debug_default("processing session config %O", config);
+	if (!config.store) throw new InvalidArgumentsException("Missing \"store\" property inside the session config");
+	const { stores: stores$1, cookie, ...rest } = {
+		enabled: true,
+		age: "2h",
+		cookieName: "adonis_session",
+		clearWithBrowser: false,
+		...config
+	};
+	const cookieOptions = { ...cookie };
+	if (!rest.clearWithBrowser) {
+		cookieOptions.maxAge = string.seconds.parse(rest.age);
+		debug_default("computing maxAge \"%s\" for session id cookie", cookieOptions.maxAge);
+	} else {
+		cookieOptions.maxAge = void 0;
+		cookieOptions.expires = void 0;
+	}
+	return configProvider.create(async (app) => {
+		const storesNames = Object.keys(config.stores);
+		const storesList = { memory: () => new MemoryStore() };
+		for (let storeName of storesNames) {
+			const store = config.stores[storeName];
+			if (typeof store === "function") storesList[storeName] = store;
+			else storesList[storeName] = await store.resolver(app);
+		}
+		const transformedConfig = {
+			...rest,
+			cookie: cookieOptions,
+			stores: storesList
+		};
+		debug_default("transformed session config %O", transformedConfig);
+		return transformedConfig;
+	});
+}
+const stores = {
+	file: (config) => {
+		return configProvider.create(async () => {
+			const { FileStore } = await import("./file-BBU02j4z.js");
+			return (_, sessionConfig) => {
+				return new FileStore(config, sessionConfig.age);
+			};
+		});
+	},
+	redis: (config) => {
+		return configProvider.create(async (app) => {
+			const { RedisStore } = await import("./redis-D8D9UtiD.js");
+			const redis = await app.container.make("redis");
+			return (_, sessionConfig) => {
+				return new RedisStore(redis.connection(config.connection), sessionConfig.age);
+			};
+		});
+	},
+	cookie: () => {
+		return configProvider.create(async () => {
+			const { CookieStore } = await import("./cookie--JOJxrtW.js");
+			return (ctx, sessionConfig) => {
+				return new CookieStore(sessionConfig.cookie, ctx);
+			};
+		});
+	},
+	dynamodb: (config) => {
+		return configProvider.create(async () => {
+			const { DynamoDBStore } = await import("./dynamodb-BFVgTQSf.js");
+			const { DynamoDBClient } = await import("@aws-sdk/client-dynamodb");
+			const client = "clientConfig" in config ? new DynamoDBClient(config.clientConfig) : config.client;
+			return (_, sessionConfig) => {
+				return new DynamoDBStore(client, sessionConfig.age, {
+					tableName: config.tableName,
+					keyAttribute: config.keyAttribute
+				});
+			};
+		});
+	},
+	database: (config) => {
+		return configProvider.create(async (app) => {
+			const { DatabaseStore } = await import("./database-vbrhCOPd.js");
+			const db = await app.container.make("lucid.db");
+			const connectionName = config?.connectionName || db.primaryConnectionName;
+			if (!db.manager.has(connectionName)) throw new RuntimeException(`Invalid database connection "${connectionName}" referenced in session config`);
+			return (_, sessionConfig) => {
+				return new DatabaseStore(db.connection(connectionName), sessionConfig.age, {
+					tableName: config?.tableName,
+					gcProbability: config?.gcProbability
+				});
+			};
+		});
+	}
+};
+export { stores as n, configure as r, defineConfig as t };

package/build/session_collection-CvS5yIq6.js

@@ -0,0 +1,31 @@
+import { n as E_SESSION_TAGGING_NOT_SUPPORTED } from "./session-C9DdRahS.js";
+import { t as debug_default } from "./debug-BZVg83L1.js";
+var SessionCollection = class {
+	#store;
+	constructor(config) {
+		const storeFactory = config.stores[config.store];
+		this.#store = storeFactory(null, config);
+	}
+	supportsTagging() {
+		return "tag" in this.#store && "tagged" in this.#store;
+	}
+	async get(sessionId) {
+		debug_default("session collection: getting session data %s", sessionId);
+		return this.#store.read(sessionId);
+	}
+	async destroy(sessionId) {
+		debug_default("session collection: destroying session %s", sessionId);
+		return this.#store.destroy(sessionId);
+	}
+	async tag(sessionId, userId) {
+		debug_default("session collection: tagging session %s with user %s", sessionId, userId);
+		if (!this.supportsTagging()) throw new E_SESSION_TAGGING_NOT_SUPPORTED();
+		return this.#store.tag(sessionId, userId);
+	}
+	async tagged(userId) {
+		debug_default("session collection: getting sessions tagged with user %s", userId);
+		if (!this.supportsTagging()) throw new E_SESSION_TAGGING_NOT_SUPPORTED();
+		return this.#store.tagged(userId);
+	}
+};
+export { SessionCollection as t };

package/build/session_middleware-gegOBxmm.js

@@ -0,0 +1,27 @@
+import { t as Session } from "./session-C9DdRahS.js";
+import { ExceptionHandler } from "@adonisjs/core/http";
+const originalErrorHandler = ExceptionHandler.prototype.renderValidationErrorAsHTML;
+ExceptionHandler.macro("renderValidationErrorAsHTML", async function(error, ctx) {
+	if (ctx.session) {
+		const withInput = ctx.request.header("X-Inertia") ? false : true;
+		ctx.session.flashValidationErrors(error, withInput);
+		ctx.response.redirect("back", true);
+	} else return originalErrorHandler(error, ctx);
+});
+var SessionMiddleware = class {
+	#config;
+	#emitter;
+	constructor(config, emitter) {
+		this.#config = config;
+		this.#emitter = emitter;
+	}
+	async handle(ctx, next) {
+		if (!this.#config.enabled) return next();
+		ctx.session = new Session(this.#config, this.#config.stores[this.#config.store], this.#emitter, ctx);
+		await ctx.session.initiate(false);
+		const response = await next();
+		await ctx.session.commit();
+		return response;
+	}
+};
+export { SessionMiddleware as t };

package/build/src/client.js

@@ -1,8 +1,39 @@
-import {
-  SessionClient
-} from "../chunk-Y566BNUT.js";
-import "../chunk-HAD4PFFM.js";
-import "../chunk-SBOMJK4T.js";
-export {
-  SessionClient
+import { t as debug_default } from "../debug-BZVg83L1.js";
+import { n as ValuesStore } from "../values_store-CvR1Sn37.js";
+import { randomUUID } from "node:crypto";
+var SessionClient = class {
+	#valuesStore = new ValuesStore({});
+	#flashMessagesStore = new ValuesStore({});
+	#store;
+	flashKey = "__flash__";
+	sessionId = randomUUID();
+	constructor(store) {
+		this.#store = store;
+	}
+	merge(values) {
+		this.#valuesStore.merge(values);
+		return this;
+	}
+	flash(values) {
+		this.#flashMessagesStore.merge(values);
+		return this;
+	}
+	async commit() {
+		if (!this.#flashMessagesStore.isEmpty) this.#valuesStore.set(this.flashKey, this.#flashMessagesStore.toJSON());
+		debug_default("committing session data during api request");
+		if (!this.#valuesStore.isEmpty) this.#store.write(this.sessionId, this.#valuesStore.toJSON());
+	}
+	async destroy(sessionId) {
+		debug_default("destroying session data during api request");
+		this.#store.destroy(sessionId || this.sessionId);
+	}
+	async load(sessionId) {
+		const store = new ValuesStore(await this.#store.read(sessionId || this.sessionId));
+		const flashMessages = store.pull(this.flashKey, {});
+		return {
+			values: store.all(),
+			flashMessages
+		};
+	}
 };
+export { SessionClient };

package/build/src/debug.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("util").DebugLogger;
+declare const _default: import("node:util").DebugLogger;
 export default _default;

package/build/src/define_config.d.ts

@@ -1,13 +1,23 @@
 import type { ConfigProvider } from '@adonisjs/core/types';
 import type { CookieOptions } from '@adonisjs/core/types/http';
-import type { SessionConfig, FileStoreConfig, RedisStoreConfig, SessionStoreFactory, DynamoDBStoreConfig } from './types.ts';
+import type { SessionConfig, FileStoreConfig, RedisStoreConfig, SessionStoreFactory, DynamoDBStoreConfig, DatabaseStoreConfig } from './types.ts';
+type ConfigInput<KnownStores extends Record<string, SessionStoreFactory | ConfigProvider<SessionStoreFactory>>> = Partial<SessionConfig> & {
+    store: keyof KnownStores | 'memory';
+    stores: KnownStores;
+    /**
+     * Whether to clear the session cookie when the browser is closed.
+     * When true, creates a session cookie that expires on browser close.
+     * Note: Persisted session data continues to exist until it expires.
+     */
+    clearWithBrowser?: boolean;
+    cookie?: Omit<Partial<CookieOptions>, 'maxAge' | 'expires'>;
+};
 /**
  * Resolved session configuration with all stores resolved
  */
 type ResolvedConfig<KnownStores extends Record<string, SessionStoreFactory>> = SessionConfig & {
     store: keyof KnownStores;
     stores: KnownStores;
-    cookie: Partial<CookieOptions>;
 };
 /**
  * Defines and validates session configuration with store setup.
@@ -29,10 +39,7 @@ type ResolvedConfig<KnownStores extends Record<string, SessionStoreFactory>> = S
  *   }
  * })
  */
-export declare function defineConfig<KnownStores extends Record<string, SessionStoreFactory | ConfigProvider<SessionStoreFactory>>>(config: Partial<SessionConfig> & {
-    store: keyof KnownStores | 'memory';
-    stores: KnownStores;
-}): ConfigProvider<ResolvedConfig<{
+export declare function defineConfig<KnownStores extends Record<string, SessionStoreFactory | ConfigProvider<SessionStoreFactory>>>(config: ConfigInput<KnownStores>): ConfigProvider<ResolvedConfig<{
     [K in keyof KnownStores]: SessionStoreFactory;
 }>>;
 /**
@@ -59,5 +66,6 @@ export declare const stores: {
     redis: (config: RedisStoreConfig) => ConfigProvider<SessionStoreFactory>;
     cookie: () => ConfigProvider<SessionStoreFactory>;
     dynamodb: (config: DynamoDBStoreConfig) => ConfigProvider<SessionStoreFactory>;
+    database: (config?: DatabaseStoreConfig) => ConfigProvider<SessionStoreFactory>;
 };
 export {};

package/build/src/errors.d.ts

@@ -22,3 +22,12 @@ export declare const E_SESSION_NOT_MUTABLE: new (args?: any, options?: ErrorOpti
  * session.put('key', 'value') // Works fine
  */
 export declare const E_SESSION_NOT_READY: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
+/**
+ * Error thrown when attempting to use tagging features with a store that doesn't support it.
+ * Only Memory, Redis, and Database stores support session tagging.
+ *
+ * @example
+ * // This will throw E_SESSION_TAGGING_NOT_SUPPORTED when using cookie store
+ * const sessions = await sessionCollection.tagged(userId)
+ */
+export declare const E_SESSION_TAGGING_NOT_SUPPORTED: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;

package/build/src/plugins/edge.d.ts

@@ -1,16 +1,20 @@
 import type { PluginFn } from 'edge.js/types';
 /**
  * The edge plugin for AdonisJS Session adds template tags to read flash messages.
- * Provides @flashMessage, @inputError, @error, and @errors tags for templates.
+ * Provides @flashMessage, @inputError, @error, and \@errors tags for templates.
  *
  * @example
+ * ```ts
  * // Register the plugin with Edge
  * import { edgePluginSession } from '@adonisjs/session/plugins/edge'
  * edge.use(edgePluginSession)
+ * ```
  *
+ * ```edge
  * // Use in templates
  * @flashMessage('success')
  *   <div class="alert alert-success">{{ $message }}</div>
  * @end
+ * ```
  */
 export declare const edgePluginSession: PluginFn<undefined>;