@adonisjs/session 7.0.0-2 → 7.0.0-4

package/build/src/drivers/file.js

@@ -7,28 +7,30 @@
  * file that was distributed with this source code.
  */
 import { dirname, join } from 'node:path';
-import { access, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { Exception } from '@poppinss/utils';
-import { MessageBuilder } from '@poppinss/utils';
+import string from '@poppinss/utils/string';
+import { MessageBuilder } from '@adonisjs/core/helpers';
+import { access, mkdir, readFile, rm, writeFile, utimes, stat } from 'node:fs/promises';
+import debug from '../debug.js';
 /**
- * File driver to read/write session to filesystem
+ * File driver writes the session data on the file system as. Each session
+ * id gets its own file.
  */
 export class FileDriver {
     #config;
-    constructor(config) {
+    #age;
+    constructor(config, age) {
         this.#config = config;
-        if (!this.#config.file || !this.#config.file.location) {
-            throw new Exception('Missing "file.location" for session file driver inside "config/session" file', { code: 'E_INVALID_SESSION_DRIVER_CONFIG', status: 500 });
-        }
+        this.#age = age;
+        debug('initiating file driver %O', this.#config);
     }
     /**
-     * Returns complete path to the session file
+     * Returns an absolute path to the session id file
      */
     #getFilePath(sessionId) {
-        return join(this.#config.file.location, `${sessionId}.txt`);
+        return join(this.#config.location, `${sessionId}.txt`);
     }
     /**
-     * Check if the given path exists or not
+     * Check if a file exists at a given path or not
      */
     async #pathExists(path) {
         try {
@@ -40,71 +42,92 @@ export class FileDriver {
         }
     }
     /**
-     * Output file with contents to the given path
+     * Returns stats for a file and ignoring missing
+     * files.
      */
-    async #outputFile(path, content) {
-        const pathDirname = dirname(path);
-        const dirExists = await this.#pathExists(pathDirname);
-        if (!dirExists) {
-            await mkdir(pathDirname, { recursive: true });
+    async #stats(path) {
+        try {
+            const stats = await stat(path);
+            return stats;
+        }
+        catch {
+            return null;
         }
-        await writeFile(path, content, 'utf-8');
     }
     /**
-     * Ensure the file exists. Create it if missing
+     * Output file with contents to the given path
      */
-    async #ensureFile(path) {
+    async #outputFile(path, contents) {
         const pathDirname = dirname(path);
         const dirExists = await this.#pathExists(pathDirname);
         if (!dirExists) {
             await mkdir(pathDirname, { recursive: true });
-            await writeFile(path, '', 'utf-8');
         }
+        await writeFile(path, contents, 'utf-8');
     }
     /**
-     * Returns file contents. A new file will be created if it's
-     * missing.
+     * Reads the session data from the disk.
      */
     async read(sessionId) {
         const filePath = this.#getFilePath(sessionId);
-        await this.#ensureFile(filePath);
-        const contents = await readFile(filePath, 'utf-8');
-        if (!contents.trim()) {
+        debug('file driver: reading session data %', sessionId);
+        /**
+         * Return null when no session id file exists in first
+         * place
+         */
+        const stats = await this.#stats(filePath);
+        if (!stats) {
             return null;
         }
         /**
-         * Verify contents with the session id and return them as an object.
+         * Check if the file has been expired and return null (if expired)
          */
-        const verifiedContents = new MessageBuilder().verify(contents.trim(), sessionId);
-        if (typeof verifiedContents !== 'object') {
+        const sessionWillExpireAt = stats.mtimeMs + string.milliseconds.parse(this.#age);
+        if (Date.now() > sessionWillExpireAt) {
+            debug('file driver: expired session data %s', sessionId);
+            return null;
+        }
+        /**
+         * Reading the file contents if the file exists
+         */
+        let contents = await readFile(filePath, 'utf-8');
+        contents = contents.trim();
+        if (!contents) {
+            return null;
+        }
+        /**
+         * Verify contents with the session id and return them as an object. The verify
+         * method can fail when the contents is not JSON>
+         */
+        try {
+            return new MessageBuilder().verify(contents, sessionId);
+        }
+        catch {
             return null;
         }
-        return verifiedContents;
     }
     /**
-     * Write session values to a file
+     * Writes the session data to the disk as a string
      */
     async write(sessionId, values) {
-        if (typeof values !== 'object') {
-            throw new Error('Session file driver expects an object of values');
-        }
+        debug('file driver: writing session data %s: %O', sessionId, values);
+        const filePath = this.#getFilePath(sessionId);
         const message = new MessageBuilder().build(values, undefined, sessionId);
-        await this.#outputFile(this.#getFilePath(sessionId), message);
+        await this.#outputFile(filePath, message);
     }
     /**
-     * Cleanup session file by removing it
+     * Removes the session file from the disk
      */
     async destroy(sessionId) {
+        debug('file driver: destroying session data %s', sessionId);
         await rm(this.#getFilePath(sessionId), { force: true });
     }
     /**
-     * Writes the value by reading it from the store
+     * Updates the session expiry by rewriting it to the
+     * persistence store
      */
     async touch(sessionId) {
-        const value = await this.read(sessionId);
-        if (!value) {
-            return;
-        }
-        await this.write(sessionId, value);
+        debug('file driver: touching session data %s', sessionId);
+        await utimes(this.#getFilePath(sessionId), new Date(), new Date());
     }
 }

package/build/src/drivers/memory.d.ts

@@ -6,24 +6,20 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import { SessionDriverContract } from '../types.js';
+import type { SessionData, SessionDriverContract } from '../types/main.js';
 /**
  * Memory driver is meant to be used for writing tests.
  */
 export declare class MemoryDriver implements SessionDriverContract {
-    static sessions: Map<string, Object>;
+    static sessions: Map<string, SessionData>;
     /**
      * Read session id value from the memory
      */
-    read(sessionId: string): {
-        [key: string]: any;
-    } | null;
+    read(sessionId: string): SessionData | null;
     /**
      * Save in memory value for a given session id
      */
-    write(sessionId: string, values: {
-        [key: string]: any;
-    }): void;
+    write(sessionId: string, values: SessionData): void;
     /**
      * Cleanup for a single session
      */

package/build/src/drivers/memory.js

@@ -21,9 +21,6 @@ export class MemoryDriver {
      * Save in memory value for a given session id
      */
     write(sessionId, values) {
-        if (typeof values !== 'object') {
-            throw new Error('Session memory driver expects an object of values');
-        }
         MemoryDriver.sessions.set(sessionId, values);
     }
     /**

package/build/src/drivers/redis.d.ts

@@ -6,21 +6,19 @@
  * For the full copyright and license information, please view the LICENSE
  * file that was distributed with this source code.
  */
-import type { RedisManagerContract } from '@adonisjs/redis/types';
-import type { SessionDriverContract, SessionConfig } from '../types.js';
+import type { RedisService } from '@adonisjs/redis/types';
+import type { SessionDriverContract, RedisDriverConfig, SessionData } from '../types/main.js';
 /**
  * File driver to read/write session to filesystem
  */
 export declare class RedisDriver implements SessionDriverContract {
     #private;
-    constructor(config: SessionConfig, redis: RedisManagerContract<any>);
+    constructor(redis: RedisService, config: RedisDriverConfig, age: string | number);
     /**
      * Returns file contents. A new file will be created if it's
      * missing.
      */
-    read(sessionId: string): Promise<{
-        [key: string]: any;
-    } | null>;
+    read(sessionId: string): Promise<SessionData | null>;
     /**
      * Write session values to a file
      */

package/build/src/drivers/redis.js

@@ -6,69 +6,65 @@
  * 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 string from '@poppinss/utils/string';
-import { MessageBuilder } from '@poppinss/utils';
+import { MessageBuilder } from '@adonisjs/core/helpers';
+import debug from '../debug.js';
 /**
  * File driver to read/write session to filesystem
  */
 export class RedisDriver {
     #config;
     #redis;
-    #ttl;
-    constructor(config, redis) {
+    #ttlSeconds;
+    constructor(redis, config, age) {
         this.#config = config;
         this.#redis = redis;
-        /**
-         * Convert milliseconds to seconds
-         */
-        this.#ttl = Math.round((typeof this.#config.age === 'string'
-            ? string.milliseconds.parse(this.#config.age)
-            : this.#config.age) / 1000);
-        if (!this.#config.redisConnection) {
-            throw new Exception('Missing redisConnection for session redis driver inside "config/session" file', { code: 'E_INVALID_SESSION_DRIVER_CONFIG', status: 500 });
-        }
-    }
-    /**
-     * Returns instance of the redis connection
-     */
-    #getRedisConnection() {
-        return this.#redis.connection(this.#config.redisConnection);
+        this.#ttlSeconds = string.seconds.parse(age);
+        debug('initiating redis driver %O', this.#config);
     }
     /**
      * Returns file contents. A new file will be created if it's
      * missing.
      */
     async read(sessionId) {
-        const contents = await this.#getRedisConnection().get(sessionId);
+        debug('redis driver: reading session data %s', sessionId);
+        const contents = await this.#redis.connection(this.#config.connection).get(sessionId);
         if (!contents) {
             return null;
         }
-        const verifiedContents = new MessageBuilder().verify(contents, sessionId);
-        if (typeof verifiedContents !== 'object') {
+        /**
+         * Verify contents with the session id and return them as an object. The verify
+         * method can fail when the contents is not JSON>
+         */
+        try {
+            return new MessageBuilder().verify(contents, sessionId);
+        }
+        catch {
             return null;
         }
-        return verifiedContents;
     }
     /**
      * Write session values to a file
      */
     async write(sessionId, values) {
-        if (typeof values !== 'object') {
-            throw new Error('Session file driver expects an object of values');
-        }
-        await this.#getRedisConnection().setex(sessionId, this.#ttl, new MessageBuilder().build(values, undefined, sessionId));
+        debug('redis driver: writing session data %s, %O', sessionId, values);
+        const message = new MessageBuilder().build(values, undefined, sessionId);
+        await this.#redis
+            .connection(this.#config.connection)
+            .setex(sessionId, this.#ttlSeconds, message);
     }
     /**
      * Cleanup session file by removing it
      */
     async destroy(sessionId) {
-        await this.#getRedisConnection().del(sessionId);
+        debug('redis driver: destroying session data %s', sessionId);
+        await this.#redis.connection(this.#config.connection).del(sessionId);
     }
     /**
      * Updates the value expiry
      */
     async touch(sessionId) {
-        await this.#getRedisConnection().expire(sessionId, this.#ttl);
+        debug('redis driver: touching session data %s', sessionId);
+        await this.#redis.connection(this.#config.connection).expire(sessionId, this.#ttlSeconds);
     }
 }

package/build/src/drivers_collection.d.ts

@@ -0,0 +1,22 @@
+import type { HttpContext } from '@adonisjs/core/http';
+import type { SessionDriversList } from './types/main.js';
+/**
+ * A global collection of session drivers
+ */
+declare class SessionDriversCollection {
+    /**
+     * List of registered drivers
+     */
+    list: Partial<SessionDriversList>;
+    /**
+     * Extend drivers collection and add a custom
+     * driver to it.
+     */
+    extend<Name extends keyof SessionDriversList>(driverName: Name, factoryCallback: SessionDriversList[Name]): this;
+    /**
+     * Creates the driver instance with config
+     */
+    create<Name extends keyof SessionDriversList>(name: Name, config: Parameters<SessionDriversList[Name]>[0], ctx: HttpContext): ReturnType<SessionDriversList[Name]>;
+}
+declare const sessionDriversList: SessionDriversCollection;
+export default sessionDriversList;

package/build/src/drivers_collection.js

@@ -0,0 +1,38 @@
+/*
+ * @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';
+/**
+ * A global collection of session drivers
+ */
+class SessionDriversCollection {
+    /**
+     * List of registered drivers
+     */
+    list = {};
+    /**
+     * Extend drivers collection and add a custom
+     * driver to it.
+     */
+    extend(driverName, factoryCallback) {
+        this.list[driverName] = factoryCallback;
+        return this;
+    }
+    /**
+     * Creates the driver instance with config
+     */
+    create(name, config, ctx) {
+        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);
+    }
+}
+const sessionDriversList = new SessionDriversCollection();
+export default sessionDriversList;

package/build/src/errors.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Raised when session store is not mutable
+ */
+export declare const E_SESSION_NOT_MUTABLE: new (args?: any, options?: ErrorOptions | undefined) => import("@poppinss/utils").Exception;
+/**
+ * Raised when session store has been initiated
+ */
+export declare const E_SESSION_NOT_READY: new (args?: any, options?: ErrorOptions | undefined) => import("@poppinss/utils").Exception;

package/build/src/errors.js

@@ -0,0 +1,17 @@
+/*
+ * @adonisjs/session
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+import { createError } from '@poppinss/utils';
+/**
+ * Raised when session store is not mutable
+ */
+export const E_SESSION_NOT_MUTABLE = createError('Session store is in readonly mode and cannot be mutated', 'E_SESSION_NOT_MUTABLE', 500);
+/**
+ * Raised when session store has been initiated
+ */
+export const E_SESSION_NOT_READY = createError('Session store has not been initiated. Make sure you have registered the session middleware', 'E_SESSION_NOT_READY', 500);

package/build/src/helpers.d.ts

@@ -0,0 +1,6 @@
+import type { ApplicationService } from '@adonisjs/core/types';
+import type { SessionDriversList } from './types/main.js';
+/**
+ * Lazily imports and registers a driver with the sessionDriversList
+ */
+export declare function registerSessionDriver(app: ApplicationService, driverInUse: keyof SessionDriversList): Promise<void>;

package/build/src/helpers.js

@@ -0,0 +1,43 @@
+/*
+ * @adonisjs/session
+ *
+ * (c) AdonisJS
+ *
+ * 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 sessionDriversList from './drivers_collection.js';
+/**
+ * Lazily imports and registers a driver with the sessionDriversList
+ */
+export async function registerSessionDriver(app, driverInUse) {
+    /**
+     * Noop when the driver is already registered
+     */
+    if (sessionDriversList.list[driverInUse]) {
+        return;
+    }
+    debug('registering %s driver', driverInUse);
+    if (driverInUse === 'cookie') {
+        const { CookieDriver } = await import('../src/drivers/cookie.js');
+        sessionDriversList.extend('cookie', (config, ctx) => new CookieDriver(config.cookie, ctx));
+        return;
+    }
+    if (driverInUse === 'memory') {
+        const { MemoryDriver } = await import('../src/drivers/memory.js');
+        sessionDriversList.extend('memory', () => new MemoryDriver());
+        return;
+    }
+    if (driverInUse === 'file') {
+        const { FileDriver } = await import('../src/drivers/file.js');
+        sessionDriversList.extend('file', (config) => new FileDriver(config.file, config.age));
+        return;
+    }
+    if (driverInUse === 'redis') {
+        const { RedisDriver } = await import('../src/drivers/redis.js');
+        const redis = await app.container.make('redis');
+        sessionDriversList.extend('redis', (config) => new RedisDriver(redis, config.redis, config.age));
+        return;
+    }
+}