@adonisjs/session 7.0.0-10 → 7.0.0-11

package/build/providers/session_provider.js

@@ -53,8 +53,8 @@ export default class SessionProvider {
         });
         const edge = await this.getEdge();
         if (edge) {
-            const { edgePluginAdonisJSSession } = await import('../src/edge_plugin_adonisjs_session.js');
-            edge.use(edgePluginAdonisJSSession);
+            const { edgePluginSession } = await import('../src/plugins/edge.js');
+            edge.use(edgePluginSession);
         }
     }
 }

package/build/src/client.d.ts

@@ -1,5 +1,4 @@
-import type { CookieClient } from '@adonisjs/core/http';
-import type { SessionConfig, SessionData, SessionDriverContract } from './types/main.js';
+import type { SessionData, SessionDriverContract } from './types/main.js';
 /**
  * Session client exposes the API to set session data as a client
  */
@@ -9,27 +8,33 @@ export declare class SessionClient {
      * Session key for setting flash messages
      */
     flashKey: string;
-    constructor(config: SessionConfig, driver: SessionDriverContract, cookieClient: CookieClient);
     /**
-     * Load session data from the driver
+     * Session to use when no explicit session id is
+     * defined
      */
-    load(cookies: Record<string, any>, sessionId?: string): Promise<{
-        sessionId: string;
-        session: SessionData;
-        flashMessages: SessionData;
-    }>;
+    sessionId: string;
+    constructor(driver: SessionDriverContract);
     /**
-     * Commits the session data to the session store and returns
-     * the session id and cookie name for it to be accessible
-     * by the server
+     * Merge session data
      */
-    commit(values: SessionData | null, flashMessages: SessionData | null, sessionId?: string): Promise<{
-        sessionId: string;
-        signedSessionId: string;
-        cookieName: string;
-    }>;
+    merge(values: SessionData): this;
     /**
-     * Clear the session store
+     * Merge flash messages
      */
-    forget(sessionId?: string): Promise<void>;
+    flash(values: SessionData): this;
+    /**
+     * Commits data to the session store.
+     */
+    commit(): Promise<void>;
+    /**
+     * Destroys the session data with the store
+     */
+    destroy(sessionId?: string): Promise<void>;
+    /**
+     * Loads session data from the session store
+     */
+    load(sessionId?: string): Promise<{
+        values: any;
+        flashMessages: any;
+    }>;
 }

package/build/src/client.js

@@ -7,75 +7,79 @@
  * file that was distributed with this source code.
  */
 import { cuid } from '@adonisjs/core/helpers';
