@adonisjs/session 7.7.0 → 8.0.0-next.1

package/build/session-CBqhcnvJ.js

@@ -0,0 +1,209 @@
+import { t as debug_default } from "./debug-Ba-0Cgn9.js";
+import { n as ValuesStore, t as ReadOnlyValuesStore } from "./values_store-smX0sQBJ.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
+});
+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);
+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));
+	}
+	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 { errors_exports as n, Session as t };

package/build/session-Cc1LPXRc.js

@@ -0,0 +1,107 @@
+import { t as debug_default } from "./debug-Ba-0Cgn9.js";
+import { InvalidArgumentsException } from "@adonisjs/core/exceptions";
+import { configProvider } from "@adonisjs/core";
+import string from "@adonisjs/core/helpers/string";
+const stubsRoot = import.meta.dirname;
+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");
+	});
+}
+var MemoryStore = class MemoryStore {
+	static sessions = /* @__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);
+	}
+	touch(_) {}
+};
+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-CNxCs957.js");
+			return (_, sessionConfig) => {
+				return new FileStore(config, sessionConfig.age);
+			};
+		});
+	},
+	redis: (config) => {
+		return configProvider.create(async (app) => {
+			const { RedisStore } = await import("./redis-Bcjum7z7.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-aLBno-zS.js");
+			return (ctx, sessionConfig) => {
+				return new CookieStore(sessionConfig.cookie, ctx);
+			};
+		});
+	},
+	dynamodb: (config) => {
+		return configProvider.create(async () => {
+			const { DynamoDBStore } = await import("./dynamodb-CU8BrQfU.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
+				});
+			};
+		});
+	}
+};
+export { stubsRoot as i, stores as n, configure as r, defineConfig as t };

package/build/session_middleware-CS0R7hmq.js

@@ -0,0 +1,27 @@
+import { t as Session } from "./session-CBqhcnvJ.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.d.ts

@@ -1,37 +1,73 @@
-import type { SessionData, SessionStoreContract } from './types.js';
+import type { SessionData, SessionStoreContract } from './types.ts';
 /**
- * Session client exposes the API to set session data as a client
+ * Session client exposes the API to set session data as a client.
+ * Useful for testing or programmatic session manipulation.
+ *
+ * @example
+ * const client = new SessionClient(store)
+ * client.merge({ userId: 123 })
+ * client.flash({ success: 'Login successful' })
+ * await client.commit()
  */
 export declare class SessionClient {
     #private;
     /**
-     * Session key for setting flash messages
+     * Session key used for storing flash messages
      */
     flashKey: string;
     /**
-     * Session to use when no explicit session id is
-     * defined
+     * Session ID to use when no explicit session id is defined
+     */
+    sessionId: `${string}-${string}-${string}-${string}-${string}`;
+    /**
+     * Creates a new session client
+     *
+     * @param store - Session store contract implementation
      */
-    sessionId: string;
     constructor(store: SessionStoreContract);
     /**
-     * Merge session data
+     * Merges session data with existing values
+     *
+     * @param values - Session data to merge
+     *
+     * @example
+     * client.merge({ userId: 123, theme: 'dark' })
      */
     merge(values: SessionData): this;
     /**
-     * Merge flash messages
+     * Merges flash messages with existing flash data
+     *
+     * @param values - Flash message data to merge
+     *
+     * @example
+     * client.flash({ success: 'Operation completed', info: 'Check your email' })
      */
     flash(values: SessionData): this;
     /**
-     * Commits data to the session store.
+     * Commits data to the session store
+     *
+     * @example
+     * await client.commit() // Saves all changes to the store
      */
     commit(): Promise<void>;
     /**
-     * Destroys the session data with the store
+     * Destroys the session data from the store
+     *
+     * @param sessionId - Optional session ID to destroy (defaults to current session)
+     *
+     * @example
+     * await client.destroy()           // Destroy current session
+     * await client.destroy('abc123')   // Destroy specific session
      */
     destroy(sessionId?: string): Promise<void>;
     /**
      * Loads session data from the session store
+     *
+     * @param sessionId - Optional session ID to load (defaults to current session)
+     *
+     * @example
+     * const { values, flashMessages } = await client.load()
+     * const data = await client.load('abc123') // Load specific session
      */
     load(sessionId?: string): Promise<{
         values: any;

package/build/src/client.js

@@ -1,10 +1,39 @@
-import {
-  SessionClient
-} from "../chunk-GCO66PQD.js";
-import "../chunk-TE5JP3SX.js";
-import "../chunk-5ECC6OWF.js";
-import "../chunk-PZ5AY32C.js";
-export {
-  SessionClient
+import { t as debug_default } from "../debug-Ba-0Cgn9.js";
+import { n as ValuesStore } from "../values_store-smX0sQBJ.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
+		};
+	}
 };
-//# sourceMappingURL=client.js.map
+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,31 +1,70 @@
 import type { ConfigProvider } from '@adonisjs/core/types';
 import type { CookieOptions } from '@adonisjs/core/types/http';
-import type { SessionConfig, FileStoreConfig, RedisStoreConfig, SessionStoreFactory, DynamoDBStoreConfig, DatabaseStoreConfig } from './types.js';
+import type { SessionConfig, FileStoreConfig, RedisStoreConfig, SessionStoreFactory, DynamoDBStoreConfig } 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 config with stores
+ * Resolved session configuration with all stores resolved
  */
 type ResolvedConfig<KnownStores extends Record<string, SessionStoreFactory>> = SessionConfig & {
     store: keyof KnownStores;
     stores: KnownStores;
-    cookie: Partial<CookieOptions>;
 };
 /**
- * Helper to normalize session config
+ * Defines and validates session configuration with store setup.
+ * Handles default values and store resolution.
+ *
+ * @param config - Session configuration with stores
+ *
+ * @example
+ * import { defineConfig, stores } from '@adonisjs/session'
+ *
+ * export default defineConfig({
+ *   enabled: true,
+ *   cookieName: 'adonis_session',
+ *   age: '2 hours',
+ *   store: 'cookie',
+ *   stores: {
+ *     cookie: stores.cookie(),
+ *     redis: stores.redis({ connection: 'main' })
+ *   }
+ * })
  */
-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;
 }>>;
 /**
- * Inbuilt stores to store the session data.
+ * Built-in session stores for different storage backends.
+ * Each store provides a different persistence mechanism for session data.
+ *
+ * @example
+ * import { stores } from '@adonisjs/session'
+ *
+ * // File store - stores on filesystem
+ * stores.file({ location: './tmp/sessions' })
+ *
+ * // Redis store - stores in Redis
+ * stores.redis({ connection: 'main' })
+ *
+ * // Cookie store - stores in encrypted cookies
+ * stores.cookie()
+ *
+ * // DynamoDB store - stores in AWS DynamoDB
+ * stores.dynamodb({ tableName: 'Sessions' })
  */
 export declare const stores: {
     file: (config: FileStoreConfig) => ConfigProvider<SessionStoreFactory>;
     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

@@ -1,13 +1,24 @@
 /**
- * Raised when session store is not mutable
+ * Error thrown when attempting to mutate a readonly session store.
+ * This occurs when trying to write to a session that was initiated in readonly mode.
+ *
+ * @example
+ * // This will throw E_SESSION_NOT_MUTABLE
+ * await session.initiate(true) // readonly mode
+ * session.put('key', 'value')  // Throws error
  */
-export declare const E_SESSION_NOT_MUTABLE: new (args?: any, options?: ErrorOptions) => import("@poppinss/utils").Exception;
+export declare const E_SESSION_NOT_MUTABLE: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;
 /**
- * Raised when session store has been initiated
+ * Error thrown when attempting to use session before it's been initiated.
+ * This usually means the session middleware hasn't been registered or called.
+ *
+ * @example
+ * // This will throw E_SESSION_NOT_READY
+ * const session = new Session(config, storeFactory, emitter, ctx)
+ * session.put('key', 'value') // Throws error - need to call initiate first
+ *
+ * // Correct usage:
+ * await session.initiate(false)
+ * session.put('key', 'value') // Works fine
  */
-export declare const E_SESSION_NOT_READY: new (args?: any, options?: ErrorOptions) => import("@poppinss/utils").Exception;
-/**
- * Raised when trying to use tagging with a store that
- * doesn't support tagging operations
- */
-export declare const E_SESSION_TAGGING_NOT_SUPPORTED: new (args?: any, options?: ErrorOptions) => import("@poppinss/utils").Exception;
+export declare const E_SESSION_NOT_READY: new (args?: any, options?: ErrorOptions) => import("@adonisjs/core/exceptions").Exception;

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

@@ -1,6 +1,20 @@
 import type { PluginFn } from 'edge.js/types';
 /**
- * The edge plugin for AdonisJS Session adds tags to read
- * flash messages
+ * The edge plugin for AdonisJS Session adds template tags to read flash messages.
+ * 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>;