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

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.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-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
+		};
+	}
 };
+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';
+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;
 }>>;
 /**

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>;

package/build/src/plugins/edge.js

@@ -1,125 +1,75 @@
-import {
-  debug_default
-} from "../../chunk-SBOMJK4T.js";
-
-// src/plugins/edge.ts
-var edgePluginSession = (edge) => {
-  debug_default("registering session tags with edge");
-  edge.registerTag({
-    tagName: "flashMessage",
-    seekable: true,
-    block: true,
-    compile(parser, buffer, token) {
-      const expression = parser.utils.transformAst(
-        parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename),
-        token.filename,
-        parser
-      );
-      const key = parser.utils.stringify(expression);
-      buffer.writeStatement(
-        `if (state.flashMessages.has(${key})) {`,
-        token.filename,
-        token.loc.start.line
-      );
-      buffer.writeExpression(
-        `let $message = state.flashMessages.get(${key})`,
-        token.filename,
-        token.loc.start.line
-      );
-      parser.stack.defineScope();
-      parser.stack.defineVariable("$message");
-      token.children.forEach((child) => {
-        parser.processToken(child, buffer);
-      });
-      parser.stack.clearScope();
-      buffer.writeStatement(`}`, token.filename, token.loc.start.line);
-    }
-  });
-  edge.registerTag({
-    tagName: "inputError",
-    seekable: true,
-    block: true,
-    compile(parser, buffer, token) {
-      const expression = parser.utils.transformAst(
-        parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename),
-        token.filename,
-        parser
-      );
-      const key = parser.utils.stringify(expression);
-      buffer.writeStatement(
-        `if (!!state.flashMessages.get('inputErrorsBag', {})[${key}]) {`,
-        token.filename,
-        token.loc.start.line
-      );
-      buffer.writeExpression(
-        `let $messages = state.flashMessages.get('inputErrorsBag', {})[${key}]`,
-        token.filename,
-        token.loc.start.line
-      );
-      parser.stack.defineScope();
-      parser.stack.defineVariable("$messages");
-      token.children.forEach((child) => {
-        parser.processToken(child, buffer);
-      });
-      parser.stack.clearScope();
-      buffer.writeStatement(`}`, token.filename, token.loc.start.line);
-    }
-  });
-  edge.registerTag({
-    tagName: "error",
-    seekable: true,
-    block: true,
-    compile(parser, buffer, token) {
-      const expression = parser.utils.transformAst(
-        parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename),
-        token.filename,
-        parser
-      );
-      const key = parser.utils.stringify(expression);
-      buffer.writeStatement(
-        `if (state.flashMessages.has(['errorsBag', ${key}])) {`,
-        token.filename,
-        token.loc.start.line
-      );
-      buffer.writeExpression(
-        `let $message = state.flashMessages.get(['errorsBag', ${key}])`,
-        token.filename,
-        token.loc.start.line
-      );
-      parser.stack.defineScope();
-      parser.stack.defineVariable("$message");
-      token.children.forEach((child) => {
-        parser.processToken(child, buffer);
-      });
-      parser.stack.clearScope();
-      buffer.writeStatement(`}`, token.filename, token.loc.start.line);
-    }
-  });
-  edge.registerTag({
-    tagName: "errors",
-    seekable: true,
-    block: true,
-    compile(parser, buffer, token) {
-      buffer.writeStatement(
-        `if (state.flashMessages.has('errorsBag')) {`,
-        token.filename,
-        token.loc.start.line
-      );
-      buffer.writeExpression(
-        `let $messages = state.flashMessages.get('errorsBag')`,
-        token.filename,
-        token.loc.start.line
-      );
-      parser.stack.defineScope();
-      parser.stack.defineVariable("$messages");
-      token.children.forEach((child) => {
-        parser.processToken(child, buffer);
-      });
-      parser.stack.clearScope();
-      buffer.writeStatement(`}`, token.filename, token.loc.start.line);
-    }
-  });
-};
-export {
-  edgePluginSession
+import { t as debug_default } from "../../debug-Ba-0Cgn9.js";
+const edgePluginSession = (edge) => {
+	debug_default("registering session tags with edge");
+	edge.registerTag({
+		tagName: "flashMessage",
+		seekable: true,
+		block: true,
+		compile(parser, buffer, token) {
+			const expression = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+			const key = parser.utils.stringify(expression);
+			buffer.writeStatement(`if (state.flashMessages.has(${key})) {`, token.filename, token.loc.start.line);
+			buffer.writeExpression(`let $message = state.flashMessages.get(${key})`, token.filename, token.loc.start.line);
+			parser.stack.defineScope();
+			parser.stack.defineVariable("$message");
+			token.children.forEach((child) => {
+				parser.processToken(child, buffer);
+			});
+			parser.stack.clearScope();
+			buffer.writeStatement(`}`, token.filename, token.loc.start.line);
+		}
+	});
+	edge.registerTag({
+		tagName: "inputError",
+		seekable: true,
+		block: true,
+		compile(parser, buffer, token) {
+			const expression = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+			const key = parser.utils.stringify(expression);
+			buffer.writeStatement(`if (!!state.flashMessages.get('inputErrorsBag', {})[${key}]) {`, token.filename, token.loc.start.line);
+			buffer.writeExpression(`let $messages = state.flashMessages.get('inputErrorsBag', {})[${key}]`, token.filename, token.loc.start.line);
+			parser.stack.defineScope();
+			parser.stack.defineVariable("$messages");
+			token.children.forEach((child) => {
+				parser.processToken(child, buffer);
+			});
+			parser.stack.clearScope();
+			buffer.writeStatement(`}`, token.filename, token.loc.start.line);
+		}
+	});
+	edge.registerTag({
+		tagName: "error",
+		seekable: true,
+		block: true,
+		compile(parser, buffer, token) {
+			const expression = parser.utils.transformAst(parser.utils.generateAST(token.properties.jsArg, token.loc, token.filename), token.filename, parser);
+			const key = parser.utils.stringify(expression);
+			buffer.writeStatement(`if (state.flashMessages.has(['errorsBag', ${key}])) {`, token.filename, token.loc.start.line);
+			buffer.writeExpression(`let $message = state.flashMessages.get(['errorsBag', ${key}])`, token.filename, token.loc.start.line);
+			parser.stack.defineScope();
+			parser.stack.defineVariable("$message");
+			token.children.forEach((child) => {
+				parser.processToken(child, buffer);
+			});
+			parser.stack.clearScope();
+			buffer.writeStatement(`}`, token.filename, token.loc.start.line);
+		}
+	});
+	edge.registerTag({
+		tagName: "errors",
+		seekable: true,
+		block: true,
+		compile(parser, buffer, token) {
+			buffer.writeStatement(`if (state.flashMessages.has('errorsBag')) {`, token.filename, token.loc.start.line);
+			buffer.writeExpression(`let $messages = state.flashMessages.get('errorsBag')`, token.filename, token.loc.start.line);
+			parser.stack.defineScope();
+			parser.stack.defineVariable("$messages");
+			token.children.forEach((child) => {
+				parser.processToken(child, buffer);
+			});
+			parser.stack.clearScope();
+			buffer.writeStatement(`}`, token.filename, token.loc.start.line);
+		}
+	});
 };
+export { edgePluginSession };

package/build/src/plugins/japa/api_client.js

@@ -1,100 +1,80 @@
-import {
-  SessionClient
-} from "../../../chunk-Y566BNUT.js";
-import "../../../chunk-HAD4PFFM.js";
-import "../../../chunk-SBOMJK4T.js";
-
-// src/plugins/japa/api_client.ts
-import "@japa/plugin-adonisjs";
+import "../../../debug-Ba-0Cgn9.js";
+import "../../../values_store-smX0sQBJ.js";
+import { SessionClient } from "../../client.js";
+import { RuntimeException } from "@adonisjs/core/exceptions";
 import lodash from "@poppinss/utils/lodash";
 import { configProvider } from "@adonisjs/core";
-import { RuntimeException } from "@adonisjs/core/exceptions";
+import "@japa/plugin-adonisjs";
 import { ApiClient, ApiRequest, ApiResponse } from "@japa/api-client";
-var sessionApiClient = (app) => {
-  const pluginFn = async function() {
-    const sessionConfigProvider = app.config.get("session", {});
-    const config = await configProvider.resolve(app, sessionConfigProvider);
-    if (!config) {
-      throw new RuntimeException(
-        'Invalid "config/session.ts" file. Make sure you are using the "defineConfig" method'
-      );
-    }
-    ApiRequest.getter(
-      "sessionClient",
-      function() {
-        return new SessionClient(config.stores.memory());
-      },
-      true
-    );
-    ApiRequest.macro("withSession", function(data) {
-      this.sessionClient.merge(data);
-      return this;
-    });
-    ApiRequest.macro("withFlashMessages", function(data) {
-      this.sessionClient.flash(data);
-      return this;
-    });
-    ApiResponse.macro("session", function(key) {
-      return key ? lodash.get(this.sessionBag.values, key) : this.sessionBag.values;
-    });
-    ApiResponse.macro("flashMessages", function() {
-      return this.sessionBag.flashMessages;
-    });
-    ApiResponse.macro("flashMessage", function(key) {
-      return lodash.get(this.sessionBag.flashMessages, key);
-    });
-    ApiResponse.macro("assertSession", function(key, value) {
-      this.assert.property(this.session(), key);
-      if (value !== void 0) {
-        this.assert.deepEqual(this.session(key), value);
-      }
-    });
-    ApiResponse.macro("assertSessionMissing", function(key) {
-      this.assert.notProperty(this.session(), key);
-    });
-    ApiResponse.macro("assertFlashMessage", function(key, value) {
-      this.assert.property(this.flashMessages(), key);
-      if (value !== void 0) {
-        this.assert.deepEqual(this.flashMessage(key), value);
-      }
-    });
-    ApiResponse.macro("assertFlashMissing", function(key) {
-      this.assert.notProperty(this.flashMessages(), key);
-    });
-    ApiResponse.macro("assertHasValidationError", function(field) {
-      this.assert.property(this.flashMessage("errors"), field);
-    });
-    ApiResponse.macro("assertDoesNotHaveValidationError", function(field) {
-      this.assert.notProperty(this.flashMessage("errors"), field);
-    });
-    ApiResponse.macro("assertValidationError", function(field, message) {
-      this.assert.include(this.flashMessage("errors")?.[field] || [], message);
-    });
-    ApiResponse.macro("assertValidationErrors", function(field, messages) {
-      this.assert.deepEqual(this.flashMessage("errors")?.[field] || [], messages);
-    });
-    ApiClient.onRequest((request) => {
-      request.setup(async () => {
-        request.withCookie(config.cookieName, request.sessionClient.sessionId);
-        await request.sessionClient.commit();
-        return async (error) => {
-          if (error) {
-            await request.sessionClient.destroy();
-          }
-        };
-      });
-      request.teardown(async (response) => {
-        const sessionId = response.cookie(config.cookieName);
-        response.sessionBag = sessionId ? await response.request.sessionClient.load(sessionId.value) : {
-          values: {},
-          flashMessages: {}
-        };
-        await request.sessionClient.destroy(sessionId?.value);
-      });
-    });
-  };
-  return pluginFn;
-};
-export {
-  sessionApiClient
+const sessionApiClient = (app) => {
+	const pluginFn = async function() {
+		const sessionConfigProvider = app.config.get("session", {});
+		const config = await configProvider.resolve(app, sessionConfigProvider);
+		if (!config) throw new RuntimeException("Invalid \"config/session.ts\" file. Make sure you are using the \"defineConfig\" method");
+		ApiRequest.getter("sessionClient", function() {
+			return new SessionClient(config.stores.memory());
+		}, true);
+		ApiRequest.macro("withSession", function(data) {
+			this.sessionClient.merge(data);
+			return this;
+		});
+		ApiRequest.macro("withFlashMessages", function(data) {
+			this.sessionClient.flash(data);
+			return this;
+		});
+		ApiResponse.macro("session", function(key) {
+			return key ? lodash.get(this.sessionBag.values, key) : this.sessionBag.values;
+		});
+		ApiResponse.macro("flashMessages", function() {
+			return this.sessionBag.flashMessages;
+		});
+		ApiResponse.macro("flashMessage", function(key) {
+			return lodash.get(this.sessionBag.flashMessages, key);
+		});
+		ApiResponse.macro("assertSession", function(key, value) {
+			this.assert.property(this.session(), key);
+			if (value !== void 0) this.assert.deepEqual(this.session(key), value);
+		});
+		ApiResponse.macro("assertSessionMissing", function(key) {
+			this.assert.notProperty(this.session(), key);
+		});
+		ApiResponse.macro("assertFlashMessage", function(key, value) {
+			this.assert.property(this.flashMessages(), key);
+			if (value !== void 0) this.assert.deepEqual(this.flashMessage(key), value);
+		});
+		ApiResponse.macro("assertFlashMissing", function(key) {
+			this.assert.notProperty(this.flashMessages(), key);
+		});
+		ApiResponse.macro("assertHasValidationError", function(field) {
+			this.assert.property(this.flashMessage("errors"), field);
+		});
+		ApiResponse.macro("assertDoesNotHaveValidationError", function(field) {
+			this.assert.notProperty(this.flashMessage("errors"), field);
+		});
+		ApiResponse.macro("assertValidationError", function(field, message) {
+			this.assert.include(this.flashMessage("errors")?.[field] || [], message);
+		});
+		ApiResponse.macro("assertValidationErrors", function(field, messages) {
+			this.assert.deepEqual(this.flashMessage("errors")?.[field] || [], messages);
+		});
+		ApiClient.onRequest((request) => {
+			request.setup(async () => {
+				request.withCookie(config.cookieName, request.sessionClient.sessionId);
+				await request.sessionClient.commit();
+				return async (error) => {
+					if (error) await request.sessionClient.destroy();
+				};
+			});
+			request.teardown(async (response) => {
+				const sessionId = response.cookie(config.cookieName);
+				response.sessionBag = sessionId ? await response.request.sessionClient.load(sessionId.value) : {
+					values: {},
+					flashMessages: {}
+				};
+				await request.sessionClient.destroy(sessionId?.value);
+			});
+		});
+	};
+	return pluginFn;
 };
+export { sessionApiClient };