zephyr-agent/dist/lib/node-persist/storage.js

Zephyr plugin agent

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, getters, values)=>{
        var define = (defs, kind)=>{
            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
                enumerable: true,
                [kind]: defs[key]
            });
        };
        define(getters, "get");
        define(values, "value");
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    createPersistentStore: ()=>createPersistentStore,
    forEachItem: ()=>storage_forEachItem,
    getItem: ()=>storage_getItem,
    keys: ()=>storage_keys,
    removeItem: ()=>storage_removeItem,
    setItem: ()=>storage_setItem,
    setPrivateItem: ()=>setPrivateItem,
    storage: ()=>storage
});
const external_node_crypto_namespaceObject = require("node:crypto");
const promises_namespaceObject = require("node:fs/promises");
const external_node_path_namespaceObject = require("node:path");
const proper_lockfile2_namespaceObject = require("@bybrave/proper-lockfile2");
const external_atomic_file_js_namespaceObject = require("./atomic-file.js");
const external_storage_keys_js_namespaceObject = require("./storage-keys.js");
const STORAGE_ITEM_LOCK_STALE_MS = 60000;
const STORAGE_ITEM_LOCK_RETRIES = {
    retries: 120,
    factor: 1.2,
    minTimeout: 25,
    maxTimeout: 500,
    randomize: true
};
function datumPath(directory, key) {
    const digest = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(key).digest('hex');
    return (0, external_node_path_namespaceObject.join)(directory, digest);
}
function parseDatum(content) {
    try {
        const datum = JSON.parse(content);
        return 'string' == typeof datum.key && datum.key ? datum : void 0;
    } catch  {
        return;
    }
}
function isExpired(datum) {
    return 'number' == typeof datum.ttl && datum.ttl < Date.now();
}
function createPersistentStore(directory, hooks = {}) {
    const ready = (0, promises_namespaceObject.mkdir)(directory, {
        recursive: true,
        mode: 448
    }).then(()=>void 0);
    async function withItemLock(key, action) {
        await ready;
        const release = await (0, proper_lockfile2_namespaceObject.lock)(datumPath(directory, key), {
            realpath: false,
            retries: STORAGE_ITEM_LOCK_RETRIES,
            stale: STORAGE_ITEM_LOCK_STALE_MS
        });
        try {
            return await action();
        } finally{
            await release();
        }
    }
    async function readDatum(key) {
        await ready;
        try {
            return parseDatum(await (0, promises_namespaceObject.readFile)(datumPath(directory, key), 'utf8'));
        } catch (error) {
            if ('ENOENT' === error.code) return;
            throw error;
        }
    }
    async function getItem(key) {
        let datum = await readDatum(key);
        if (!datum) return;
        if (isExpired(datum)) {
            datum = await removeExpiredItem(key);
            if (!datum) return;
        }
        return datum.value;
    }
    async function setItem(key, value, options = {}) {
        return withItemLock(key, async ()=>{
            const file = datumPath(directory, key);
            const ttl = options.ttl ? Date.now() + options.ttl : void 0;
            await (0, external_atomic_file_js_namespaceObject.writeFileAtomically)(file, JSON.stringify({
                key,
                value,
                ttl
            }));
            (0, external_storage_keys_js_namespaceObject.ensurePrivateFilePermissions)(file);
            return {
                file
            };
        });
    }
    async function removeItem(key) {
        await withItemLock(key, ()=>removeItemWithoutLock(key));
    }
    async function removeItemWithoutLock(key) {
        await (0, promises_namespaceObject.rm)(datumPath(directory, key), {
            force: true
        });
    }
    async function removeExpiredItem(key) {
        await hooks.beforeExpiredCleanup?.(key);
        return withItemLock(key, async ()=>{
            const datum = await readDatum(key);
            if (!datum || !isExpired(datum)) return datum;
            await removeItemWithoutLock(key);
        });
    }
    async function data() {
        await ready;
        const entries = await (0, promises_namespaceObject.readdir)(directory, {
            withFileTypes: true
        });
        const values = [];
        for (const entry of entries)if (!(!entry.isFile() || entry.name.startsWith('.'))) try {
            let datum = parseDatum(await (0, promises_namespaceObject.readFile)((0, external_node_path_namespaceObject.join)(directory, entry.name), 'utf8'));
            if (!datum) continue;
            if (isExpired(datum)) {
                datum = await removeExpiredItem(datum.key);
                if (!datum) continue;
            }
            values.push(datum);
        } catch (error) {
            if ('ENOENT' !== error.code) throw error;
        }
        return values;
    }
    async function keys() {
        return (await data()).map(({ key })=>key);
    }
    async function forEachItem(callback) {
        for (const { key, value } of (await data()))await callback({
            key,
            value
        });
    }
    return {
        ready,
        getItem,
        setItem,
        removeItem,
        keys,
        forEachItem
    };
}
const persistentStore = createPersistentStore(external_storage_keys_js_namespaceObject.ZE_STORAGE_PATH);
const storage = persistentStore.ready;
const storage_getItem = persistentStore.getItem;
const storage_setItem = persistentStore.setItem;
const storage_removeItem = persistentStore.removeItem;
const storage_keys = persistentStore.keys;
const storage_forEachItem = persistentStore.forEachItem;
async function setPrivateItem(key, value, options) {
    const result = await storage_setItem(key, value, options);
    (0, external_storage_keys_js_namespaceObject.ensurePrivateFilePermissions)(result.file);
}
exports.createPersistentStore = __webpack_exports__.createPersistentStore;
exports.forEachItem = __webpack_exports__.forEachItem;
exports.getItem = __webpack_exports__.getItem;
exports.keys = __webpack_exports__.keys;
exports.removeItem = __webpack_exports__.removeItem;
exports.setItem = __webpack_exports__.setItem;
exports.setPrivateItem = __webpack_exports__.setPrivateItem;
exports.storage = __webpack_exports__.storage;
for(var __rspack_i in __webpack_exports__)if (-1 === [
    "createPersistentStore",
    "forEachItem",
    "getItem",
    "keys",
    "removeItem",
    "setItem",
    "setPrivateItem",
    "storage"
].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
Object.defineProperty(exports, '__esModule', {
    value: true
});

//# sourceMappingURL=storage.js.map