@adonisjs/session 7.0.0-11 → 7.0.0-13

package/build/configure.js

@@ -24,7 +24,7 @@ export async function configure(command) {
      */
     await codemods.defineEnvValidations({
         variables: {
-            SESSION_DRIVER: `Env.schema.enum(['cookie', 'redis', 'file', 'memory'] as const)`,
+            SESSION_DRIVER: `Env.schema.enum(['cookie', 'memory'] as const)`,
         },
         leadingComment: 'Variables for configuring session package',
     });

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 { edgePluginSession } = await import('../src/plugins/edge.js');
-            edge.use(edgePluginSession);
-        }
+        await this.registerEdgePlugin();
     }
 }

package/build/src/client.d.ts

@@ -1,4 +1,4 @@
-import type { 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
  */
@@ -13,7 +13,7 @@ export declare class SessionClient {
      * defined
      */
     sessionId: string;
-    constructor(driver: SessionDriverContract);
+    constructor(store: SessionStoreContract);
     /**
      * Merge session data
      */

package/build/src/client.js

@@ -8,7 +8,7 @@
  */
 import { cuid } from '@adonisjs/core/helpers';
 import debug from './debug.js';
-import { Store } from './store.js';
+import { ValuesStore } from './values_store.js';
 /**
  * Session client exposes the API to set session data as a client
  */
@@ -16,15 +16,15 @@ export class SessionClient {
     /**
      * Data store
      */
-    #store = new Store({});
+    #valuesStore = new ValuesStore({});
     /**
      * Flash messages store
      */
-    #flashMessagesStore = new Store({});
+    #flashMessagesStore = new ValuesStore({});
     /**
-     * The session driver to use for reading and writing session data
+     * The session store to use for reading and writing session data
      */
-    #driver;
+    #store;
     /**
      * Session key for setting flash messages
      */
@@ -34,14 +34,14 @@ export class SessionClient {
      * defined
      */
     sessionId = cuid();
-    constructor(driver) {
-        this.#driver = driver;
+    constructor(store) {
+        this.#store = store;
     }
     /**
      * Merge session data
      */
     merge(values) {
-        this.#store.merge(values);
+        this.#valuesStore.merge(values);
         return this;
     }
     /**
@@ -56,11 +56,11 @@ export class SessionClient {
      */
     async commit() {
         if (!this.#flashMessagesStore.isEmpty) {
-            this.#store.set(this.flashKey, this.#flashMessagesStore.toJSON());
+            this.#valuesStore.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());
+        if (!this.#valuesStore.isEmpty) {
+            this.#store.write(this.sessionId, this.#valuesStore.toJSON());
         }
     }
     /**
@@ -68,14 +68,14 @@ export class SessionClient {
      */
     async destroy(sessionId) {
         debug('destroying session data during api request');
-        this.#driver.destroy(sessionId || this.sessionId);
+        this.#store.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 contents = await this.#store.read(sessionId || this.sessionId);
+        const store = new ValuesStore(contents);
         const flashMessages = store.pull(this.flashKey, {});
         return {
             values: store.all(),

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/plugins/japa/api_client.d.ts

@@ -1,7 +1,7 @@
 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';
+import type { SessionData } from '../../types.js';
 declare module '@japa/api-client' {
     interface ApiRequest {
         sessionClient: SessionClient;
@@ -69,7 +69,7 @@ declare module '@japa/api-client' {
     }
 }
 /**
- * Hooks AdonisJS Session with the Japa API Client
+ * Hooks AdonisJS Session with the Japa API client
  * plugin
  */
 export declare const sessionApiClient: (app: ApplicationService) => PluginFn;

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

@@ -7,35 +7,31 @@
  * file that was distributed with this source code.
  */
 import lodash from '@poppinss/utils/lodash';
+import { configProvider } from '@adonisjs/core';
 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
+ * Hooks AdonisJS Session with the Japa API client
  * plugin
  */
 export const sessionApiClient = (app) => {
     const pluginFn = async function () {
-        const config = app.config.get('session');
+        const sessionConfigProvider = app.config.get('session', {});
         /**
-         * Disallow usage of driver other than memory during testing
+         * Resolve config from the provider
          */
-        if (config.driver !== 'memory') {
-            throw new RuntimeException(`Cannot use session driver "${config.driver}" during testing. Switch to memory driver`);
+        const config = await configProvider.resolve(app, sessionConfigProvider);
+        if (!config) {
+            throw new RuntimeException('Invalid "config/session.ts" file. Make sure you are using the "defineConfig" method');
         }
-        /**
-         * 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));
+            return new SessionClient(config.stores.memory());
         }, true);
         /**
          * Define session data

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

@@ -2,7 +2,7 @@ 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';
+import type { SessionData } from '../../types.js';
 declare module 'playwright' {
     interface BrowserContext {
         sessionClient: SessionClient;
@@ -30,7 +30,7 @@ declare module 'playwright' {
     }
 }
 /**
- * Hooks AdonisJS Session with the Japa API Client
+ * Hooks AdonisJS Session with the Japa browser client
  * plugin
  */
 export declare const sessionBrowserClient: (app: ApplicationService) => PluginFn;

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

@@ -6,11 +6,10 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
+import { configProvider } from '@adonisjs/core';
 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.
@@ -41,28 +40,25 @@ function getSessionCookieOptions(config, cookieOptions) {
     };
 }
 /**
- * Hooks AdonisJS Session with the Japa API Client
+ * Hooks AdonisJS Session with the Japa browser client
  * plugin
  */
 export const sessionBrowserClient = (app) => {
     const pluginFn = async function () {
-        const config = app.config.get('session');
+        const sessionConfigProvider = app.config.get('session', {});
         /**
-         * Disallow usage of driver other than memory during testing
+         * Resolve config from the provider
          */
-        if (config.driver !== 'memory') {
-            throw new RuntimeException(`Cannot use session driver "${config.driver}" during testing. Switch to memory driver`);
+        const config = await configProvider.resolve(app, sessionConfigProvider);
+        if (!config) {
+            throw new RuntimeException('Invalid "config/session.ts" file. Make sure you are using the "defineConfig" method');
         }
-        /**
-         * 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));
+                context.sessionClient = new SessionClient(config.stores.memory());
                 /**
                  * Initiating session store
                  */

package/build/src/session.d.ts

@@ -1,8 +1,8 @@
-import { EmitterService } from '@adonisjs/core/types';
 import type { HttpContext } from '@adonisjs/core/http';
-import { Store } from './store.js';
-import type { SessionData, SessionConfig, AllowedSessionValues, SessionDriverContract } from './types/main.js';
-import { HttpError } from '@adonisjs/core/types/http';
+import type { EmitterService } from '@adonisjs/core/types';
+import type { HttpError } from '@adonisjs/core/types/http';
+import { ValuesStore } from './values_store.js';
+import type { SessionData, SessionConfig, SessionStoreFactory, AllowedSessionValues } from './types.js';
 /**
  * The session class exposes the API to read and write values to
  * the session store.
@@ -16,11 +16,11 @@ export declare class Session {
      * Store of flash messages that be written during the
      * HTTP request
      */
-    responseFlashMessages: Store;
+    responseFlashMessages: ValuesStore;
     /**
      * Store of flash messages for the current HTTP request.
      */
-    flashMessages: Store;
+    flashMessages: ValuesStore;
     /**
      * The key to use for storing flash messages inside
      * the session store.
@@ -58,7 +58,7 @@ export declare class Session {
      * modified
      */
     get hasBeenModified(): boolean;
-    constructor(config: SessionConfig, driver: SessionDriverContract, emitter: EmitterService, ctx: HttpContext);
+    constructor(config: SessionConfig, storeFactory: SessionStoreFactory, emitter: EmitterService, ctx: HttpContext);
     /**
      * Initiates the session store. The method results in a noop
      * when called multiple times