@serve.zone/gitops 2.13.1

package/dist_ts/storage/classes.storagemanager.js

@@ -0,0 +1,135 @@
+import * as plugins from '../plugins.js';
+const isNotFoundError = (error) => {
+    return error instanceof Error && error.code === 'ENOENT';
+};
+/**
+ * Key-value storage abstraction with filesystem and memory backends.
+ * Keys must start with '/' and are normalized (no '..', no double slashes).
+ */
+export class StorageManager {
+    backend;
+    fsPath;
+    memoryStore;
+    constructor(config = {}) {
+        this.backend = config.backend ?? 'filesystem';
+        this.fsPath = config.fsPath ?? './storage';
+        this.memoryStore = new Map();
+    }
+    /**
+     * Normalize and validate a storage key.
+     */
+    normalizeKey(key) {
+        if (!key.startsWith('/')) {
+            throw new Error(`Storage key must start with '/': ${key}`);
+        }
+        // Strip '..' segments and normalize double slashes
+        const segments = key.split('/').filter((s) => s !== '' && s !== '..');
+        return '/' + segments.join('/');
+    }
+    /**
+     * Resolve a key to a filesystem path.
+     */
+    keyToPath(key) {
+        const normalized = this.normalizeKey(key);
+        return plugins.path.join(this.fsPath, ...normalized.split('/').filter(Boolean));
+    }
+    async get(key) {
+        const normalized = this.normalizeKey(key);
+        if (this.backend === 'memory') {
+            return this.memoryStore.get(normalized) ?? null;
+        }
+        try {
+            return await plugins.fs.readFile(this.keyToPath(normalized), 'utf8');
+        }
+        catch (err) {
+            if (isNotFoundError(err))
+                return null;
+            throw err;
+        }
+    }
+    async set(key, value) {
+        const normalized = this.normalizeKey(key);
+        if (this.backend === 'memory') {
+            this.memoryStore.set(normalized, value);
+            return;
+        }
+        const filePath = this.keyToPath(normalized);
+        const dir = plugins.path.dirname(filePath);
+        await plugins.fs.mkdir(dir, { recursive: true });
+        // Atomic write: write to temp then rename
+        const tmpPath = filePath + '.tmp';
+        await plugins.fs.writeFile(tmpPath, value, 'utf8');
+        await plugins.fs.rename(tmpPath, filePath);
+    }
+    async delete(key) {
+        const normalized = this.normalizeKey(key);
+        if (this.backend === 'memory') {
+            return this.memoryStore.delete(normalized);
+        }
+        try {
+            await plugins.fs.rm(this.keyToPath(normalized));
+            return true;
+        }
+        catch (err) {
+            if (isNotFoundError(err))
+                return false;
+            throw err;
+        }
+    }
+    async exists(key) {
+        const normalized = this.normalizeKey(key);
+        if (this.backend === 'memory') {
+            return this.memoryStore.has(normalized);
+        }
+        try {
+            await plugins.fs.stat(this.keyToPath(normalized));
+            return true;
+        }
+        catch (err) {
+            if (isNotFoundError(err))
+                return false;
+            throw err;
+        }
+    }
+    /**
+     * List keys under a given prefix.
+     */
+    async list(prefix) {
+        const normalized = this.normalizeKey(prefix);
+        if (this.backend === 'memory') {
+            const keys = [];
+            for (const key of this.memoryStore.keys()) {
+                if (key.startsWith(normalized)) {
+                    keys.push(key);
+                }
+            }
+            return keys.sort();
+        }
+        const dirPath = this.keyToPath(normalized);
+        const keys = [];
+        try {
+            const entries = await plugins.fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    keys.push(normalized.replace(/\/$/, '') + '/' + entry.name);
+                }
+            }
+        }
+        catch (err) {
+            if (isNotFoundError(err))
+                return [];
+            throw err;
+        }
+        return keys.sort();
+    }
+    async getJSON(key) {
+        const raw = await this.get(key);
+        if (raw === null)
+            return null;
+        return JSON.parse(raw);
+    }
+    async setJSON(key, value) {
+        await this.set(key, JSON.stringify(value, null, 2));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/storage/index.d.ts

@@ -0,0 +1,2 @@
+export { StorageManager } from './classes.storagemanager.js';
+export type { IStorageConfig, TStorageBackend } from './classes.storagemanager.js';

package/dist_ts/storage/index.js

@@ -0,0 +1,2 @@
+export { StorageManager } from './classes.storagemanager.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9zdG9yYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQyJ9

package/dist_ts/timers.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_INTERVAL_MINUTES: number;
+export declare const validateIntervalMinutes: (value: number | undefined, label?: string, fallback?: number) => number;
+export declare const intervalMinutesToMs: (value: number, label?: string) => number;
+export declare const unrefTimer: (timer: ReturnType<typeof setInterval> | ReturnType<typeof setTimeout>) => void;

package/dist_ts/timers.js

@@ -0,0 +1,24 @@
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+const MS_PER_MINUTE = 60_000;
+export const MAX_INTERVAL_MINUTES = Math.floor(MAX_TIMER_DELAY_MS / MS_PER_MINUTE);
+export const validateIntervalMinutes = (value, label = 'intervalMinutes', fallback) => {
+    const intervalMinutes = value ?? fallback;
+    if (intervalMinutes === undefined ||
+        !Number.isFinite(intervalMinutes) ||
+        !Number.isInteger(intervalMinutes) ||
+        intervalMinutes < 1 ||
+        intervalMinutes > MAX_INTERVAL_MINUTES) {
+        throw new Error(`${label} must be an integer between 1 and ${MAX_INTERVAL_MINUTES}`);
+    }
+    return intervalMinutes;
+};
+export const intervalMinutesToMs = (value, label = 'intervalMinutes') => {
+    return validateIntervalMinutes(value, label) * MS_PER_MINUTE;
+};
+export const unrefTimer = (timer) => {
+    const unref = timer.unref;
+    if (typeof unref === 'function') {
+        unref.call(timer);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvdGltZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sa0JBQWtCLEdBQUcsYUFBYSxDQUFDO0FBQ3pDLE1BQU0sYUFBYSxHQUFHLE1BQU0sQ0FBQztBQUU3QixNQUFNLENBQUMsTUFBTSxvQkFBb0IsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLGtCQUFrQixHQUFHLGFBQWEsQ0FBQyxDQUFDO0FBRW5GLE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFHLENBQ3JDLEtBQXlCLEVBQ3pCLEtBQUssR0FBRyxpQkFBaUIsRUFDekIsUUFBaUIsRUFDVCxFQUFFO0lBQ1YsTUFBTSxlQUFlLEdBQUcsS0FBSyxJQUFJLFFBQVEsQ0FBQztJQUMxQyxJQUNFLGVBQWUsS0FBSyxTQUFTO1FBQzdCLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxlQUFlLENBQUM7UUFDakMsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLGVBQWUsQ0FBQztRQUNsQyxlQUFlLEdBQUcsQ0FBQztRQUNuQixlQUFlLEdBQUcsb0JBQW9CLEVBQ3RDLENBQUM7UUFDRCxNQUFNLElBQUksS0FBSyxDQUFDLEdBQUcsS0FBSyxxQ0FBcUMsb0JBQW9CLEVBQUUsQ0FBQyxDQUFDO0lBQ3ZGLENBQUM7SUFFRCxPQUFPLGVBQWUsQ0FBQztBQUN6QixDQUFDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxDQUFDLEtBQWEsRUFBRSxLQUFLLEdBQUcsaUJBQWlCLEVBQVUsRUFBRTtJQUN0RixPQUFPLHVCQUF1QixDQUFDLEtBQUssRUFBRSxLQUFLLENBQUMsR0FBRyxhQUFhLENBQUM7QUFDL0QsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLENBQUMsS0FBcUUsRUFBUSxFQUFFO0lBQ3hHLE1BQU0sS0FBSyxHQUFJLEtBQWdDLENBQUMsS0FBSyxDQUFDO0lBQ3RELElBQUksT0FBTyxLQUFLLEtBQUssVUFBVSxFQUFFLENBQUM7UUFDaEMsS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUNwQixDQUFDO0FBQ0gsQ0FBQyxDQUFDIn0=

package/dist_ts_bundled/bundle.d.ts

@@ -0,0 +1,4 @@
+export declare const files: {
+    path: string;
+    contentBase64: string;
+}[];