@adonisjs/session 6.4.0 → 7.0.0-0

package/build/src/session_manager.js

@@ -0,0 +1,149 @@
+/**
+ * @adonisjs/session
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import string from '@poppinss/utils/string';
+import { Exception } from '@poppinss/utils';
+import { Session } from './session.js';
+import { CookieClient } from '@adonisjs/core/http';
+import { CookieDriver } from './drivers/cookie.js';
+import { MemoryDriver } from './drivers/memory.js';
+import { FileDriver } from './drivers/file.js';
+import { RedisDriver } from './drivers/redis.js';
+import { SessionClient } from './client.js';
+/**
+ * Session manager exposes the API to create session instance for a given
+ * request and also add new drivers.
+ */
+export class SessionManager {
+    /**
+     * A private map of drivers added from outside in.
+     */
+    #extendedDrivers = new Map();
+    /**
+     * Reference to session config
+     */
+    #config;
+    /**
+     * Reference to the encryption instance
+     */
+    #encryption;
+    /**
+     * Reference to the redis manager
+     */
+    #redis;
+    constructor(config, encryption, redis) {
+        this.#encryption = encryption;
+        this.#redis = redis;
+        this.#processConfig(config);
+    }
+    /**
+     * Processes the config and decides the `expires` option for the cookie
+     */
+    #processConfig(config) {
+        /**
+         * Explicitly overwriting `cookie.expires` and `cookie.maxAge` from
+         * the user defined config
+         */
+        const processedConfig = Object.assign({ enabled: true }, config, {
+            cookie: {
+                ...config.cookie,
+                expires: undefined,
+                maxAge: undefined,
+            },
+        });
+        /**
+         * Set the max age when `clearWithBrowser = false`. Otherwise cookie
+         * is a session cookie
+         */
+        if (!processedConfig.clearWithBrowser) {
+            const age = typeof processedConfig.age === 'string'
+                ? Math.round(string.milliseconds.parse(processedConfig.age) / 1000)
+                : processedConfig.age;
+            processedConfig.cookie.maxAge = age;
+        }
+        this.#config = processedConfig;
+    }
+    /**
+     * Returns an instance of cookie driver
+     */
+    #createCookieDriver(ctx) {
+        return new CookieDriver(this.#config, ctx);
+    }
+    /**
+     * Returns an instance of the memory driver
+     */
+    #createMemoryDriver() {
+        return new MemoryDriver();
+    }
+    /**
+     * Returns an instance of file driver
+     */
+    #createFileDriver() {
+        return new FileDriver(this.#config);
+    }
+    /**
+     * Returns an instance of redis driver
+     */
+    #createRedisDriver() {
+        if (!this.#redis) {
+            throw new Error('Install "@adonisjs/redis" in order to use the redis driver for storing sessions');
+        }
+        return new RedisDriver(this.#config, this.#redis);
+    }
+    /**
+     * Creates an instance of extended driver
+     */
+    #createExtendedDriver(ctx) {
+        if (!this.#extendedDrivers.has(this.#config.driver)) {
+            throw new Exception(`"${this.#config.driver}" is not a valid session driver`, {
+                code: 'E_INVALID_SESSION_DRIVER',
+                status: 500,
+            });
+        }
+        return this.#extendedDrivers.get(this.#config.driver)(this, this.#config, ctx);
+    }
+    #createDriver(ctx) {
+        switch (this.#config.driver) {
+            case 'cookie':
+                return this.#createCookieDriver(ctx);
+            case 'file':
+                return this.#createFileDriver();
+            case 'redis':
+                return this.#createRedisDriver();
+            case 'memory':
+                return this.#createMemoryDriver();
+            default:
+                return this.#createExtendedDriver(ctx);
+        }
+    }
+    /**
+     * Find if the sessions are enabled
+     */
+    isEnabled() {
+        return this.#config.enabled;
+    }
+    /**
+     * Creates an instance of the session client
+     */
+    client() {
+        const cookieClient = new CookieClient(this.#encryption);
+        return new SessionClient(this.#config, this.#createMemoryDriver(), cookieClient, {});
+    }
+    /**
+     * Creates a new session instance for a given HTTP request
+     */
+    create(ctx) {
+        return new Session(ctx, this.#config, this.#createDriver(ctx));
+    }
+    /**
+     * Extend the drivers list by adding a new one.
+     */
+    extend(driver, callback) {
+        this.#extendedDrivers.set(driver, callback);
+    }
+}

package/build/src/session_middleware.d.ts

@@ -0,0 +1,5 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { NextFn } from '@adonisjs/core/types/http';
+export default class SessionMiddleware {
+    handle(ctx: HttpContext, next: NextFn): Promise<void>;
+}

package/build/src/session_middleware.js

@@ -0,0 +1,20 @@
+export default class SessionMiddleware {
+    async handle(ctx, next) {
+        const sessionManager = (await ctx.containerResolver.make('session'));
+        if (!sessionManager.isEnabled()) {
+            return;
+        }
+        /**
+         * Initiate session store
+         */
+        await ctx.session.initiate(false);
+        /**
+         * Call next middlewares or route handler
+         */
+        await next();
+        /**
+         * Commit store mutations
+         */
+        await ctx.session.commit();
+    }
+}

package/build/src/{Store/index.d.ts → store.d.ts}

@@ -1,13 +1,9 @@
-/// <reference path="../../adonis-typings/index.d.ts" />
-import { AllowedSessionValues, StoreContract } from '@ioc:Adonis/Addons/Session';
+import type { AllowedSessionValues } from './types.js';
 /**
  * Session store to mutate and access values from the session object
  */
-export declare class Store implements StoreContract {
-    /**
-     * Underlying store values
-     */
-    private values;
+export declare class Store {
+    #private;
     constructor(values: {
         [key: string]: any;
     } | null);

package/build/src/{Store/index.js → store.js}

@@ -1,46 +1,47 @@
-"use strict";
 /*
  * @adonisjs/redis
  *
- * (c) Harminder Virk <virk@adonisjs.com>
+ * (c) AdonisJS
  *
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Store = void 0;
-/// <reference path="../../adonis-typings/index.ts" />
-const utils_1 = require("@poppinss/utils");
+import { Exception } from '@poppinss/utils';
+import lodash from '@poppinss/utils/lodash';
 /**
  * Session store to mutate and access values from the session object
  */
-class Store {
+export class Store {
+    /**
+     * Underlying store values
+     */
+    #values;
     constructor(values) {
-        this.values = values || {};
+        this.#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) {
-        utils_1.lodash.set(this.values, key, value);
+        lodash.set(this.#values, key, value);
     }
     /**
      * Get value for a given key
      */
     get(key, defaultValue) {
-        return utils_1.lodash.get(this.values, key, defaultValue);
+        return lodash.get(this.#values, key, defaultValue);
     }
     /**
      * Remove key
      */
     unset(key) {
-        utils_1.lodash.unset(this.values, key);
+        lodash.unset(this.#values, key);
     }
     /**
      * Reset store by clearing it's values.
@@ -65,7 +66,7 @@ class Store {
     increment(key, steps = 1) {
         const value = this.get(key, 0);
         if (typeof value !== 'number') {
-            throw new utils_1.Exception(`Cannot increment "${key}", since original value is not a number`);
+            throw new Exception(`Cannot increment "${key}", since original value is not a number`);
         }
         this.set(key, value + steps);
     }
@@ -76,7 +77,7 @@ class Store {
     decrement(key, steps = 1) {
         const value = this.get(key, 0);
         if (typeof value !== 'number') {
-            throw new utils_1.Exception(`Cannot increment "${key}", since original value is not a number`);
+            throw new Exception(`Cannot increment "${key}", since original value is not a number`);
         }
         this.set(key, value - steps);
     }
@@ -84,13 +85,13 @@ class Store {
      * Overwrite the underlying values object
      */
     update(values) {
-        this.values = values;
+        this.#values = values;
     }
     /**
      * Update to merge values
      */
     merge(values) {
-        utils_1.lodash.merge(this.values, values);
+        lodash.merge(this.#values, values);
     }
     /**
      * A boolean to know if value exists. Extra guards to check
@@ -107,7 +108,7 @@ class Store {
      * Get all values
      */
     all() {
-        return this.values;
+        return this.#values;
     }
     /**
      * Returns object representation of values
@@ -128,4 +129,3 @@ class Store {
         return JSON.stringify(this.all());
     }
 }
-exports.Store = Store;

package/build/src/types.d.ts

@@ -0,0 +1,61 @@
+import type { CookieOptions } from '@adonisjs/core/types/http';
+import type { SessionManager } from './session_manager.js';
+import type { HttpContext } from '@adonisjs/core/http';
+/**
+ * The callback to be passed to the `extend` method. It is invoked
+ * for each request (if extended driver is in use).
+ */
+export type ExtendCallback = (manager: SessionManager, config: SessionConfig, ctx: HttpContext) => SessionDriverContract;
+/**
+ * Shape of a driver that every session driver must have
+ */
+export interface SessionDriverContract {
+    read(sessionId: string): Promise<Record<string, any> | null> | Record<string, any> | null;
+    write(sessionId: string, values: Record<string, any>): Promise<void> | void;
+    destroy(sessionId: string): Promise<void> | void;
+    touch(sessionId: string): Promise<void> | void;
+}
+/**
+ * Shape of session config.
+ */
+export interface SessionConfig {
+    /**
+     * Enable/disable session for the entire application lifecycle
+     */
+    enabled: boolean;
+    /**
+     * The driver in play
+     */
+    driver: string;
+    /**
+     * Cookie name.
+     */
+    cookieName: string;
+    /**
+     * Clear session when browser closes
+     */
+    clearWithBrowser: boolean;
+    /**
+     * Age of session cookie
+     */
+    age: string | number;
+    /**
+     * Config for the cookie driver and also the session id
+     * cookie
+     */
+    cookie: Omit<Partial<CookieOptions>, 'maxAge' | 'expires'>;
+    /**
+     * Config for the file driver
+     */
+    file?: {
+        location: string;
+    };
+    /**
+     * The redis connection to use from the `config/redis` file
+     */
+    redisConnection?: string;
+}
+/**
+ * The values allowed by the `session.put` method
+ */
+export type AllowedSessionValues = string | boolean | number | object | Date | Array<any>;

package/build/src/types.js

@@ -0,0 +1 @@
+export {};

package/build/{templates/session.txt → stubs/config.stub}

@@ -1,15 +1,12 @@
-/**
- * Config source: https://git.io/JeYHp
- *
- * Feel free to let us know via PR, if you find something broken in this config
- * file.
- */
+---
+to: {{ app.configPath('session.ts') }}
+---
 
-import Env from '@ioc:Adonis/Core/Env'
-import Application from '@ioc:Adonis/Core/Application'
-import { sessionConfig } from '@adonisjs/session/build/config'
+import env from '#start/env'
+import app from '@adonisjs/core/services/app'
+import { defineConfig } from '@adonisjs/session'
 
-export default sessionConfig({
+export default defineConfig({
   /*
   |--------------------------------------------------------------------------
   | Enable/Disable sessions
@@ -36,7 +33,7 @@ export default sessionConfig({
   | Note: Switching drivers will make existing sessions invalid.
   |
   */
-  driver: Env.get('SESSION_DRIVER'),
+  driver: env.get('SESSION_DRIVER'),
 
   /*
   |--------------------------------------------------------------------------
@@ -54,7 +51,7 @@ export default sessionConfig({
   |--------------------------------------------------------------------------
   |
   | Whether or not you want to destroy the session when browser closes. Setting
-  | this value to `true` will ignore the `age`.
+  | this value to "true" will ignore the "age".
   |
   */
   clearWithBrowser: false,
@@ -70,7 +67,7 @@ export default sessionConfig({
   | 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.
+  | Example: "2 days", "2.5 hrs", "1y", "5s" and so on.
   |
   */
   age: '2h',
@@ -100,7 +97,7 @@ export default sessionConfig({
   |
   */
   file: {
-    location: Application.tmpPath('sessions'),
+    location: app.tmpPath('sessions'),
   },
 
   /*
@@ -109,7 +106,7 @@ export default sessionConfig({
   |--------------------------------------------------------------------------
   |
   | The redis connection you want session driver to use. The same connection
-  | must be defined inside `config/redis.ts` file as well.
+  | must be defined inside "config/redis.ts" file as well.
   |
   */
   redisConnection: 'local',

package/build/stubs/main.d.ts

@@ -0,0 +1 @@
+export declare const stubsRoot: string;

package/build/{adonis-typings/tests.js → stubs/main.js}

@@ -1,4 +1,3 @@
-"use strict";
 /*
  * @adonisjs/session
  *
@@ -7,5 +6,5 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-require("@japa/api-client");
+import { getDirname } from '@poppinss/utils';
+export const stubsRoot = getDirname(import.meta.url);