+import debug from './debug.js';
 import { Store } from './store.js';
 /**
  * Session client exposes the API to set session data as a client
  */
 export class SessionClient {
     /**
-     * Session configuration
+     * Data store
      */
-    #config;
+    #store = new Store({});
+    /**
+     * Flash messages store
+     */
+    #flashMessagesStore = new Store({});
     /**
      * The session driver to use for reading and writing session data
      */
     #driver;
     /**
-     * Cookie client contract to sign and unsign cookies
+     * Session key for setting flash messages
      */
-    #cookieClient;
+    flashKey = '__flash__';
     /**
      * Session to use when no explicit session id is
      * defined
      */
-    #sessionId = cuid();
+    sessionId = cuid();
+    constructor(driver) {
+        this.#driver = driver;
+    }
     /**
-     * Session key for setting flash messages
+     * Merge session data
      */
-    flashKey = '__flash__';
-    constructor(config, driver, cookieClient) {
-        this.#config = config;
-        this.#driver = driver;
-        this.#cookieClient = cookieClient;
+    merge(values) {
+        this.#store.merge(values);
+        return this;
     }
     /**
-     * Load session data from the driver
+     * Merge flash messages
      */
-    async load(cookies, sessionId) {
-        const sessionIdCookie = cookies[this.#config.cookieName];
-        const sessId = sessionId || sessionIdCookie ? sessionIdCookie.value : this.#sessionId;
-        const contents = await this.#driver.read(sessId);
-        const store = new Store(contents);
-        const flashMessages = store.pull(this.flashKey, null);
-        return {
-            sessionId: sessId,
-            session: store.all(),
-            flashMessages,
-        };
+    flash(values) {
+        this.#flashMessagesStore.merge(values);
+        return this;
     }
     /**
-     * Commits the session data to the session store and returns
-     * the session id and cookie name for it to be accessible
-     * by the server
+     * Commits data to the session store.
      */
-    async commit(values, flashMessages, sessionId) {
-        const sessId = sessionId || this.#sessionId;
-        /**
-         * Persist session data to the store, alongside flash messages
-         */
-        if (values || flashMessages) {
-            await this.#driver.write(sessId, Object.assign({ [this.flashKey]: flashMessages }, values));
+    async commit() {
+        if (!this.#flashMessagesStore.isEmpty) {
+            this.#store.set(this.flashKey, this.#flashMessagesStore.toJSON());
+        }
+        debug('committing session data during api request');
+        if (!this.#store.isEmpty) {
+            this.#driver.write(this.sessionId, this.#store.toJSON());
         }
-        return {
-            sessionId: sessId,
-            signedSessionId: this.#cookieClient.sign(this.#config.cookieName, sessId),
-            cookieName: this.#config.cookieName,
-        };
     }
     /**
-     * Clear the session store
+     * Destroys the session data with the store
      */
-    async forget(sessionId) {
-        await this.#driver.destroy(sessionId || this.#sessionId);
+    async destroy(sessionId) {
+        debug('destroying session data during api request');
+        this.#driver.destroy(sessionId || this.sessionId);
+    }
+    /**
+     * Loads session data from the session store
+     */
+    async load(sessionId) {
+        const contents = await this.#driver.read(sessionId || this.sessionId);
+        const store = new Store(contents);
+        const flashMessages = store.pull(this.flashKey, {});
+        return {
+            values: store.all(),
+            flashMessages,
+        };
     }
 }

package/build/src/drivers_collection.d.ts

@@ -1,4 +1,3 @@
-import type { HttpContext } from '@adonisjs/core/http';
 import type { SessionDriversList } from './types/main.js';
 /**
  * A global collection of session drivers
@@ -16,7 +15,7 @@ declare class SessionDriversCollection {
     /**
      * Creates the driver instance with config
      */
-    create<Name extends keyof SessionDriversList>(name: Name, config: Parameters<SessionDriversList[Name]>[0], ctx: HttpContext): ReturnType<SessionDriversList[Name]>;
+    create<Name extends keyof SessionDriversList>(name: Name, ...args: Parameters<SessionDriversList[Name]>): ReturnType<SessionDriversList[Name]>;
 }
 declare const sessionDriversList: SessionDriversCollection;
 export default sessionDriversList;

package/build/src/drivers_collection.js

@@ -26,12 +26,12 @@ class SessionDriversCollection {
     /**
      * Creates the driver instance with config
      */
-    create(name, config, ctx) {
+    create(name, ...args) {
         const driverFactory = this.list[name];
         if (!driverFactory) {
             throw new RuntimeException(`Unknown session driver "${String(name)}". Make sure the driver is registered`);
         }
-        return driverFactory(config, ctx);
+        return driverFactory(args[0], args[1]);
     }
 }
 const sessionDriversList = new SessionDriversCollection();

package/build/src/{edge_plugin_adonisjs_session.d.ts → plugins/edge.d.ts}

@@ -3,4 +3,4 @@ import type { PluginFn } from 'edge.js/types';
  * The edge plugin for AdonisJS Session adds tags to read
  * flash messages
  */
-export declare const edgePluginAdonisJSSession: PluginFn<undefined>;
+export declare const edgePluginSession: PluginFn<undefined>;

package/build/src/{edge_plugin_adonisjs_session.js → plugins/edge.js}

@@ -6,12 +6,12 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import debug from './debug.js';
+import debug from '../debug.js';
 /**
  * The edge plugin for AdonisJS Session adds tags to read
  * flash messages
  */
-export const edgePluginAdonisJSSession = (edge) => {
+export const edgePluginSession = (edge) => {
     debug('registering session tags with edge');
     edge.registerTag({
         tagName: 'flashMessage',

package/build/src/plugins/japa/api_client.d.ts

@@ -0,0 +1,75 @@
+import type { PluginFn } from '@japa/runner/types';
+import type { ApplicationService } from '@adonisjs/core/types';
+import { SessionClient } from '../../client.js';
+import type { SessionData } from '../../types/main.js';
+declare module '@japa/api-client' {
+    interface ApiRequest {
+        sessionClient: SessionClient;
+        /**
+         * Make HTTP request along with the provided session data
+         */
+        withSession(values: SessionData): this;
+        /**
+         * Make HTTP request along with the provided session flash
+         * messages.
+         */
+        withFlashMessages(values: SessionData): this;
+    }
+    interface ApiResponse {
+        sessionBag: {
+            values: SessionData;
+            flashMessages: SessionData;
+        };
+        /**
+         * Get session data from the HTTP response
+         */
+        session(key?: string): any;
+        /**
+         * Get flash messages from the HTTP response
+         */
+        flashMessages(): SessionData;
+        /**
+         * Get flash messages for a specific key from the HTTP response
+         */
+        flashMessage(key: string): SessionData;
+        /**
+         * Assert session key-value pair exists
+         */
+        assertSession(key: string, value?: any): void;
+        /**
+         * Assert key is missing in session store
+         */
+        assertSessionMissing(key: string): void;
+        /**
+         * Assert flash message key-value pair exists
+         */
+        assertFlashMessage(key: string, value?: any): void;
+        /**
+         * Assert key is missing flash messages store
+         */
+        assertFlashMissing(key: string): void;
+        /**
+         * Assert flash messages has validation errors for
+         * the given field
+         */
+        assertHasValidationError(field: string): void;
+        /**
+         * Assert flash messages does not have validation errors
+         * for the given field
+         */
+        assertDoesNotHaveValidationError(field: string): void;
+        /**
+         * Assert error message for a given field
+         */
+        assertValidationError(field: string, message: string): void;
+        /**
+         * Assert all error messages for a given field
+         */
+        assertValidationErrors(field: string, messages: string[]): void;
+    }
+}
+/**
+ * Hooks AdonisJS Session with the Japa API Client
+ * plugin
+ */
+export declare const sessionApiClient: (app: ApplicationService) => PluginFn;

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

@@ -0,0 +1,145 @@
+/*
+ * @adonisjs/session
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import lodash from '@poppinss/utils/lodash';
+import { RuntimeException } from '@poppinss/utils';
+import { ApiClient, ApiRequest, ApiResponse } from '@japa/api-client';
+import { SessionClient } from '../../client.js';
+import { registerSessionDriver } from '../../helpers.js';
+import sessionDriversList from '../../drivers_collection.js';
+/**
+ * Hooks AdonisJS Session with the Japa API Client
+ * plugin
+ */
+export const sessionApiClient = (app) => {
+    const pluginFn = async function () {
+        const config = app.config.get('session');
+        /**
+         * Disallow usage of driver other than memory during testing
+         */
+        if (config.driver !== 'memory') {
+            throw new RuntimeException(`Cannot use session driver "${config.driver}" during testing. Switch to memory driver`);
+        }
+        /**
+         * Register the memory driver if not already registered
+         */
+        await registerSessionDriver(app, 'memory');
+        /**
+         * Stick an singleton session client to APIRequest. The session
+         * client is used to keep a track of session data we have
+         * to send during the request.
+         */
+        ApiRequest.getter('sessionClient', function () {
+            return new SessionClient(sessionDriversList.create('memory', config));
+        }, true);
+        /**
+         * Define session data
+         */
+        ApiRequest.macro('withSession', function (data) {
+            this.sessionClient.merge(data);
+            return this;
+        });
+        /**
+         * Define flash messages
+         */
+        ApiRequest.macro('withFlashMessages', function (data) {
+            this.sessionClient.flash(data);
+            return this;
+        });
+        /**
+         * Get session data
+         */
+        ApiResponse.macro('session', function (key) {
+            return key ? lodash.get(this.sessionBag.values, key) : this.sessionBag.values;
+        });
+        /**
+         * Get flash messages
+         */
+        ApiResponse.macro('flashMessages', function () {
+            return this.sessionBag.flashMessages;
+        });
+        ApiResponse.macro('flashMessage', function (key) {
+            return lodash.get(this.sessionBag.flashMessages, key);
+        });
+        /**
+         * Response session assertions
+         */
+        ApiResponse.macro('assertSession', function (key, value) {
+            this.assert.property(this.session(), key);
+            if (value !== undefined) {
+                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 !== undefined) {
+                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);
+        });
+        /**
+         * We define the hook using the "request.setup" method because we
+         * want to allow other Japa hooks to mutate the session store
+         * without running into race conditions
+         */
+        ApiClient.onRequest((request) => {
+            request.setup(async () => {
+                /**
+                 * Set cookie
+                 */
+                request.withCookie(config.cookieName, request.sessionClient.sessionId);
+                /**
+                 * Persist data
+                 */
+                await request.sessionClient.commit();
+                /**
+                 * Cleanup if request fails
+                 */
+                return async (error) => {
+                    if (error) {
+                        await request.sessionClient.destroy();
+                    }
+                };
+            });
+            request.teardown(async (response) => {
+                const sessionId = response.cookie(config.cookieName);
+                /**
+                 * Reading session data from the response cookie
+                 */
+                response.sessionBag = sessionId
+                    ? await response.request.sessionClient.load(sessionId.value)
+                    : {
+                        values: {},
+                        flashMessages: {},
+                    };
+                /**
+                 * Cleanup state
+                 */
+                await request.sessionClient.destroy(sessionId?.value);
+            });
+        });
+    };
+    return pluginFn;
+};

package/build/src/plugins/japa/browser_client.d.ts

@@ -0,0 +1,36 @@
+import type { PluginFn } from '@japa/runner/types';
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { CookieOptions as AdonisCookieOptions } from '@adonisjs/core/types/http';
+import { SessionClient } from '../../client.js';
+import type { SessionData } from '../../types/main.js';
+declare module 'playwright' {
+    interface BrowserContext {
+        sessionClient: SessionClient;
+        /**
+         * Initiate session. The session id cookie will be defined
+         * if missing
+         */
+        initiateSession(options?: Partial<AdonisCookieOptions>): Promise<void>;
+        /**
+         * Returns data from the session store
+         */
+        getSession(): Promise<any>;
+        /**
+         * Returns data from the session store
+         */
+        getFlashMessages(): Promise<any>;
+        /**
+         * Set session data
+         */
+        setSession(values: SessionData): Promise<void>;
+        /**
+         * Set flash messages
+         */
+        setFlashMessages(values: SessionData): Promise<void>;
+    }
+}
+/**
+ * Hooks AdonisJS Session with the Japa API Client
+ * plugin
+ */
+export declare const sessionBrowserClient: (app: ApplicationService) => PluginFn;

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

@@ -0,0 +1,119 @@
+/*
+ * @adonisjs/session
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { RuntimeException } from '@poppinss/utils';
+import { decoratorsCollection } from '@japa/browser-client';
+import { SessionClient } from '../../client.js';
+import { registerSessionDriver } from '../../helpers.js';
+import sessionDriversList from '../../drivers_collection.js';
+/**
+ * Transforming AdonisJS same site option to playwright
+ * same site option.
+ */
+function transformSameSiteOption(sameSite) {
+    if (!sameSite) {
+        return;
+    }
+    if (sameSite === true || sameSite === 'strict') {
+        return 'Strict';
+    }
+    if (sameSite === 'lax') {
+        return 'Lax';
+    }
+    if (sameSite === 'none') {
+        return 'None';
+    }
+}
+/**
+ * Transforming AdonisJS session config to playwright cookie options.
+ */
+function getSessionCookieOptions(config, cookieOptions) {
+    const options = { ...config.cookie, ...cookieOptions };
+    return {
+        ...options,
+        expires: undefined,
+        sameSite: transformSameSiteOption(options.sameSite),
+    };
+}
+/**
+ * Hooks AdonisJS Session with the Japa API Client
+ * plugin
+ */
+export const sessionBrowserClient = (app) => {
+    const pluginFn = async function () {
+        const config = app.config.get('session');
+        /**
+         * Disallow usage of driver other than memory during testing
+         */
+        if (config.driver !== 'memory') {
+            throw new RuntimeException(`Cannot use session driver "${config.driver}" during testing. Switch to memory driver`);
+        }
+        /**
+         * Register the memory driver if not already registered
+         */
+        await registerSessionDriver(app, 'memory');
+        decoratorsCollection.register({
+            context(context) {
+                /**
+                 * Reference to session client per browser context
+                 */
+                context.sessionClient = new SessionClient(sessionDriversList.create('memory', config));
+                /**
+                 * Initiating session store
+                 */
+                context.initiateSession = async function (options) {
+                    const sessionId = await context.getCookie(config.cookieName);
+                    if (sessionId) {
+                        context.sessionClient.sessionId = sessionId;
+                        return;
+                    }
+                    await context.setCookie(config.cookieName, context.sessionClient.sessionId, getSessionCookieOptions(config, options));
+                };
+                /**
+                 * Returns session data
+                 */
+                context.getSession = async function () {
+                    await context.initiateSession();
+                    const sessionData = await context.sessionClient.load();
+                    return sessionData.values;
+                };
+                /**
+                 * Returns flash messages from the data store
+                 */
+                context.getFlashMessages = async function () {
+                    await context.initiateSession();
+                    const sessionData = await context.sessionClient.load();
+                    return sessionData.flashMessages;
+                };
+                /**
+                 * Set session data
+                 */
+                context.setSession = async function (values) {
+                    await context.initiateSession();
+                    context.sessionClient.merge(values);
+                    await context.sessionClient.commit();
+                };
+                /**
+                 * Set flash messages
+                 */
+                context.setFlashMessages = async function (values) {
+                    await context.initiateSession();
+                    context.sessionClient.flash(values);
+                    await context.sessionClient.commit();
+                };
+                /**
+                 * Destroy session when context is closed
+                 */
+                context.on('close', async function () {
+                    await context.sessionClient.destroy();
+                });
+            },
+        });
+    };
+    return pluginFn;
+};

package/build/src/types/main.d.ts

@@ -102,5 +102,5 @@ export interface SessionDriversList {
     file: (config: SessionConfig, ctx: HttpContext) => FileDriver;
     cookie: (config: SessionConfig, ctx: HttpContext) => CookieDriver;
     redis: (config: SessionConfig, ctx: HttpContext) => RedisDriver;
-    memory: (config: SessionConfig, ctx: HttpContext) => MemoryDriver;
+    memory: (config: SessionConfig, ctx?: HttpContext) => MemoryDriver;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adonisjs/session",
   "description": "Session provider for AdonisJS",
-  "version": "7.0.0-10",
+  "version": "7.0.0-11",
   "engines": {
     "node": ">=18.16.0"
   },
@@ -22,6 +22,9 @@
     "./factories": "./build/factories/main.js",
     "./session_provider": "./build/providers/session_provider.js",
     "./session_middleware": "./build/src/session_middleware.js",
+    "./plugins/edge": "./build/src/plugins/edge.js",
+    "./plugins/api_client": "./build/src/plugins/japa/api_client.js",
+    "./plugins/browser_client": "./build/src/plugins/japa/browser_client.js",
     "./client": "./build/src/client.js",
     "./types": "./build/src/types.js"
   },
@@ -55,8 +58,8 @@
     "@japa/plugin-adonisjs": "^2.0.0-1",
     "@japa/runner": "^3.0.0-6",
     "@japa/snapshot": "^2.0.0-1",
-    "@swc/core": "^1.3.78",
-    "@types/node": "^20.5.1",
+    "@swc/core": "1.3.82",
+    "@types/node": "^20.6.0",
     "@types/set-cookie-parser": "^2.4.3",
     "@types/supertest": "^2.0.12",
     "@vinejs/vine": "^1.6.0",
@@ -65,11 +68,12 @@
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
     "edge.js": "^6.0.0-8",
-    "eslint": "^8.47.0",
+    "eslint": "^8.49.0",
+    "get-port": "^7.0.0",
     "github-label-sync": "^2.3.1",
     "husky": "^8.0.3",
     "np": "^8.0.4",
-    "playwright": "^1.37.1",
+    "playwright": "^1.38.0",
     "prettier": "^3.0.2",
     "set-cookie-parser": "^2.6.0",
     "supertest": "^6.3.3",
@@ -82,6 +86,8 @@
   "peerDependencies": {
     "@adonisjs/core": "^6.1.5-22",
     "@adonisjs/redis": "^8.0.0-10",
+    "@japa/api-client": "^2.0.0-0",
+    "@japa/browser-client": "^2.0.0-3",
     "edge.js": "^6.0.0-8"
   },
   "peerDependenciesMeta": {
@@ -90,6 +96,12 @@
     },
     "edge.js": {
       "optional": true
+    },
+    "@japa/api-client": {
+      "optional": true
+    },
+    "@japa/browser-client": {
+      "optional": true
     }
   },
   "author": "virk,adonisjs",