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

package/build/commands/commands.json

@@ -0,0 +1 @@
+{"commands":[{"commandName":"make:session-table","description":"Create a migration for the sessions database table","help":"","namespace":"make","aliases":[],"flags":[],"args":[],"options":{},"filePath":"make_session_table.js"}],"version":1}

package/build/commands/main.d.ts

@@ -0,0 +1,4 @@
+import { CommandMetaData, Command } from '@adonisjs/ace/types';
+
+export function getMetaData(): Promise<CommandMetaData[]>
+export function getCommand(metaData: CommandMetaData): Promise<Command | null>

package/build/commands/main.js

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises'
+
+/**
+ * In-memory cache of commands after they have been loaded
+ */
+let commandsMetaData
+
+/**
+ * Reads the commands from the "./commands.json" file. Since, the commands.json
+ * file is generated automatically, we do not have to validate its contents
+ */
+export async function getMetaData() {
+  if (commandsMetaData) {
+    return commandsMetaData
+  }
+
+  const commandsIndex = await readFile(new URL('./commands.json', import.meta.url), 'utf-8')
+  commandsMetaData = JSON.parse(commandsIndex).commands
+
+  return commandsMetaData
+}
+
+/**
+ * Imports the command by lookingup its path from the commands
+ * metadata
+ */
+export async function getCommand(metaData) {
+  const commands = await getMetaData()
+  const command = commands.find(({ commandName }) => metaData.commandName === commandName)
+  if (!command) {
+    return null
+  }
+
+  const { default: commandConstructor } = await import(new URL(command.filePath, import.meta.url).href)
+  return commandConstructor
+}

package/build/commands/make_session_table.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '@adonisjs/core/ace';
+/**
+ * Command to create the sessions table migration
+ */
+export default class MakeSessionTable extends BaseCommand {
+    static commandName: string;
+    static description: string;
+    run(): Promise<void>;
+}

package/build/commands/make_session_table.js

@@ -0,0 +1,13 @@
+import { t as stubsRoot } from "../main-kn40V-hF.js";
+import { BaseCommand } from "@adonisjs/core/ace";
+var MakeSessionTable = class extends BaseCommand {
+	static commandName = "make:session-table";
+	static description = "Create a migration for the sessions database table";
+	async run() {
+		await (await this.createCodemods()).makeUsingStub(stubsRoot, "make/migration/sessions.stub", { migration: {
+			tableName: "sessions",
+			prefix: Date.now()
+		} });
+	}
+};
+export { MakeSessionTable as default };

package/build/cookie--JOJxrtW.js

@@ -0,0 +1,31 @@
+import { t as debug_default } from "./debug-BZVg83L1.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/database-vbrhCOPd.js

@@ -0,0 +1,86 @@
+import { t as debug_default } from "./debug-BZVg83L1.js";
+import string from "@poppinss/utils/string";
+import { MessageBuilder } from "@adonisjs/core/helpers";
+var DatabaseStore = class {
+	#client;
+	#tableName;
+	#ttlSeconds;
+	#gcProbability;
+	constructor(client, age, options) {
+		this.#client = client;
+		this.#tableName = options?.tableName ?? "sessions";
+		this.#ttlSeconds = string.seconds.parse(age);
+		this.#gcProbability = options?.gcProbability ?? 2;
+		debug_default("initiating database store");
+	}
+	async #collectGarbage() {
+		if (this.#gcProbability <= 0) return;
+		if (Math.random() * 100 < this.#gcProbability) {
+			debug_default("database store: running garbage collection");
+			const expiredBefore = new Date(Date.now());
+			await this.#client.from(this.#tableName).where("expires_at", "<=", expiredBefore).delete();
+		}
+	}
+	#parseSessionData(contents, sessionId) {
+		try {
+			return new MessageBuilder().verify(contents, sessionId);
+		} catch {
+			return null;
+		}
+	}
+	async read(sessionId) {
+		debug_default("database store: reading session data %s", sessionId);
+		const row = await this.#client.from(this.#tableName).where("id", sessionId).first();
+		if (!row) return null;
+		const expiresAt = new Date(row.expires_at).getTime();
+		if (Date.now() > expiresAt) {
+			await this.destroy(sessionId);
+			return null;
+		}
+		return this.#parseSessionData(row.data, sessionId);
+	}
+	async write(sessionId, values) {
+		debug_default("database store: writing session data %s, %O", sessionId, values);
+		const message = new MessageBuilder().build(values, void 0, sessionId);
+		const expiresAt = new Date(Date.now() + this.#ttlSeconds * 1e3);
+		await this.#client.insertQuery().table(this.#tableName).insert({
+			id: sessionId,
+			data: message,
+			expires_at: expiresAt
+		}).knexQuery.onConflict("id").merge(["data", "expires_at"]);
+		await this.#collectGarbage();
+	}
+	async destroy(sessionId) {
+		debug_default("database store: destroying session data %s", sessionId);
+		await this.#client.from(this.#tableName).where("id", sessionId).delete();
+	}
+	async touch(sessionId) {
+		debug_default("database store: touching session data %s", sessionId);
+		const expiresAt = new Date(Date.now() + this.#ttlSeconds * 1e3);
+		await this.#client.from(this.#tableName).where("id", sessionId).update({ expires_at: expiresAt });
+	}
+	async tag(sessionId, userId) {
+		debug_default("database store: tagging session %s with user %s", sessionId, userId);
+		const data = new MessageBuilder().build({}, void 0, sessionId);
+		const expiresAt = new Date(Date.now() + this.#ttlSeconds * 1e3);
+		await this.#client.insertQuery().table(this.#tableName).insert({
+			id: sessionId,
+			user_id: userId,
+			data,
+			expires_at: expiresAt
+		}).knexQuery.onConflict("id").merge(["user_id"]);
+	}
+	#rowToTaggedSession(row) {
+		const data = this.#parseSessionData(row.data, row.id);
+		if (!data) return null;
+		return {
+			id: row.id,
+			data
+		};
+	}
+	async tagged(userId) {
+		debug_default("database store: getting sessions tagged with user %s", userId);
+		return (await this.#client.from(this.#tableName).select("id", "data").where("user_id", userId).where("expires_at", ">", /* @__PURE__ */ new Date())).map((row) => this.#rowToTaggedSession(row)).filter((session) => session !== null);
+	}
+};
+export { DatabaseStore };

