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

package/build/cookie-aLBno-zS.js

@@ -0,0 +1,31 @@
+import { t as debug_default } from "./debug-Ba-0Cgn9.js";
+var CookieStore = class {
+	#ctx;
+	#config;
+	constructor(config, ctx) {
+		this.#config = config;
+		this.#ctx = ctx;
+		debug_default("initiating cookie store %O", this.#config);
+	}
+	read(sessionId) {
+		debug_default("cookie store: reading session data %s", sessionId);
+		const cookieValue = this.#ctx.request.encryptedCookie(sessionId);
+		if (typeof cookieValue !== "object") return null;
+		return cookieValue;
+	}
+	write(sessionId, values) {
+		debug_default("cookie store: writing session data %s: %O", sessionId, values);
+		this.#ctx.response.encryptedCookie(sessionId, values, this.#config);
+	}
+	destroy(sessionId) {
+		debug_default("cookie store: destroying session data %s", sessionId);
+		if (this.#ctx.request.cookiesList()[sessionId]) this.#ctx.response.clearCookie(sessionId);
+	}
+	touch(sessionId) {
+		const value = this.read(sessionId);
+		debug_default("cookie store: touching session data %s", sessionId);
+		if (!value) return;
+		this.write(sessionId, value);
+	}
+};
+export { CookieStore };

package/build/debug-Ba-0Cgn9.js

@@ -0,0 +1,3 @@
+import { debuglog } from "node:util";
+var debug_default = debuglog("adonisjs:session");
+export { debug_default as t };

package/build/dynamodb-CU8BrQfU.js

@@ -0,0 +1,72 @@
+import { t as debug_default } from "./debug-Ba-0Cgn9.js";
+import string from "@adonisjs/core/helpers/string";
+import { MessageBuilder } from "@adonisjs/core/helpers";
+import { marshall, unmarshall } from "@aws-sdk/util-dynamodb";
+import { DeleteItemCommand, GetItemCommand, PutItemCommand, UpdateItemCommand } from "@aws-sdk/client-dynamodb";
+var DynamoDBStore = class {
+	#client;
+	#tableName;
+	#keyAttribute;
+	#ttlSeconds;
+	#valueAttribute = "value";
+	#expiresAtAttribute = "expires_at";
+	constructor(client, age, options) {
+		this.#client = client;
+		this.#tableName = options?.tableName ?? "Session";
+		this.#keyAttribute = options?.keyAttribute ?? "key";
+		this.#ttlSeconds = string.seconds.parse(age);
+		debug_default("initiating dynamodb store");
+	}
+	async read(sessionId) {
+		debug_default("dynamodb store: reading session data %s", sessionId);
+		const command = new GetItemCommand({
+			TableName: this.#tableName,
+			Key: marshall({ [this.#keyAttribute]: sessionId })
+		});
+		const response = await this.#client.send(command);
+		if (!response.Item) return null;
+		if (!response.Item[this.#valueAttribute]) return null;
+		const item = unmarshall(response.Item);
+		const contents = item[this.#valueAttribute];
+		const expiresAt = item[this.#expiresAtAttribute];
+		if (Date.now() > expiresAt) return null;
+		try {
+			return new MessageBuilder().verify(contents, sessionId);
+		} catch {
+			return null;
+		}
+	}
+	async write(sessionId, values) {
+		debug_default("dynamodb store: writing session data %s, %O", sessionId, values);
+		const message = new MessageBuilder().build(values, void 0, sessionId);
+		const command = new PutItemCommand({
+			TableName: this.#tableName,
+			Item: marshall({
+				[this.#keyAttribute]: sessionId,
+				[this.#valueAttribute]: message,
+				[this.#expiresAtAttribute]: Date.now() + this.#ttlSeconds * 1e3
+			})
+		});
+		await this.#client.send(command);
+	}
+	async destroy(sessionId) {
+		debug_default("dynamodb store: destroying session data %s", sessionId);
+		const command = new DeleteItemCommand({
+			TableName: this.#tableName,
+			Key: marshall({ [this.#keyAttribute]: sessionId })
+		});
+		await this.#client.send(command);
+	}
+	async touch(sessionId) {
+		debug_default("dynamodb store: touching session data %s", sessionId);
+		const command = new UpdateItemCommand({
+			TableName: this.#tableName,
+			Key: marshall({ [this.#keyAttribute]: sessionId }),
+			UpdateExpression: "SET #expires_at = :expires_at",
+			ExpressionAttributeNames: { "#expires_at": this.#expiresAtAttribute },
+			ExpressionAttributeValues: marshall({ ":expires_at": Date.now() + this.#ttlSeconds * 1e3 })
+		});
+		await this.#client.send(command);
+	}
+};
+export { DynamoDBStore };

package/build/factories/main.js

@@ -1,49 +1,29 @@
-import {
-  defineConfig
-} from "../chunk-MVBWJOEG.js";
-import {
-  SessionMiddleware
-} from "../chunk-DFXWYDMY.js";
-import "../chunk-SHD6OX52.js";
-import "../chunk-HAD4PFFM.js";
-import "../chunk-SBOMJK4T.js";
-
-// factories/session_middleware_factory.ts
+import "../session-CBqhcnvJ.js";
+import { t as defineConfig } from "../session-Cc1LPXRc.js";
+import "../debug-Ba-0Cgn9.js";
+import "../values_store-smX0sQBJ.js";
+import { t as SessionMiddleware } from "../session_middleware-CS0R7hmq.js";
 import { Emitter } from "@adonisjs/core/events";
 import { AppFactory } from "@adonisjs/core/factories/app";
 var SessionMiddlewareFactory = class {
-  #config = {
-    store: "memory",
-    stores: {}
-  };
-  #emitter;
-  #getApp() {
-    return new AppFactory().create(new URL("./", import.meta.url), () => {
-    });
-  }
-  #getEmitter() {
-    return this.#emitter || new Emitter(this.#getApp());
-  }
-  /**
-   * Merge custom options
-   */
-  merge(options) {
-    if (options.config) {
-      this.#config = options.config;
-    }
-    if (options.emitter) {
-      this.#emitter = options.emitter;
-    }
-    return this;
-  }
-  /**
-   * Creates an instance of the session middleware
-   */
-  async create() {
-    const config = await defineConfig(this.#config).resolver(this.#getApp());
-    return new SessionMiddleware(config, this.#getEmitter());
-  }
-};
-export {
-  SessionMiddlewareFactory
+	#config = {
+		store: "memory",
+		stores: {}
+	};
+	#emitter;
+	#getApp() {
+		return new AppFactory().create(new URL("./", import.meta.url), () => {});
+	}
+	#getEmitter() {
+		return this.#emitter || new Emitter(this.#getApp());
+	}
+	merge(options) {
+		if (options.config) this.#config = options.config;
+		if (options.emitter) this.#emitter = options.emitter;
+		return this;
+	}
+	async create() {
+		return new SessionMiddleware(await defineConfig(this.#config).resolver(this.#getApp()), this.#getEmitter());
+	}
 };
+export { SessionMiddlewareFactory };

package/build/file-CNxCs957.js

@@ -0,0 +1,71 @@
+import { t as debug_default } from "./debug-Ba-0Cgn9.js";
+import string from "@adonisjs/core/helpers/string";
+import { MessageBuilder } from "@adonisjs/core/helpers";
+import { dirname, join } from "node:path";
+import { access, mkdir, readFile, rm, stat, utimes, writeFile } from "node:fs/promises";
+var FileStore = class {
+	#config;
+	#age;
+	constructor(config, age) {
+		this.#config = config;
+		this.#age = age;
+		debug_default("initiating file store %O", this.#config);
+	}
+	#getFilePath(sessionId) {
+		return join(this.#config.location, `${sessionId}.txt`);
+	}
+	async #pathExists(path) {
+		try {
+			await access(path);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async #stats(path) {
+		try {
+			return await stat(path);
+		} catch {
+			return null;
+		}
+	}
+	async #outputFile(path, contents) {
+		const pathDirname = dirname(path);
+		if (!await this.#pathExists(pathDirname)) await mkdir(pathDirname, { recursive: true });
+		await writeFile(path, contents, "utf-8");
+	}
+	async read(sessionId) {
+		const filePath = this.#getFilePath(sessionId);
+		debug_default("file store: reading session data %", sessionId);
+		const stats = await this.#stats(filePath);
+		if (!stats) return null;
+		const sessionWillExpireAt = stats.mtimeMs + string.seconds.parse(this.#age) * 1e3;
+		if (Date.now() > sessionWillExpireAt) {
+			debug_default("file store: expired session data %s", sessionId);
+			return null;
+		}
+		let contents = await readFile(filePath, "utf-8");
+		contents = contents.trim();
+		if (!contents) return null;
+		try {
+			return new MessageBuilder().verify(contents, sessionId);
+		} catch {
+			return null;
+		}
+	}
+	async write(sessionId, values) {
+		debug_default("file store: writing session data %s: %O", sessionId, values);
+		const filePath = this.#getFilePath(sessionId);
+		const message = new MessageBuilder().build(values, void 0, sessionId);
+		await this.#outputFile(filePath, message);
+	}
+	async destroy(sessionId) {
+		debug_default("file store: destroying session data %s", sessionId);
+		await rm(this.#getFilePath(sessionId), { force: true });
+	}
+	async touch(sessionId) {
+		debug_default("file store: touching session data %s", sessionId);
+		await utimes(this.#getFilePath(sessionId), /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+	}
+};
+export { FileStore };

package/build/index.js

@@ -1,25 +1,5 @@
-import {
-  configure,
-  defineConfig,
-  stores,
-  stubsRoot
-} from "./chunk-MVBWJOEG.js";
-import {
-  Session,
-  errors_exports
-} from "./chunk-SHD6OX52.js";
-import {
-  ReadOnlyValuesStore,
-  ValuesStore
-} from "./chunk-HAD4PFFM.js";
-import "./chunk-SBOMJK4T.js";
-export {
-  ReadOnlyValuesStore,
-  Session,
-  ValuesStore,
-  configure,
-  defineConfig,
-  errors_exports as errors,
-  stores,
-  stubsRoot
-};
+import { n as errors_exports, t as Session } from "./session-CBqhcnvJ.js";
+import { i as stubsRoot, n as stores, r as configure, t as defineConfig } from "./session-Cc1LPXRc.js";
+import "./debug-Ba-0Cgn9.js";
+import { n as ValuesStore, t as ReadOnlyValuesStore } from "./values_store-smX0sQBJ.js";
+export { ReadOnlyValuesStore, Session, ValuesStore, configure, defineConfig, errors_exports as errors, stores, stubsRoot };

package/build/providers/session_provider.js

@@ -1,51 +1,30 @@
-import {
-  SessionMiddleware
-} from "../chunk-DFXWYDMY.js";
-import "../chunk-SHD6OX52.js";
-import "../chunk-HAD4PFFM.js";
-import "../chunk-SBOMJK4T.js";
-
-// providers/session_provider.ts
-import { configProvider } from "@adonisjs/core";
+import "../session-CBqhcnvJ.js";
+import "../debug-Ba-0Cgn9.js";
+import "../values_store-smX0sQBJ.js";
+import { t as SessionMiddleware } from "../session_middleware-CS0R7hmq.js";
 import { RuntimeException } from "@adonisjs/core/exceptions";
+import { configProvider } from "@adonisjs/core";
 var SessionProvider = class {
-  constructor(app) {
-    this.app = app;
-  }
-  /**
-   * Registers edge plugin when edge is installed
-   * in the user application.
-   */
-  async registerEdgePlugin() {
-    if (this.app.usingEdgeJS) {
-      const edge = await import("edge.js");
-      const { edgePluginSession } = await import("../src/plugins/edge.js");
-      edge.default.use(edgePluginSession);
-    }
-  }
-  /**
-   * Registering muddleware
-   */
-  register() {
-    this.app.container.singleton(SessionMiddleware, async (resolver) => {
-      const sessionConfigProvider = this.app.config.get("session", {});
-      const config = await configProvider.resolve(this.app, sessionConfigProvider);
-      if (!config) {
-        throw new RuntimeException(
-          'Invalid "config/session.ts" file. Make sure you are using the "defineConfig" method'
-        );
-      }
-      const emitter = await resolver.make("emitter");
-      return new SessionMiddleware(config, emitter);
-    });
-  }
-  /**
-   * Adding edge tags (if edge is installed)
-   */
-  async boot() {
-    await this.registerEdgePlugin();
-  }
-};
-export {
-  SessionProvider as default
+	constructor(app) {
+		this.app = app;
+	}
+	async registerEdgePlugin() {
+		if (this.app.usingEdgeJS) {
+			const edge = await import("edge.js");
+			const { edgePluginSession } = await import("../src/plugins/edge.js");
+			edge.default.use(edgePluginSession);
+		}
+	}
+	register() {
+		this.app.container.singleton(SessionMiddleware, async (resolver) => {
+			const sessionConfigProvider = this.app.config.get("session", {});
+			const config = await configProvider.resolve(this.app, sessionConfigProvider);
+			if (!config) throw new RuntimeException("Invalid \"config/session.ts\" file. Make sure you are using the \"defineConfig\" method");
+			return new SessionMiddleware(config, await resolver.make("emitter"));
+		});
+	}
+	async boot() {
+		await this.registerEdgePlugin();
+	}
 };
+export { SessionProvider as default };

package/build/redis-Bcjum7z7.js

@@ -0,0 +1,36 @@
+import { t as debug_default } from "./debug-Ba-0Cgn9.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");
+	}
+	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);
+	}
+};
+export { RedisStore };

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