@adonisjs/session 7.0.0-0 → 7.0.0-10

package/build/src/session_middleware.js

@@ -1,9 +1,44 @@
+/*
+ * @adonisjs/session
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { ExceptionHandler } from '@adonisjs/core/http';
+import { Session } from './session.js';
+import sessionDriversList from './drivers_collection.js';
+/**
+ * Overwriting validation exception renderer
+ */
+const originalErrorHandler = ExceptionHandler.prototype.renderValidationErrorAsHTML;
+ExceptionHandler.macro('renderValidationErrorAsHTML', async function (error, ctx) {
+    if (ctx.session) {
+        ctx.session.flashValidationErrors(error);
+        ctx.response.redirect('back', true);
+    }
+    else {
+        return originalErrorHandler(error, ctx);
+    }
+});
+/**
+ * Session middleware is used to initiate the session store
+ * and commit its values during an HTTP request
+ */
 export default class SessionMiddleware {
+    #config;
+    #emitter;
+    constructor(config, emitter) {
+        this.#config = config;
+        this.#emitter = emitter;
+    }
     async handle(ctx, next) {
-        const sessionManager = (await ctx.containerResolver.make('session'));
-        if (!sessionManager.isEnabled()) {
-            return;
+        if (!this.#config.enabled) {
+            return next();
         }
+        const driver = sessionDriversList.create(this.#config.driver, this.#config, ctx);
+        ctx.session = new Session(this.#config, driver, this.#emitter, ctx);
         /**
          * Initiate session store
          */
@@ -11,10 +46,14 @@ export default class SessionMiddleware {
         /**
          * Call next middlewares or route handler
          */
-        await next();
+        const response = await next();
         /**
          * Commit store mutations
          */
         await ctx.session.commit();
+        /**
+         * Return response
+         */
+        return response;
     }
 }

package/build/src/store.d.ts

@@ -1,32 +1,62 @@
-import type { AllowedSessionValues } from './types.js';
+import type { AllowedSessionValues, SessionData } from './types/main.js';
 /**
- * Session store to mutate and access values from the session object
+ * Readonly session store
  */
-export declare class Store {
-    #private;
-    constructor(values: {
-        [key: string]: any;
-    } | null);
+export declare class ReadOnlyStore {
     /**
-     * Find if store is empty or not
+     * Underlying store values
      */
-    get isEmpty(): boolean;
+    protected values: SessionData;
     /**
-     * Set key/value pair
+     * Find if store is empty or not
      */
-    set(key: string, value: AllowedSessionValues): void;
+    get isEmpty(): boolean;
+    constructor(values: SessionData | null);
     /**
      * Get value for a given key
      */
     get(key: string, defaultValue?: any): any;
     /**
-     * Remove key
+     * A boolean to know if value exists. Extra guards to check
+     * arrays for it's length as well.
      */
-    unset(key: string): void;
+    has(key: string, checkForArraysLength?: boolean): boolean;
     /**
-     * Reset store by clearing it's values.
+     * Get all values
      */
-    clear(): void;
+    all(): any;
+    /**
+     * Returns object representation of values
+     */
+    toObject(): any;
+    /**
+     * Returns the store values
+     */
+    toJSON(): any;
+    /**
+     * Returns string representation of the store
+     */
+    toString(): string;
+}
+/**
+ * Session store encapsulates the session data and offers a
+ * declarative API to mutate it.
+ */
+export declare class Store extends ReadOnlyStore {
+    #private;
+    constructor(values: SessionData | null);
+    /**
+     * Find if the store has been modified.
+     */
+    get hasBeenModified(): boolean;
+    /**
+     * Set key/value pair
+     */
+    set(key: string, value: AllowedSessionValues): void;
+    /**
+     * Remove key
+     */
+    unset(key: string): void;
     /**
      * Pull value from the store. It is same as calling
      * store.get and then store.unset
@@ -43,7 +73,7 @@ export declare class Store {
      */
     decrement(key: string, steps?: number): void;
     /**
-     * Overwrite the underlying values object
+     * Overwrite existing store data with new values.
      */
     update(values: {
         [key: string]: any;
@@ -55,24 +85,7 @@ export declare class Store {
         [key: string]: any;
     }): any;
     /**
-     * A boolean to know if value exists. Extra guards to check
-     * arrays for it's length as well.
-     */
-    has(key: string, checkForArraysLength?: boolean): boolean;
-    /**
-     * Get all values
-     */
-    all(): any;
-    /**
-     * Returns object representation of values
-     */
-    toObject(): any;
-    /**
-     * Returns the store values
-     */
-    toJSON(): any;
-    /**
-     * Returns string representation of the store
+     * Reset store by clearing it's values.
      */
-    toString(): string;
+    clear(): void;
 }

package/build/src/store.js

@@ -6,48 +6,103 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { Exception } from '@poppinss/utils';
 import lodash from '@poppinss/utils/lodash';
+import { RuntimeException } from '@poppinss/utils';
 /**
- * Session store to mutate and access values from the session object
+ * Readonly session store
  */
-export class Store {
+export class ReadOnlyStore {
     /**
      * Underlying store values
      */
-    #values;
-    constructor(values) {
-        this.#values = values || {};
-    }
+    values;
     /**
      * Find if store is empty or not
      */
     get isEmpty() {
-        return !this.#values || Object.keys(this.#values).length === 0;
+        return !this.values || Object.keys(this.values).length === 0;
     }
-    /**
-     * Set key/value pair
-     */
-    set(key, value) {
-        lodash.set(this.#values, key, value);
+    constructor(values) {
+        this.values = values || {};
     }
     /**
      * Get value for a given key
      */
     get(key, defaultValue) {
-        return lodash.get(this.#values, key, defaultValue);
+        const value = lodash.get(this.values, key);
+        if (defaultValue !== undefined && (value === null || value === undefined)) {
+            return defaultValue;
+        }
+        return value;
     }
     /**
-     * Remove key
+     * A boolean to know if value exists. Extra guards to check
+     * arrays for it's length as well.
      */
-    unset(key) {
-        lodash.unset(this.#values, key);
+    has(key, checkForArraysLength = true) {
+        const value = this.get(key);
+        if (!Array.isArray(value)) {
+            return !!value;
+        }
+        return checkForArraysLength ? value.length > 0 : !!value;
     }
     /**
-     * Reset store by clearing it's values.
+     * Get all values
      */
-    clear() {
-        this.update({});
+    all() {
+        return this.values;
+    }
+    /**
+     * Returns object representation of values
+     */
+    toObject() {
+        return this.all();
+    }
+    /**
+     * Returns the store values
+     */
+    toJSON() {
+        return this.all();
+    }
+    /**
+     * Returns string representation of the store
+     */
+    toString() {
+        return JSON.stringify(this.all());
+    }
+}
+/**
+ * Session store encapsulates the session data and offers a
+ * declarative API to mutate it.
+ */
+export class Store extends ReadOnlyStore {
+    /**
+     * A boolean to know if store has been
+     * modified
+     */
+    #modified = false;
+    constructor(values) {
+        super(values);
+    }
+    /**
+     * Find if the store has been modified.
+     */
+    get hasBeenModified() {
+        return this.#modified;
+    }
+    /**
+     * Set key/value pair
+     */
+    set(key, value) {
+        this.#modified = true;
+        lodash.set(this.values, key, value);
+    }
+    /**
+     * Remove key
+     */
+    unset(key) {
+        this.#modified = true;
+        lodash.unset(this.values, key);
     }
     /**
      * Pull value from the store. It is same as calling
@@ -66,7 +121,7 @@ export class Store {
     increment(key, steps = 1) {
         const value = this.get(key, 0);
         if (typeof value !== 'number') {
-            throw new Exception(`Cannot increment "${key}", since original value is not a number`);
+            throw new RuntimeException(`Cannot increment "${key}". Existing value is not a number`);
         }
         this.set(key, value + steps);
     }
@@ -77,55 +132,28 @@ export class Store {
     decrement(key, steps = 1) {
         const value = this.get(key, 0);
         if (typeof value !== 'number') {
-            throw new Exception(`Cannot increment "${key}", since original value is not a number`);
+            throw new RuntimeException(`Cannot decrement "${key}". Existing value is not a number`);
         }
         this.set(key, value - steps);
     }
     /**
-     * Overwrite the underlying values object
+     * Overwrite existing store data with new values.
      */
     update(values) {
-        this.#values = values;
+        this.#modified = true;
+        this.values = values;
     }
     /**
      * Update to merge values
      */
     merge(values) {
-        lodash.merge(this.#values, values);
-    }
-    /**
-     * A boolean to know if value exists. Extra guards to check
-     * arrays for it's length as well.
-     */
-    has(key, checkForArraysLength = true) {
-        const value = this.get(key);
-        if (!Array.isArray(value)) {
-            return !!value;
-        }
-        return checkForArraysLength ? value.length > 0 : !!value;
+        this.#modified = true;
+        lodash.merge(this.values, values);
     }
     /**
-     * Get all values
-     */
-    all() {
-        return this.#values;
-    }
-    /**
-     * Returns object representation of values
-     */
-    toObject() {
-        return this.all();
-    }
-    /**
-     * Returns the store values
-     */
-    toJSON() {
-        return this.all();
-    }
-    /**
-     * Returns string representation of the store
+     * Reset store by clearing it's values.
      */
-    toString() {
-        return JSON.stringify(this.all());
+    clear() {
+        this.update({});
     }
 }

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

@@ -0,0 +1,19 @@
+import type { Session } from '../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;
+        };
+    }
+}

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

@@ -0,0 +1,106 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import { RedisConnections } from '@adonisjs/redis/types';
+import type { CookieOptions } from '@adonisjs/core/types/http';
+import type { FileDriver } from '../drivers/file.js';
+import type { RedisDriver } from '../drivers/redis.js';
+import type { MemoryDriver } from '../drivers/memory.js';
+import type { CookieDriver } from '../drivers/cookie.js';
+/**
+ * The values allowed by the `session.put` method
+ */
+export type AllowedSessionValues = string | boolean | number | object | Date | Array<any>;
+export type SessionData = Record<string, AllowedSessionValues>;
+/**
+ * Session drivers must implement the session driver contract.
+ */
+export interface SessionDriverContract {
+    /**
+     * The read method is used to read the data from the persistence
+     * store and return it back as an object
+     */
+    read(sessionId: string): Promise<SessionData | null> | SessionData | null;
+    /**
+     * The write method is used to write the session data into the
+     * persistence store.
+     */
+    write(sessionId: string, data: SessionData): Promise<void> | void;
+    /**
+     * The destroy method is used to destroy the session by removing
+     * its data from the persistence store
+     */
+    destroy(sessionId: string): Promise<void> | void;
+    /**
+     * The touch method should update the lifetime of session id without
+     * making changes to the session data.
+     */
+    touch(sessionId: string): Promise<void> | void;
+}
+/**
+ * Shape of session config.
+ */
+export interface SessionConfig {
+    /**
+     * Enable/disable sessions temporarily
+     */
+    enabled: boolean;
+    /**
+     * The drivers to use
+     */
+    driver: keyof SessionDriversList;
+    /**
+     * The name of the cookie for storing the session id.
+     */
+    cookieName: string;
+    /**
+     * When set to true, the session id cookie will be removed
+     * when the user closes the browser.
+     *
+     * However, the persisted data will continue to exist until
+     * it gets expired.
+     */
+    clearWithBrowser: boolean;
+    /**
+     * How long the session data should be kept alive without any
+     * activity.
+     *
+     * The session id cookie will also live for the same duration, unless
+     * "clearWithBrowser" is enabled
+     *
+     * The value should be a time expression or a number in seconds
+     */
+    age: string | number;
+    /**
+     * Configuration used by the cookie driver and for storing the
+     * session id cookie.
+     */
+    cookie: Omit<Partial<CookieOptions>, 'maxAge' | 'expires'>;
+}
+/**
+ * Configuration used by the file driver.
+ */
+export type FileDriverConfig = {
+    location: string;
+};
+/**
+ * Configuration used by the redis driver.
+ */
+export type RedisDriverConfig = {
+    connection: keyof RedisConnections;
+};
+/**
+ * Extending session config with the drivers config
+ */
+export interface SessionConfig {
+    file?: FileDriverConfig;
+    redis?: RedisDriverConfig;
+}
+/**
+ * List of the session drivers. The list can be extended using
+ * declaration merging
+ */
+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;
+}

package/build/src/types/main.js

@@ -0,0 +1,9 @@
+/*
+ * @adonisjs/session
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+export {};

package/build/stubs/config.stub

@@ -1,113 +1,49 @@
 ---
 to: {{ app.configPath('session.ts') }}
 ---
-
 import env from '#start/env'
-import app from '@adonisjs/core/services/app'
 import { defineConfig } from '@adonisjs/session'
 
 export default defineConfig({
-  /*
-  |--------------------------------------------------------------------------
-  | Enable/Disable sessions
-  |--------------------------------------------------------------------------
-  |
-  | Setting the following property to "false" will disable the session for the
-  | entire application
-  |
-  */
   enabled: true,
-
-  /*
-  |--------------------------------------------------------------------------
-  | Driver
-  |--------------------------------------------------------------------------
-  |
-  | The session driver to use. You can choose between one of the following
-  | drivers.
-  |
-  | - cookie (Uses signed cookies to store session values)
-  | - file (Uses filesystem to store session values)
-  | - redis (Uses redis. Make sure to install "@adonisjs/redis" as well)
-  |
-  | Note: Switching drivers will make existing sessions invalid.
-  |
-  */
-  driver: env.get('SESSION_DRIVER'),
-
-  /*
-  |--------------------------------------------------------------------------
-  | Cookie name
-  |--------------------------------------------------------------------------
-  |
-  | The name of the cookie that will hold the session id.
-  |
-  */
   cookieName: 'adonis-session',
 
-  /*
-  |--------------------------------------------------------------------------
-  | Clear session when browser closes
-  |--------------------------------------------------------------------------
-  |
-  | Whether or not you want to destroy the session when browser closes. Setting
-  | this value to "true" will ignore the "age".
-  |
-  */
+  /**
+   * When set to true, the session id cookie will be deleted
+   * once the user closes the browser.
+   */
   clearWithBrowser: false,
 
-  /*
-  |--------------------------------------------------------------------------
-  | Session age
-  |--------------------------------------------------------------------------
-  |
-  | The duration for which session stays active after no activity. A new HTTP
-  | request to the server is considered as activity.
-  |
-  | The value can be a number in milliseconds or a string that must be valid
-  | as per https://npmjs.org/package/ms package.
-  |
-  | Example: "2 days", "2.5 hrs", "1y", "5s" and so on.
-  |
-  */
+  /**
+   * Define how long to keep the session data alive without
+   * any activity.
+   */
   age: '2h',
 
-  /*
-  |--------------------------------------------------------------------------
-  | Cookie values
-  |--------------------------------------------------------------------------
-  |
-  | The cookie settings are used to setup the session id cookie and also the
-  | driver will use the same values.
-  |
-  */
+  /**
+   * The driver to use. Make sure to validate the environment
+   * variable in order to infer the driver name without any
+   * errors.
+   */
+  driver: env.get('SESSION_DRIVER'),
+
   cookie: {
     path: '/',
     httpOnly: true,
     sameSite: false,
   },
 
-  /*
-  |--------------------------------------------------------------------------
-  | Configuration for the file driver
-  |--------------------------------------------------------------------------
-  |
-  | The file driver needs absolute path to the directory in which sessions
-  | must be stored.
-  |
-  */
-  file: {
-    location: app.tmpPath('sessions'),
-  },
-
-  /*
-  |--------------------------------------------------------------------------
-  | Redis driver
-  |--------------------------------------------------------------------------
-  |
-  | The redis connection you want session driver to use. The same connection
-  | must be defined inside "config/redis.ts" file as well.
-  |
-  */
-  redisConnection: 'local',
+  /**
+   * Settings for the file driver
+   */
+  // file: {
+  //   location: app.tmpPath('sessions'),
+  // },
+
+  /**
+   * Settings for the redis driver
+   */
+  // redis: {
+  //   connection: 'main'
+  // },
 })