package/build/debug-BZVg83L1.js

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

package/build/dynamodb-BFVgTQSf.js

@@ -0,0 +1,72 @@
+import { t as debug_default } from "./debug-BZVg83L1.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,31 @@
-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-C9DdRahS.js";
+import "../main-kn40V-hF.js";
+import { t as defineConfig } from "../session-Cb9-DoMh.js";
+import "../debug-BZVg83L1.js";
+import "../values_store-CvR1Sn37.js";
+import "../session_collection-CvS5yIq6.js";
+import { t as SessionMiddleware } from "../session_middleware-gegOBxmm.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-BBU02j4z.js

@@ -0,0 +1,71 @@
+import { t as debug_default } from "./debug-BZVg83L1.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

@@ -11,4 +11,5 @@ 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 { SessionCollection } from './src/session_collection.ts';
 export { ReadOnlyValuesStore, ValuesStore } from './src/values_store.ts';

package/build/index.js

@@ -1,25 +1,7 @@
-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 { r as errors_exports, t as Session } from "./session-C9DdRahS.js";
+import { t as stubsRoot } from "./main-kn40V-hF.js";
+import { n as stores, r as configure, t as defineConfig } from "./session-Cb9-DoMh.js";
+import "./debug-BZVg83L1.js";
+import { n as ValuesStore, t as ReadOnlyValuesStore } from "./values_store-CvR1Sn37.js";
+import { t as SessionCollection } from "./session_collection-CvS5yIq6.js";
+export { ReadOnlyValuesStore, Session, SessionCollection, ValuesStore, configure, defineConfig, errors_exports as errors, stores, stubsRoot };

package/build/main-kn40V-hF.js

@@ -0,0 +1,2 @@
+const stubsRoot = import.meta.dirname;
+export { stubsRoot as t };

package/build/make/migration/sessions.stub

@@ -0,0 +1,26 @@
+{{{
+  exports({
+    to: app.makePath(
+      'database/migrations',
+      `${migration.prefix}_create_${migration.tableName}_table.ts`
+    )
+  })
+}}}
+import { BaseSchema } from '@adonisjs/lucid/schema'
+
+export default class extends BaseSchema {
+  protected tableName = '{{ migration.tableName }}'
+
+  async up() {
+    this.schema.createTable(this.tableName, (table) => {
+      table.string('id').primary()
+      table.text('data').notNullable()
+      table.string('user_id').nullable().index()
+      table.timestamp('expires_at').notNullable().index()
+    })
+  }
+
+  async down() {
+    this.schema.dropTable(this.tableName)
+  }
+}

package/build/providers/session_provider.d.ts

@@ -23,6 +23,7 @@ declare module '@adonisjs/core/types' {
  * AdonisJS application
  */
 export default class SessionProvider {
+    #private;
     protected app: ApplicationService;
     constructor(app: ApplicationService);
     /**
@@ -31,7 +32,7 @@ export default class SessionProvider {
      */
     protected registerEdgePlugin(): Promise<void>;
     /**
-     * Registering muddleware
+     * Registering bindings
      */
     register(): void;
     /**

package/build/providers/session_provider.js

@@ -1,51 +1,37 @@
-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-C9DdRahS.js";
+import "../debug-BZVg83L1.js";
+import "../values_store-CvR1Sn37.js";
+import { t as SessionCollection } from "../session_collection-CvS5yIq6.js";
+import { t as SessionMiddleware } from "../session_middleware-gegOBxmm.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);
+		}
+	}
+	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;
+	}
+	register() {
+		this.app.container.singleton(SessionMiddleware, async (resolver) => {
+			return new SessionMiddleware(await this.#resolveConfig(), await resolver.make("emitter"));
+		});
+		this.app.container.singleton(SessionCollection, async () => {
+			return new SessionCollection(await this.#resolveConfig());
+		});
+	}
+	async boot() {
+		await this.registerEdgePlugin();
+	}
 };
+export { SessionProvider as default };