@adonisjs/session 7.0.0-10 → 7.0.0-12

package/build/factories/session_middleware_factory.d.ts

@@ -1,7 +1,7 @@
 import { Emitter } from '@adonisjs/core/events';
-import { EventsList } from '@adonisjs/core/types';
-import { SessionConfig } from '../src/types/main.js';
+import type { EventsList } from '@adonisjs/core/types';
 import SessionMiddleware from '../src/session_middleware.js';
+import type { SessionConfig, SessionStoreFactory } from '../src/types.js';
 /**
  * Exposes the API to create an instance of the session middleware
  * without additional plumbing
@@ -12,11 +12,16 @@ export declare class SessionMiddlewareFactory {
      * Merge custom options
      */
     merge(options: {
-        config?: Partial<SessionConfig>;
+        config?: Partial<SessionConfig> & {
+            store: string;
+            stores: Record<string, SessionStoreFactory>;
+        };
         emitter?: Emitter<EventsList>;
     }): this;
     /**
      * Creates an instance of the session middleware
      */
-    create(): Promise<SessionMiddleware>;
+    create(): Promise<SessionMiddleware<{
+        [x: string]: SessionStoreFactory;
+    }>>;
 }

package/build/factories/session_middleware_factory.js

@@ -9,14 +9,16 @@
 import { Emitter } from '@adonisjs/core/events';
 import { AppFactory } from '@adonisjs/core/factories/app';
 import { defineConfig } from '../index.js';
-import { registerSessionDriver } from '../src/helpers.js';
 import SessionMiddleware from '../src/session_middleware.js';
 /**
  * Exposes the API to create an instance of the session middleware
  * without additional plumbing
  */
 export class SessionMiddlewareFactory {
-    #config = { driver: 'memory' };
+    #config = {
+        store: 'memory',
+        stores: {},
+    };
     #emitter;
     #getApp() {
         return new AppFactory().create(new URL('./', import.meta.url), () => { });
