@adonisjs/session 7.7.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.d.ts

@@ -1 +1 @@
-export { SessionMiddlewareFactory } from './session_middleware_factory.js';
+export { SessionMiddlewareFactory } from './session_middleware_factory.ts';

package/build/factories/main.js

@@ -1,53 +1,29 @@
-import {
-  defineConfig
-} from "../chunk-Q24L5XPC.js";
-import "../chunk-V3OAEXMJ.js";
-import "../chunk-G7KFHA57.js";
-import {
-  SessionMiddleware
-} from "../chunk-6BSSM3HO.js";
-import "../chunk-XP3CBOXR.js";
-import "../chunk-TE5JP3SX.js";
-import "../chunk-5ECC6OWF.js";
-import "../chunk-PZ5AY32C.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());
-  }
+	#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
-};
-//# sourceMappingURL=main.js.map
+export { SessionMiddlewareFactory };

package/build/factories/session_middleware_factory.d.ts

@@ -1,7 +1,7 @@
 import { Emitter } from '@adonisjs/core/events';
 import type { EventsList } from '@adonisjs/core/types';
-import SessionMiddleware from '../src/session_middleware.js';
-import type { SessionConfig, SessionStoreFactory } from '../src/types.js';
+import SessionMiddleware from '../src/session_middleware.ts';
+import type { SessionConfig, SessionStoreFactory } from '../src/types.ts';
 /**
  * Exposes the API to create an instance of the session middleware
  * without additional plumbing

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.d.ts

@@ -6,10 +6,9 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-export * as errors from './src/errors.js';
-export { configure } from './configure.js';
-export { Session } from './src/session.js';
-export { stubsRoot } from './stubs/main.js';
-export { defineConfig, stores } from './src/define_config.js';
-export { SessionCollection } from './src/session_collection.js';
-export { ReadOnlyValuesStore, ValuesStore } from './src/values_store.js';
+export * as errors from './src/errors.ts';
+export { configure } from './configure.ts';
+export { Session } from './src/session.ts';
+export { stubsRoot } from './stubs/main.ts';
+export { defineConfig, stores } from './src/define_config.ts';
+export { ReadOnlyValuesStore, ValuesStore } from './src/values_store.ts';

package/build/index.js

@@ -1,33 +1,5 @@
-import {
-  configure,
-  defineConfig,
-  stores
-} from "./chunk-Q24L5XPC.js";
-import {
-  stubsRoot
-} from "./chunk-V3OAEXMJ.js";
-import {
-  SessionCollection
-} from "./chunk-G7KFHA57.js";
-import {
-  Session,
-  errors_exports
-} from "./chunk-XP3CBOXR.js";
-import {
-  ReadOnlyValuesStore,
-  ValuesStore
-} from "./chunk-TE5JP3SX.js";
-import "./chunk-5ECC6OWF.js";
-import "./chunk-PZ5AY32C.js";
-export {
-  ReadOnlyValuesStore,
-  Session,
-  SessionCollection,
-  ValuesStore,
-  configure,
-  defineConfig,
-  errors_exports as errors,
-  stores,
-  stubsRoot
-};
-//# sourceMappingURL=index.js.map
+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.d.ts

@@ -1,5 +1,5 @@
 import type { ApplicationService } from '@adonisjs/core/types';
-import type { Session } from '../src/session.js';
+import type { Session } from '../src/session.ts';
 /**
  * Events emitted by the session class
  */
@@ -23,7 +23,6 @@ declare module '@adonisjs/core/types' {
  * AdonisJS application
  */
 export default class SessionProvider {
-    #private;
     protected app: ApplicationService;
     constructor(app: ApplicationService);
     /**
@@ -32,7 +31,7 @@ export default class SessionProvider {
      */
     protected registerEdgePlugin(): Promise<void>;
     /**
-     * Registering bindings
+     * Registering muddleware
      */
     register(): void;
     /**

package/build/providers/session_provider.js

@@ -1,67 +1,30 @@
-import {
-  SessionCollection
-} from "../chunk-G7KFHA57.js";
-import {
-  SessionMiddleware
-} from "../chunk-6BSSM3HO.js";
-import "../chunk-XP3CBOXR.js";
-import "../chunk-TE5JP3SX.js";
-import "../chunk-5ECC6OWF.js";
-import "../chunk-PZ5AY32C.js";
-
-// providers/session_provider.ts
+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";
-import { RuntimeException } from "@poppinss/utils";
 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);
-    }
-  }
-  /**
-   * Resolves the session config from the config provider
-   */
-  async #resolveConfig() {
-    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 config;
-  }
-  /**
-   * Registering bindings
-   */
-  register() {
-    this.app.container.singleton(SessionMiddleware, async (resolver) => {
-      const config = await this.#resolveConfig();
-      const emitter = await resolver.make("emitter");
-      return new SessionMiddleware(config, emitter);
-    });
-    this.app.container.singleton(SessionCollection, async () => {
-      const config = await this.#resolveConfig();
-      return new SessionCollection(config);
-    });
-  }
-  /**
-   * Adding edge tags (if edge is installed)
-   */
-  async boot() {
-    await this.registerEdgePlugin();
-  }
+	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
-};
-//# sourceMappingURL=session_provider.js.map
+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 };