@adonisjs/session 7.5.0 → 8.0.0-next.0

package/build/{chunk-TZLOND27.js → chunk-DFXWYDMY.js}

@@ -1,25 +1,44 @@
 import {
   Session
-} from "./chunk-OCQGCVXK.js";
+} from "./chunk-SHD6OX52.js";
 
 // src/session_middleware.ts
 import { ExceptionHandler } from "@adonisjs/core/http";
 var originalErrorHandler = ExceptionHandler.prototype.renderValidationErrorAsHTML;
 ExceptionHandler.macro("renderValidationErrorAsHTML", async function(error, ctx) {
   if (ctx.session) {
-    ctx.session.flashValidationErrors(error);
+    const withInput = ctx.request.header("X-Inertia") ? false : true;
+    ctx.session.flashValidationErrors(error, withInput);
     ctx.response.redirect("back", true);
   } else {
     return originalErrorHandler(error, ctx);
   }
 });
 var SessionMiddleware = class {
+  /**
+   * Session configuration including store settings
+   */
   #config;
+  /**
+   * Event emitter service for session events
+   */
   #emitter;
+  /**
+   * Creates a new session middleware instance
+   *
+   * @param config - Session configuration with store settings
+   * @param emitter - Event emitter service
+   */
   constructor(config, emitter) {
     this.#config = config;
     this.#emitter = emitter;
   }
+  /**
+   * Handles the HTTP request by initializing session and committing changes
+   *
+   * @param ctx - HTTP context
+   * @param next - Next middleware function
+   */
   async handle(ctx, next) {
     if (!this.#config.enabled) {
       return next();
@@ -41,4 +60,3 @@ var SessionMiddleware = class {
 export {
   SessionMiddleware
 };
-//# sourceMappingURL=chunk-TZLOND27.js.map

package/build/chunk-HAD4PFFM.js

@@ -0,0 +1,229 @@
+// src/values_store.ts
+import lodash from "@poppinss/utils/lodash";
+import { RuntimeException } from "@adonisjs/core/exceptions";
+var ReadOnlyValuesStore = class {
+  /**
+   * Underlying store values containing session data
+   */
+  values;
+  /**
+   * Returns true if the store is empty
+   */
+  get isEmpty() {
+    return !this.values || Object.keys(this.values).length === 0;
+  }
+  /**
+   * Creates a new readonly values store
+   *
+   * @param values - Initial session data or null
+   */
+  constructor(values) {
+    this.values = values || {};
+  }
+  /**
+   * Gets value for a given key
+   *
+   * @param key - The key or key path to retrieve
+   * @param defaultValue - Default value if key doesn't exist
+   *
+   * @example
+   * store.get('username', 'guest')
+   * store.get(['user', 'preferences', 'theme'], 'light')
+   */
+  get(key, defaultValue) {
+    const value = lodash.get(this.values, key);
+    if (defaultValue !== void 0 && (value === null || value === void 0)) {
+      return defaultValue;
+    }
+    return value;
+  }
+  /**
+   * Checks if a value exists. Includes extra guards to check arrays for length.
+   *
+   * @param key - The key or key path to check
+   * @param checkForArraysLength - Whether to check array length (default: true)
+   *
+   * @example
+   * store.has('username')                    // Check if key exists
+   * store.has(['user', 'roles'])            // Check nested key
+   * store.has('items', false)               // Don't check array length
+   */
+  has(key, checkForArraysLength = true) {
+    const value = this.get(key);
+    if (!Array.isArray(value)) {
+      return !!value;
+    }
+    return checkForArraysLength ? value.length > 0 : !!value;
+  }
+  /**
+   * Gets all values from the store
+   *
+   * @example
+   * const allData = store.all()
+   */
+  all() {
+    return this.values;
+  }
+  /**
+   * Returns object representation of values
+   *
+   * @example
+   * const obj = store.toObject()
+   */
+  toObject() {
+    return this.all();
+  }
+  /**
+   * Returns the store values as JSON-serializable data
+   *
+   * @example
+   * const json = store.toJSON()
+   */
+  toJSON() {
+    return this.all();
+  }
+  /**
+   * Returns string representation of the store
+   *
+   * @example
+   * const str = store.toString()
+   */
+  toString() {
+    return JSON.stringify(this.all());
+  }
+};
+var ValuesStore = class extends ReadOnlyValuesStore {
+  /**
+   * Flag to track if the store has been modified
+   */
+  #modified = false;
+  /**
+   * Creates a new values store
+   *
+   * @param values - Initial session data or null
+   */
+  constructor(values) {
+    super(values);
+  }
+  /**
+   * Returns true if the store has been modified
+   */
+  get hasBeenModified() {
+    return this.#modified;
+  }
+  /**
+   * Sets a key/value pair in the store
+   *
+   * @param key - The key or key path to set
+   * @param value - The value to set
+   *
+   * @example
+   * store.set('username', 'john')
+   * store.set(['user', 'preferences'], { theme: 'dark' })
+   */
+  set(key, value) {
+    this.#modified = true;
+    lodash.set(this.values, key, value);
+  }
+  /**
+   * Removes a key from the store
+   *
+   * @param key - The key or key path to remove
+   *
+   * @example
+   * store.unset('temp_data')
+   * store.unset(['user', 'cache'])
+   */
+  unset(key) {
+    this.#modified = true;
+    lodash.unset(this.values, key);
+  }
+  /**
+   * Pulls value from the store. Same as calling store.get then store.unset.
+   *
+   * @param key - The key or key path to pull
+   * @param defaultValue - Default value if key doesn't exist
+   *
+   * @example
+   * const message = store.pull('notification', 'No messages')
+   * const data = store.pull(['temp', 'data'])
+   */
+  pull(key, defaultValue) {
+    return ((value) => {
+      this.unset(key);
+      return value;
+    })(this.get(key, defaultValue));
+  }
+  /**
+   * Increments a numeric value. Raises an error when underlying value is not a number.
+   *
+   * @param key - The key or key path to increment
+   * @param steps - Number of steps to increment (default: 1)
+   *
+   * @example
+   * store.increment('page_views')     // Increments by 1
+   * store.increment('score', 10)      // Increments by 10
+   */
+  increment(key, steps = 1) {
+    const value = this.get(key, 0);
+    if (typeof value !== "number") {
+      throw new RuntimeException(`Cannot increment "${key}". Existing value is not a number`);
+    }
+    this.set(key, value + steps);
+  }
+  /**
+   * Decrements a numeric value. Raises an error when underlying value is not a number.
+   *
+   * @param key - The key or key path to decrement
+   * @param steps - Number of steps to decrement (default: 1)
+   *
+   * @example
+   * store.decrement('attempts')       // Decrements by 1
+   * store.decrement('credits', 5)     // Decrements by 5
+   */
+  decrement(key, steps = 1) {
+    const value = this.get(key, 0);
+    if (typeof value !== "number") {
+      throw new RuntimeException(`Cannot decrement "${key}". Existing value is not a number`);
+    }
+    this.set(key, value - steps);
+  }
+  /**
+   * Overwrites existing store data with new values
+   *
+   * @param values - New values to replace existing data
+   *
+   * @example
+   * store.update({ username: 'jane', theme: 'light' })
+   */
+  update(values) {
+    this.#modified = true;
+    this.values = values;
+  }
+  /**
+   * Merges values with existing store data
+   *
+   * @param values - Values to merge with existing data
+   *
+   * @example
+   * store.merge({ newField: 'value', existingField: 'updated' })
+   */
+  merge(values) {
+    this.#modified = true;
+    lodash.merge(this.values, values);
+  }
+  /**
+   * Resets store by clearing all values
+   *
+   * @example
+   * store.clear() // Removes all data from store
+   */
+  clear() {
+    this.update({});
+  }
+};
+
+export {
+  ReadOnlyValuesStore,
+  ValuesStore
+};

package/build/{chunk-WUWXIKIB.js → chunk-MVBWJOEG.js}

@@ -1,10 +1,9 @@
 import {
   debug_default
-} from "./chunk-ZVSEMDIC.js";
+} from "./chunk-SBOMJK4T.js";
 
 // stubs/main.ts
-import { getDirname } from "@poppinss/utils";
-var stubsRoot = getDirname(import.meta.url);
+var stubsRoot = import.meta.dirname;
 
 // configure.ts
 async function configure(command) {
@@ -28,32 +27,56 @@ async function configure(command) {
 }
 
 // src/define_config.ts
-import string from "@poppinss/utils/string";
 import { configProvider } from "@adonisjs/core";
-import { InvalidArgumentsException } from "@poppinss/utils";
+import string from "@adonisjs/core/helpers/string";
+import { InvalidArgumentsException } from "@adonisjs/core/exceptions";
 
 // src/stores/memory.ts
 var MemoryStore = class _MemoryStore {
+  /**
+   * Static map to store all session data in memory
+   */
   static sessions = /* @__PURE__ */ new Map();
   /**
-   * Read session id value from the memory
+   * Reads session value from memory
+   *
+   * @param sessionId - Session identifier
+   *
+   * @example
+   * const data = store.read('sess_abc123')
    */
   read(sessionId) {
     return _MemoryStore.sessions.get(sessionId) || null;
   }
   /**
-   * Save in memory value for a given session id
+   * Saves session value in memory for a given session id
+   *
+   * @param sessionId - Session identifier
+   * @param values - Session data to store
+   *
+   * @example
+   * store.write('sess_abc123', { userId: 123, theme: 'dark' })
    */
   write(sessionId, values) {
     _MemoryStore.sessions.set(sessionId, values);
   }
   /**
-   * Cleanup for a single session
+   * Removes a single session from memory
+   *
+   * @param sessionId - Session identifier to remove
+   *
+   * @example
+   * store.destroy('sess_abc123')
    */
   destroy(sessionId) {
     _MemoryStore.sessions.delete(sessionId);
   }
-  touch() {
+  /**
+   * No-op for memory store as there's no expiry mechanism
+   *
+   * @param sessionId - Session identifier (unused)
+   */
+  touch(_) {
   }
 };
 
@@ -98,34 +121,52 @@ function defineConfig(config) {
   });
 }
 var stores = {
+  /**
+   * Creates a file-based session store
+   *
+   * @param config - File store configuration
+   */
   file: (config) => {
     return configProvider.create(async () => {
-      const { FileStore } = await import("./file-B6QKOZXW.js");
+      const { FileStore } = await import("./file-CCJ5ESE2.js");
       return (_, sessionConfig) => {
         return new FileStore(config, sessionConfig.age);
       };
     });
   },
+  /**
+   * Creates a Redis-based session store
+   *
+   * @param config - Redis store configuration
+   */
   redis: (config) => {
     return configProvider.create(async (app) => {
-      const { RedisStore } = await import("./redis-CAY24YIA.js");
+      const { RedisStore } = await import("./redis-NXJWWWVB.js");
       const redis = await app.container.make("redis");
       return (_, sessionConfig) => {
         return new RedisStore(redis.connection(config.connection), sessionConfig.age);
       };
     });
   },
+  /**
+   * Creates a cookie-based session store
+   */
   cookie: () => {
     return configProvider.create(async () => {
-      const { CookieStore } = await import("./cookie-WBWYVEDW.js");
+      const { CookieStore } = await import("./cookie-YBBGLCO5.js");
       return (ctx, sessionConfig) => {
         return new CookieStore(sessionConfig.cookie, ctx);
       };
     });
   },
+  /**
+   * Creates a DynamoDB-based session store
+   *
+   * @param config - DynamoDB store configuration
+   */
   dynamodb: (config) => {
     return configProvider.create(async () => {
-      const { DynamoDBStore } = await import("./dynamodb-3PG52TE3.js");
+      const { DynamoDBStore } = await import("./dynamodb-PLZABBFD.js");
       const { DynamoDBClient } = await import("@aws-sdk/client-dynamodb");
       const client = "clientConfig" in config ? new DynamoDBClient(config.clientConfig) : config.client;
       return (_, sessionConfig) => {
@@ -144,4 +185,3 @@ export {
   defineConfig,
   stores
 };
-//# sourceMappingURL=chunk-WUWXIKIB.js.map

package/build/{chunk-ZVSEMDIC.js → chunk-SBOMJK4T.js}

@@ -5,11 +5,10 @@ var __export = (target, all) => {
 };
 
 // src/debug.ts
-import { debuglog } from "node:util";
+import { debuglog } from "util";
 var debug_default = debuglog("adonisjs:session");
 
 export {
   __export,
   debug_default
 };
-//# sourceMappingURL=chunk-ZVSEMDIC.js.map