@depup/catbox 10.0.6-depup.0

package/.npmignore

@@ -0,0 +1,3 @@
+*
+!lib/**
+!.npmignore

package/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2012-2018, Project contributors
+Copyright (c) 2012-2014, Walmart
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * The names of any contributors may not be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,33 @@
+# @depup/catbox
+
+> Dependency-bumped version of [catbox](https://www.npmjs.com/package/catbox)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/catbox
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [catbox](https://www.npmjs.com/package/catbox) @ 10.0.6 |
+| Processed | 2026-03-17 |
+| Smoke test | passed |
+| Deps updated | 3 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| boom | 7.x.x | ^7.3.0 |
+| hoek | 6.x.x | ^6.1.3 |
+| joi | 14.x.x | ^18.0.2 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/catbox
+
+License inherited from the original package.

package/lib/client.js

@@ -0,0 +1,118 @@
+'use strict';
+
+// Load modules
+
+const Hoek = require('hoek');
+const Boom = require('boom');
+
+
+// Declare internals
+
+const internals = {
+    validate: Symbol('validate')
+};
+
+
+internals.defaults = {
+    partition: 'catbox'
+};
+
+
+module.exports = class {
+
+    constructor(engine, options) {
+
+        Hoek.assert(engine, 'Missing catbox client engine');
+        Hoek.assert(typeof engine === 'object' || typeof engine === 'function', 'engine must be an engine object or engine prototype (function)');
+        Hoek.assert(typeof engine === 'function' || !options, 'Can only specify options with function engine config');
+
+        const settings = Object.assign({}, internals.defaults, options);
+        Hoek.assert(settings.partition.match(/^[\w\-]+$/), 'Invalid partition name:' + settings.partition);
+
+        this.connection = (typeof engine === 'object' ? engine : new engine(settings));
+    }
+
+    async start() {
+
+        await this.connection.start();
+    }
+
+    async stop() {
+
+        await this.connection.stop();
+    }
+
+    isReady() {
+
+        return this.connection.isReady();
+    }
+
+    validateSegmentName(name) {
+
+        return this.connection.validateSegmentName(name);
+    }
+
+    async get(key) {
+
+        this[internals.validate](key, null);
+
+        if (key === null) {
+            return null;
+        }
+
+        const result = await this.connection.get(key);
+        if (!result ||
+            result.item === undefined ||
+            result.item === null) {
+
+            return null;                                                        // Not found
+        }
+
+        const now = Date.now();
+        const expires = result.stored + result.ttl;
+        const ttl = expires - now;
+        if (ttl <= 0) {
+            return null;                                                        // Expired
+        }
+
+        const cached = {
+            item: result.item,
+            stored: result.stored,
+            ttl
+        };
+
+        return cached;                                                          // Valid
+    }
+
+    async set(key, value, ttl) {
+
+        this[internals.validate](key);
+
+        if (ttl <= 0) {
+            return;                                                             // Not cachable (or bad rules)
+        }
+
+        await this.connection.set(key, value, ttl);
+    }
+
+    async drop(key) {
+
+        this[internals.validate](key);
+
+        await this.connection.drop(key);                                       // Always drop, regardless of caching rules
+    }
+
+    [internals.validate](key, allow = {}) {
+
+        if (!this.isReady()) {
+            throw Boom.internal('Disconnected');                                // Disconnected
+        }
+
+        const isValidKey = (key && typeof key.id === 'string' &&
+                            key.segment && typeof key.segment === 'string');
+
+        if (!isValidKey && key !== allow) {
+            throw Boom.internal('Invalid key');
+        }
+    }
+};

package/lib/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+// Load modules
+
+const Client = require('./client');
+const Policy = require('./policy');
+
+
+// Declare internals
+
+const internals = {};
+
+
+exports.Client = Client;
+
+
+exports.Policy = exports.policy = Policy;

package/lib/pending.js

@@ -0,0 +1,61 @@
+'use strict';
+
+// Load modules
+
+
+// Declare internals
+
+const internals = {};
+
+
+exports = module.exports = class {
+
+    constructor(id, rule) {
+
+        this.id = id;
+        this.timeoutTimer = null;
+        this.count = 1;
+        this.rule = rule;
+
+        this.promise = new Promise((resolve, reject) => {
+
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+
+    join() {
+
+        ++this.count;
+        return this.promise;
+    }
+
+    send(err, value, cached, report) {
+
+        clearTimeout(this.timeoutTimer);
+
+        if (err &&
+            !cached) {
+
+            this.reject(err);
+            return;
+        }
+
+        if (!this.rule.getDecoratedValue) {
+            this.resolve(value);
+            return;
+        }
+
+        if (err) {
+            report.error = err;
+        }
+
+        this.resolve({ value, cached, report });
+    }
+
+    setTimeout(fn, timeoutMs) {
+
+        clearTimeout(this.timeoutTimer);
+        this.timeoutTimer = setTimeout(fn, timeoutMs);
+    }
+};

package/lib/policy.js

@@ -0,0 +1,434 @@
+'use strict';
+
+// Load modules
+
+const Boom = require('boom');
+const Hoek = require('hoek');
+const Joi = require('joi');
+
+const Pending = require('./pending');
+
+
+// Declare internals
+
+const internals = {
+    day: 24 * 60 * 60 * 1000
+};
+
+
+internals.schema = Joi.object({
+    expiresIn: Joi.number().integer().min(1),
+    expiresAt: Joi.string().regex(/^\d\d?\:\d\d$/),
+    staleIn: [
+        Joi.number().integer().min(1).when('expiresAt', { is: Joi.required(), then: Joi.number().max(86400000 - 1) }),       // One day - 1 (max is inclusive)
+        Joi.func()
+    ],
+    staleTimeout: Joi.number().integer().min(1),
+    generateFunc: Joi.func(),
+    generateTimeout: Joi.number().integer().min(1).allow(false),
+    generateOnReadError: Joi.boolean(),
+    generateIgnoreWriteError: Joi.boolean(),
+    dropOnError: Joi.boolean(),
+    pendingGenerateTimeout: Joi.number().integer().min(1),
+    getDecoratedValue: Joi.boolean().default(false),
+
+    // Ignored external keys (hapi)
+
+    privacy: Joi.any(),
+    cache: Joi.any(),
+    segment: Joi.any(),
+    shared: Joi.any()
+})
+    .without('expiresIn', 'expiresAt')
+    .with('staleIn', 'generateFunc')
+    .with('generateOnReadError', 'generateFunc')
+    .with('generateIgnoreWriteError', 'generateFunc')
+    .with('dropOnError', 'generateFunc')
+    .and('generateFunc', 'generateTimeout')
+    .and('staleIn', 'staleTimeout');
+
+
+exports = module.exports = internals.Policy = class {
+
+    constructor(options, cache, segment) {
+
+        this._cache = cache;
+        this._pendings = new Map();                       // id -> Pending
+        this._pendingGenerateCall = new Set();            // id
+        this.rules(options);
+
+        this.stats = {
+            sets: 0,
+            gets: 0,
+            hits: 0,
+            stales: 0,
+            generates: 0,
+            errors: 0
+        };
+
+        if (cache) {
+            const nameErr = cache.validateSegmentName(segment);
+            Hoek.assert(nameErr === null, 'Invalid segment name: ' + segment + (nameErr ? ' (' + nameErr.message + ')' : ''));
+
+            this._segment = segment;
+        }
+    }
+
+    rules(options) {
+
+        this.rule = internals.Policy.compile(options, !!this._cache);
+    }
+
+    async get(key) {     // key: string or { id: 'id' }
+
+        ++this.stats.gets;
+
+        // Check if request is already pending
+
+        const id = (key && typeof key === 'object') ? key.id : key;
+        let pending = this._pendings.get(id);
+        if (pending !== undefined) {
+            return await pending.join();
+        }
+
+        pending = new Pending(id, this.rule);
+        this._pendings.set(id, pending);
+
+        try {
+            await this._get(pending, key);
+        }
+        catch (err) {
+            // Safeguard to ensure that the pending rejects on any processing errors
+
+            this._send(pending, err);
+        }
+
+        return pending.promise;
+    }
+
+    async _get(pending, key) {
+
+        // Prepare report
+
+        const report = {};
+
+        // Lookup in cache
+
+        const timer = new Hoek.Bench();
+        let cached;
+        try {
+            cached = (this._cache ? await this._cache.get({ segment: this._segment, id: pending.id }) : null);
+        }
+        catch (err) {
+            report.error = err;
+            ++this.stats.errors;
+        }
+
+        report.msec = timer.elapsed();
+
+        if (cached) {
+            report.stored = cached.stored;
+            report.ttl = cached.ttl;
+            const staleIn = typeof this.rule.staleIn === 'function' ? this.rule.staleIn(cached.stored, cached.ttl) : this.rule.staleIn;
+            cached.isStale = (staleIn ? (Date.now() - cached.stored) >= staleIn : false);
+            report.isStale = cached.isStale;
+
+            if (cached.isStale) {
+                ++this.stats.stales;
+            }
+        }
+
+        // No generate method
+
+        if (!this.rule.generateFunc ||
+            (report.error && !this.rule.generateOnReadError)) {
+
+            this._send(pending, report.error, cached ? cached.item : null, cached, report);
+            return;
+        }
+
+        // Check if found and fresh
+
+        if (cached &&
+            !cached.isStale) {
+
+            this._send(pending, null, cached.item, cached, report);
+            return;
+        }
+
+        // Wait until generated or otherwise resolved
+
+        await Promise.race([
+            pending.promise,
+            this._generate(pending, key, cached, report)
+        ]);
+    }
+
+    async _generate(pending, key, cached, report) {
+
+        if (cached) {                                       // Must be stale
+
+            // Set stale timeout
+
+            cached.ttl = cached.ttl - this.rule.staleTimeout;       // Adjust TTL for when the timeout is invoked (staleTimeout must be valid if isStale is true)
+        }
+
+        if (cached &&
+            cached.ttl > 0) {
+
+            pending.setTimeout(() => {
+
+                return this._send(pending, null, cached.item, cached, report);
+            }, this.rule.staleTimeout);
+        }
+        else if (this.rule.generateTimeout) {
+
+            // Set item generation timeout (when not in cache)
+
+            pending.setTimeout(() => {
+
+                return this._send(pending, Boom.serverUnavailable(), null, null, report);
+            }, this.rule.generateTimeout);
+        }
+
+        // Generate new value
+
+        if (!this._pendingGenerateCall.has(pending.id)) {           // Check if a generate call is already in progress
+            ++this.stats.generates;                                 // Record generation before call in case it times out
+
+            if (this.rule.pendingGenerateTimeout) {
+                this._pendingGenerateCall.add(pending.id);
+                setTimeout(() => {
+
+                    this._pendingGenerateCall.delete(pending.id);
+                }, this.rule.pendingGenerateTimeout);
+            }
+
+            await this._callGenerateFunc(pending, key, cached, report);
+        }
+    }
+
+    async _callGenerateFunc(pending, key, cached, report) {
+
+        const flags = {};
+        try {
+            var value = await this.rule.generateFunc(key, flags);
+        }
+        catch (err) {
+            var generateError = err;
+        }
+
+        if (this._pendingGenerateCall.delete(pending.id)) {
+            pending = this._pendings.get(pending.id);                               // Fetch latest - it might have changed
+        }
+
+        // Error (if dropOnError is not set to false) or not cached
+
+        let persistError;
+        try {
+            if ((generateError && this.rule.dropOnError) || flags.ttl === 0) {      // null or undefined means use policy
+                await this.drop(pending.id);                                        // Invalidate cache
+            }
+            else if (!generateError) {
+                await this.set(pending.id, value, flags.ttl);                       // Lazy save (replaces stale cache copy with late-coming fresh copy)
+            }
+        }
+        catch (err) {
+            persistError = err;
+        }
+
+        const error = generateError || (this.rule.generateIgnoreWriteError ? null : persistError);
+        if (cached &&
+            error &&
+            !this.rule.dropOnError) {
+
+            this._send(pending, error, cached.item, cached, report);
+            return;
+        }
+
+        this._send(pending, error, value, null, report);                            // Ignored if stale value already returned
+    }
+
+    _send(pending, err, value, cached, report) {
+
+        pending.send(err, value, cached, report);
+        this._pendings.delete(pending.id);
+
+        if (report && report.isStale !== undefined) {
+            this.stats.hits = this.stats.hits + pending.count;
+        }
+    }
+
+    async set(key, value, ttl) {
+
+        ++this.stats.sets;
+
+        if (!this._cache) {
+            return;
+        }
+
+        ttl = ttl || internals.Policy.ttl(this.rule);
+        const id = (key && typeof key === 'object') ? key.id : key;
+        try {
+            await this._cache.set({ segment: this._segment, id }, value, ttl);
+        }
+        catch (err) {
+            ++this.stats.errors;
+            throw err;
+        }
+    }
+
+    async drop(key) {
+
+        if (!this._cache) {
+            return;
+        }
+
+        const id = (key && typeof key === 'object') ? key.id : key;
+        try {
+            return await this._cache.drop({ segment: this._segment, id });
+        }
+        catch (err) {
+            ++this.stats.errors;
+            throw err;
+        }
+    }
+
+    ttl(created) {
+
+        return internals.Policy.ttl(this.rule, created);
+    }
+
+    isReady() {
+
+        if (!this._cache) {
+            return false;
+        }
+
+        return this._cache.connection.isReady();
+    }
+
+    static compile(options, serverSide) {
+
+        /*
+            {
+                expiresIn: 30000,
+                expiresAt: '13:00',
+                generateFunc: (id, flags) => { throw err; } / { return result; } / { flags.ttl = ttl; return result; }
+                generateTimeout: 500,
+                generateOnReadError: true,
+                generateIgnoreWriteError: true,
+                staleIn: 20000,
+                staleTimeout: 500,
+                dropOnError: true,
+                getDecoratedValue: false
+            }
+         */
+
+        const rule = {};
+
+        if (!options ||
+            !Object.keys(options).length) {
+
+            return rule;
+        }
+
+        // Validate rule
+
+        options = Joi.attempt(options, internals.schema, 'Invalid cache policy configuration');
+
+        const hasExpiresIn = options.expiresIn !== undefined && options.expiresIn !== null;
+        const hasExpiresAt = options.expiresAt !== undefined && options.expiresAt !== null;
+
+        Hoek.assert(!hasExpiresIn || !options.staleIn || typeof options.staleIn === 'function' || options.staleIn < options.expiresIn, 'staleIn must be less than expiresIn');
+        Hoek.assert(!options.staleIn || serverSide, 'Cannot use stale options without server-side caching');
+        Hoek.assert(!options.staleTimeout || !hasExpiresIn || options.staleTimeout < options.expiresIn, 'staleTimeout must be less than expiresIn');
+        Hoek.assert(!options.staleTimeout || !hasExpiresIn || typeof options.staleIn === 'function' || options.staleTimeout < (options.expiresIn - options.staleIn), 'staleTimeout must be less than the delta between expiresIn and staleIn');
+        Hoek.assert(!options.staleTimeout || !options.pendingGenerateTimeout || options.staleTimeout < options.pendingGenerateTimeout, 'pendingGenerateTimeout must be greater than staleTimeout if specified');
+
+        // Expiration
+
+        if (hasExpiresAt) {
+
+            // expiresAt
+
+            const time = /^(\d\d?):(\d\d)$/.exec(options.expiresAt);
+            rule.expiresAt = {
+                hours: parseInt(time[1], 10),
+                minutes: parseInt(time[2], 10)
+            };
+        }
+        else {
+
+            // expiresIn
+
+            rule.expiresIn = options.expiresIn || 0;
+        }
+
+        // generateTimeout
+
+        if (options.generateFunc) {
+            rule.generateFunc = options.generateFunc;
+            rule.generateTimeout = options.generateTimeout;
+
+            // Stale
+
+            if (options.staleIn) {
+                rule.staleIn = options.staleIn;
+                rule.staleTimeout = options.staleTimeout;
+            }
+
+            rule.dropOnError = options.dropOnError !== undefined ? options.dropOnError : true;                                          // Defaults to true
+            rule.pendingGenerateTimeout = options.pendingGenerateTimeout !== undefined ? options.pendingGenerateTimeout : 0;            // Defaults to zero
+        }
+
+        rule.generateOnReadError = options.generateOnReadError !== undefined ? options.generateOnReadError : true;                      // Defaults to true
+        rule.generateIgnoreWriteError = options.generateIgnoreWriteError !== undefined ? options.generateIgnoreWriteError : true;       // Defaults to true
+
+        // Decorations
+
+        rule.getDecoratedValue = options.getDecoratedValue;
+
+        return rule;
+    }
+
+    static ttl(rule, created, now) {
+
+        now = now || Date.now();
+        created = created || now;
+        const age = now - created;
+
+        if (age < 0) {
+            return 0;                                                                   // Created in the future, assume expired/bad
+        }
+
+        if (rule.expiresIn) {
+            return Math.max(rule.expiresIn - age, 0);
+        }
+
+        if (rule.expiresAt) {
+            if (age > internals.day) {                                                  // If the item was created more than a 24 hours ago
+                return 0;
+            }
+
+            const expiresAt = new Date(created);                                        // Compare expiration time on the same day
+            expiresAt.setHours(rule.expiresAt.hours);
+            expiresAt.setMinutes(rule.expiresAt.minutes);
+            expiresAt.setSeconds(0);
+            expiresAt.setMilliseconds(0);
+            let expires = expiresAt.getTime();
+
+            if (expires <= created) {
+                expires = expires + internals.day;                                     // Move to tomorrow
+            }
+
+            if (now >= expires) {                                                      // Expired
+                return 0;
+            }
+
+            return expires - now;
+        }
+
+        return 0;                                                                       // No rule
+    }
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@depup/catbox",
+  "description": "[DepUp] Multi-strategy object caching service",
+  "version": "10.0.6-depup.0",
+  "repository": "git://github.com/hapijs/catbox",
+  "main": "lib/index.js",
+  "keywords": [
+    "depup",
+    "dependency-bumped",
+    "updated-deps",
+    "catbox",
+    "cache",
+    "generic",
+    "adapter"
+  ],
+  "dependencies": {
+    "boom": "^7.3.0",
+    "hoek": "^6.1.3",
+    "joi": "^18.0.2"
+  },
+  "devDependencies": {
+    "code": "5.x.x",
+    "lab": "18.x.x"
+  },
+  "scripts": {
+    "test": "lab -a code -t 100 -L",
+    "test-cov-html": "lab -a code -r html -o coverage.html"
+  },
+  "license": "BSD-3-Clause",
+  "depup": {
+    "changes": {
+      "boom": {
+        "from": "7.x.x",
+        "to": "^7.3.0"
+      },
+      "hoek": {
+        "from": "6.x.x",
+        "to": "^6.1.3"
+      },
+      "joi": {
+        "from": "14.x.x",
+        "to": "^18.0.2"
+      }
+    },
+    "depsUpdated": 3,
+    "originalPackage": "catbox",
+    "originalVersion": "10.0.6",
+    "processedAt": "2026-03-17T18:41:49.899Z",
+    "smokeTest": "passed"
+  }
+}