@@ -40,8 +42,7 @@ export class SessionMiddlewareFactory {
      * Creates an instance of the session middleware
      */
     async create() {
-        const config = defineConfig(this.#config);
-        await registerSessionDriver(this.#getApp(), config.driver);
+        const config = await defineConfig(this.#config).resolver(this.#getApp());
         return new SessionMiddleware(config, this.#getEmitter());
     }
 }

package/build/index.d.ts

@@ -6,9 +6,7 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import './src/types/extended.js';
 export * as errors from './src/errors.js';
 export { configure } from './configure.js';
 export { stubsRoot } from './stubs/main.js';
-export { defineConfig } from './src/define_config.js';
-export { default as driversList } from './src/drivers_collection.js';
+export { defineConfig, stores } from './src/define_config.js';

package/build/index.js

@@ -6,9 +6,7 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import './src/types/extended.js';
 export * as errors from './src/errors.js';
 export { configure } from './configure.js';
 export { stubsRoot } from './stubs/main.js';
-export { defineConfig } from './src/define_config.js';
-export { default as driversList } from './src/drivers_collection.js';
+export { defineConfig, stores } from './src/define_config.js';

package/build/providers/session_provider.d.ts

@@ -1,5 +1,23 @@
-import type { Edge } from 'edge.js';
 import type { ApplicationService } from '@adonisjs/core/types';
+import type { Session } from '../src/session.js';
+/**
+ * Events emitted by the session class
+ */
+declare module '@adonisjs/core/types' {
+    interface EventsList {
+        'session:initiated': {
+            session: Session;
+        };
+        'session:committed': {
+            session: Session;
+        };
+        'session:migrated': {
+            fromSessionId: string;
+            toSessionId: string;
+            session: Session;
+        };
+    }
+}
 /**
  * Session provider configures the session management inside an
  * AdonisJS application
@@ -8,16 +26,15 @@ export default class SessionProvider {
     protected app: ApplicationService;
     constructor(app: ApplicationService);
     /**
-     * Returns edge when it's installed
+     * Registers edge plugin when edge is installed
+     * in the user application.
      */
-    protected getEdge(): Promise<Edge | null>;
+    protected registerEdgePlugin(): Promise<void>;
     /**
      * Registering muddleware
      */
     register(): void;
     /**
-     * Registering the active driver when middleware is used
-     * +
      * Adding edge tags (if edge is installed)
      */
     boot(): Promise<void>;

package/build/providers/session_provider.js

@@ -6,8 +6,8 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import debug from '../src/debug.js';
-import { registerSessionDriver } from '../src/helpers.js';
+import { configProvider } from '@adonisjs/core';
+import { RuntimeException } from '@poppinss/utils';
 import SessionMiddleware from '../src/session_middleware.js';
 /**
  * Session provider configures the session management inside an
@@ -19,16 +19,19 @@ export default class SessionProvider {
         this.app = app;
     }
     /**
-     * Returns edge when it's installed
+     * Registers edge plugin when edge is installed
+     * in the user application.
      */
-    async getEdge() {
+    async registerEdgePlugin() {
+        let edge = null;
         try {
-            const { default: edge } = await import('edge.js');
-            debug('Detected edge.js package. Adding session primitives to it');
-            return edge;
+            const edgeExports = await import('edge.js');
+            edge = edgeExports.default;
         }
-        catch {
-            return null;
+        catch { }
+        if (edge) {
+            const { edgePluginSession } = await import('../src/plugins/edge.js');
+            edge.use(edgePluginSession);
         }
     }
     /**
@@ -36,25 +39,22 @@ export default class SessionProvider {
      */
     register() {
         this.app.container.singleton(SessionMiddleware, async (resolver) => {
-            const config = this.app.config.get('session', {});
+            const sessionConfigProvider = this.app.config.get('session', {});
+            /**
+             * Resolve config from the provider
+             */
+            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);
         });
     }
     /**
-     * Registering the active driver when middleware is used
-     * +
      * Adding edge tags (if edge is installed)
      */
     async boot() {
-        this.app.container.resolving(SessionMiddleware, async () => {
-            const config = this.app.config.get('session');
-            await registerSessionDriver(this.app, config.driver);
-        });
-        const edge = await this.getEdge();
-        if (edge) {
-            const { edgePluginAdonisJSSession } = await import('../src/edge_plugin_adonisjs_session.js');
-            edge.use(edgePluginAdonisJSSession);
-        }
+        await this.registerEdgePlugin();
     }
 }

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, SessionStoreContract } from './types.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(store: SessionStoreContract);
     /**
-     * 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 { Store } from './store.js';
+import debug from './debug.js';
+import { ValuesStore } from './values_store.js';
 /**
  * Session client exposes the API to set session data as a client
  */
 export class SessionClient {
     /**
-     * Session configuration
+     * Data store
      */
-    #config;
+    #valuesStore = new ValuesStore({});
     /**
-     * The session driver to use for reading and writing session data
+     * Flash messages store
      */
-    #driver;
+    #flashMessagesStore = new ValuesStore({});
     /**
-     * Cookie client contract to sign and unsign cookies
+     * The session store to use for reading and writing session data
      */
-    #cookieClient;
+    #store;
+    /**
+     * Session key for setting flash messages
+     */
+    flashKey = '__flash__';
     /**
      * Session to use when no explicit session id is
      * defined
      */
-    #sessionId = cuid();
+    sessionId = cuid();
+    constructor(store) {
+        this.#store = store;
+    }
     /**
-     * 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.#valuesStore.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.#valuesStore.set(this.flashKey, this.#flashMessagesStore.toJSON());
+        }
+        debug('committing session data during api request');
+        if (!this.#valuesStore.isEmpty) {
+            this.#store.write(this.sessionId, this.#valuesStore.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.#store.destroy(sessionId || this.sessionId);
+    }
+    /**
+     * Loads session data from the session store
+     */
+    async load(sessionId) {
+        const contents = await this.#store.read(sessionId || this.sessionId);
+        const store = new ValuesStore(contents);
+        const flashMessages = store.pull(this.flashKey, {});
+        return {
+            values: store.all(),
+            flashMessages,
+        };
     }
 }

package/build/src/debug.d.ts

@@ -1,3 +1,3 @@
-/// <reference types="@types/node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 declare const _default: import("util").DebugLogger;
 export default _default;

package/build/src/define_config.d.ts

@@ -1,8 +1,29 @@
+import type { ConfigProvider } from '@adonisjs/core/types';
 import type { CookieOptions } from '@adonisjs/core/types/http';
-import type { SessionConfig } from './types/main.js';
+import type { SessionConfig, FileStoreConfig, RedisStoreConfig, SessionStoreFactory } from './types.js';
 /**
- * Helper to normalize session config
+ * Resolved config with stores
  */
-export declare function defineConfig(config: Partial<SessionConfig>): SessionConfig & {
+type ResolvedConfig<KnownStores extends Record<string, SessionStoreFactory>> = SessionConfig & {
+    store: keyof KnownStores;
+    stores: KnownStores;
     cookie: Partial<CookieOptions>;
 };
+/**
+ * Helper to normalize session config
+ */
+export declare function defineConfig<KnownStores extends Record<string, SessionStoreFactory | ConfigProvider<SessionStoreFactory>>>(config: Partial<SessionConfig> & {
+    store: keyof KnownStores | 'memory';
+    stores: KnownStores;
+}): ConfigProvider<ResolvedConfig<{
+    [K in keyof KnownStores]: SessionStoreFactory;
+}>>;
+/**
+ * Inbuilt stores to store the session data.
+ */
+export declare const stores: {
+    file: (config: FileStoreConfig) => ConfigProvider<SessionStoreFactory>;
+    redis: (config: RedisStoreConfig) => ConfigProvider<SessionStoreFactory>;
+    cookie: () => ConfigProvider<SessionStoreFactory>;
+};
+export {};

package/build/src/define_config.js

@@ -6,37 +6,100 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+/// <reference types="@adonisjs/redis/redis_provider" />
 import string from '@poppinss/utils/string';
+import { configProvider } from '@adonisjs/core';
 import { InvalidArgumentsException } from '@poppinss/utils';
 import debug from './debug.js';
+import { MemoryStore } from './stores/memory.js';
 /**
  * Helper to normalize session config
  */
 export function defineConfig(config) {
+    debug('processing session config %O', config);
     /**
-     * Make sure a driver is defined
+     * Make sure a store is defined
      */
-    if (!config.driver) {
-        throw new InvalidArgumentsException('Missing "driver" property inside the session config');
+    if (!config.store) {
+        throw new InvalidArgumentsException('Missing "store" property inside the session config');
     }
-    const age = config.age || '2h';
-    const clearWithBrowser = config.clearWithBrowser ?? false;
-    const cookieOptions = { ...config.cookie };
     /**
-     * Define maxAge property when session id cookie is
-     * not a session cookie.
+     * Destructuring config with the default values. We pull out
+     * stores and cookie values, since we have to transform
+     * them in the output value.
      */
-    if (!clearWithBrowser) {
-        debug('computing maxAge for session id cookie');
-        cookieOptions.maxAge = string.seconds.parse(config.age || age);
-    }
-    return {
+    const { stores, cookie, ...rest } = {
         enabled: true,
-        age,
-        clearWithBrowser,
+        age: '2h',
         cookieName: 'adonis_session',
-        cookie: cookieOptions,
-        driver: config.driver,
+        clearWithBrowser: false,
         ...config,
     };
+    const cookieOptions = { ...cookie };
+    /**
+     * Define maxAge property when session id cookie is
+     * not a session cookie.
+     */
+    if (!rest.clearWithBrowser) {
+        cookieOptions.maxAge = string.seconds.parse(rest.age);
+        debug('computing maxAge "%s" for session id cookie', cookieOptions.maxAge);
+    }
+    return configProvider.create(async (app) => {
+        const storesNames = Object.keys(config.stores);
+        /**
+         * List of stores with memory store always configured
+         */
+        const storesList = {
+            memory: () => new MemoryStore(),
+        };
+        /**
+         * Looping for stores and resolving them
+         */
+        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('transformed session config %O', transformedConfig);
+        return transformedConfig;
+    });
 }
+/**
+ * Inbuilt stores to store the session data.
+ */
+export const stores = {
+    file: (config) => {
+        return configProvider.create(async () => {
+            const { FileStore } = await import('./stores/file.js');
+            return (_, sessionConfig) => {
+                return new FileStore(config, sessionConfig.age);
+            };
+        });
+    },
+    redis: (config) => {
+        return configProvider.create(async (app) => {
+            const { RedisStore } = await import('./stores/redis.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('./stores/cookie.js');
+            return (ctx, sessionConfig) => {
+                return new CookieStore(sessionConfig.cookie, ctx);
+            };
+        });
+    },
+};

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