kassza 0.13.0 → 0.14.0

package/dist/stores-BNrS0dWl.cjs

@@ -0,0 +1,506 @@
+const require_binary = require("./binary-B89HM03_.cjs");
+const require_session = require("./session-DeM5vjvC.cjs");
+//#region src/cookie-stores/resilient.ts
+function warnCookieStoreError(event) {
+	const continuation = ATOMIC_OPERATIONS.has(event.operation) ? "a hibát a kassza kapja meg és kezeli." : "a kérés session nélkül folytatódik.";
+	console.warn(`[szamlazz] A tároló "${event.operation}" művelete sikertelen, ${continuation}`, event.error);
+}
+const ATOMIC_OPERATIONS = /* @__PURE__ */ new Set([
+	"setIfAbsent",
+	"increment",
+	"deleteIfEquals"
+]);
+function withTimeout(promise, timeoutMs, operation) {
+	if (timeoutMs === void 0) return promise;
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`A session cookie store "${operation}" művelete nem fejeződött be ${timeoutMs} ms alatt.`));
+		}, timeoutMs);
+	});
+	return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}
+function resilientCookieStore(store, options = {}) {
+	const onError = options.onError ?? warnCookieStoreError;
+	if (options.timeoutMs !== void 0 && !(options.timeoutMs > 0)) throw new RangeError(`A timeoutMs pozitív szám legyen, kapott: ${options.timeoutMs}`);
+	function report(operation, key, error) {
+		try {
+			onError({
+				operation,
+				key,
+				error
+			});
+		} catch {
+			return;
+		}
+	}
+	async function run(operation, key, call) {
+		try {
+			return await withTimeout(Promise.resolve().then(call), options.timeoutMs, operation);
+		} catch (error) {
+			report(operation, key, error);
+			return;
+		}
+	}
+	async function strict(operation, key, call) {
+		try {
+			return await withTimeout(Promise.resolve().then(call), options.timeoutMs, operation);
+		} catch (error) {
+			report(operation, key, error);
+			throw error;
+		}
+	}
+	const setIfAbsent = store.setIfAbsent?.bind(store);
+	const increment = store.increment?.bind(store);
+	const deleteIfEquals = store.deleteIfEquals?.bind(store);
+	return {
+		async get(key) {
+			return await run("get", key, () => store.get(key)) ?? void 0;
+		},
+		async set(key, value, ttlSeconds) {
+			await run("set", key, () => store.set(key, value, ttlSeconds));
+		},
+		async delete(key) {
+			await run("delete", key, () => store.delete(key));
+		},
+		...setIfAbsent && { setIfAbsent: (key, value, ttlSeconds) => strict("setIfAbsent", key, () => setIfAbsent(key, value, ttlSeconds)) },
+		...increment && { increment: (key, ttlSeconds) => strict("increment", key, () => increment(key, ttlSeconds)) },
+		...deleteIfEquals && { deleteIfEquals: (key, value) => strict("deleteIfEquals", key, () => deleteIfEquals(key, value)) }
+	};
+}
+//#endregion
+//#region src/cookie-stores/shared.ts
+function prefixKey(options, key) {
+	const prefix = options?.prefix;
+	return prefix ? `${prefix}${key}` : key;
+}
+function finalizeCookieStore(store, options) {
+	if (options?.resilient === false) return store;
+	return resilientCookieStore(store, {
+		onError: options?.onError,
+		timeoutMs: options?.timeoutMs
+	});
+}
+function readCookieValue(value) {
+	if (typeof value === "string") return value === "" ? void 0 : value;
+	if (value instanceof Uint8Array) return readCookieValue(require_binary.decodeUtf8(value));
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+}
+function wholeSeconds(ttlSeconds, minimum) {
+	if (!Number.isFinite(ttlSeconds)) return minimum;
+	return Math.max(minimum, Math.ceil(ttlSeconds));
+}
+//#endregion
+//#region src/cookie-stores/cloudflare-kv.ts
+const CLOUDFLARE_KV_MIN_TTL_SECONDS = 60;
+function cloudflareKvCookieStore(namespace, options) {
+	return finalizeCookieStore({
+		async get(key) {
+			return readCookieValue(await namespace.get(prefixKey(options, key)));
+		},
+		async set(key, value, ttlSeconds) {
+			await namespace.put(prefixKey(options, key), value, { expirationTtl: wholeSeconds(ttlSeconds, 60) });
+		},
+		async delete(key) {
+			await namespace.delete(prefixKey(options, key));
+		}
+	}, options);
+}
+//#endregion
+//#region src/cookie-stores/custom.ts
+function customCookieStore(store, options) {
+	const prefixed = (key) => prefixKey(options, key);
+	const wrapped = {
+		get: (key) => store.get(prefixed(key)),
+		set: (key, value, ttlSeconds) => store.set(prefixed(key), value, ttlSeconds),
+		delete: (key) => store.delete(prefixed(key))
+	};
+	const setIfAbsent = store.setIfAbsent?.bind(store);
+	const increment = store.increment?.bind(store);
+	const deleteIfEquals = store.deleteIfEquals?.bind(store);
+	return finalizeCookieStore({
+		...wrapped,
+		...setIfAbsent && { setIfAbsent: (key, value, ttlSeconds) => setIfAbsent(prefixed(key), value, ttlSeconds) },
+		...increment && { increment: (key, ttlSeconds) => increment(prefixed(key), ttlSeconds) },
+		...deleteIfEquals && { deleteIfEquals: (key, value) => deleteIfEquals(prefixed(key), value) }
+	}, options);
+}
+//#endregion
+//#region src/cookie-stores/scripts.ts
+const SET_IF_ABSENT_SCRIPT = "if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'EX', ARGV[2]) then return 1 else return 0 end";
+const INCREMENT_SCRIPT = "local value = redis.call('INCR', KEYS[1]) redis.call('EXPIRE', KEYS[1], ARGV[1]) return value";
+const DELETE_IF_EQUALS_SCRIPT = "if redis.call('GET', KEYS[1]) == ARGV[1] then return redis.call('DEL', KEYS[1]) else return 0 end";
+function scriptNumber(value) {
+	const parsed = typeof value === "number" ? value : Number(value);
+	if (!Number.isFinite(parsed)) throw new TypeError(`A Redis szkript nem számot adott vissza: ${String(value)}`);
+	return parsed;
+}
+function atomicOperations(run, prefixed, seconds) {
+	return {
+		async setIfAbsent(key, value, ttlSeconds) {
+			return scriptNumber(await run(SET_IF_ABSENT_SCRIPT, prefixed(key), [value, String(seconds(ttlSeconds))])) === 1;
+		},
+		async increment(key, ttlSeconds) {
+			return scriptNumber(await run(INCREMENT_SCRIPT, prefixed(key), [String(seconds(ttlSeconds))]));
+		},
+		async deleteIfEquals(key, value) {
+			return scriptNumber(await run(DELETE_IF_EQUALS_SCRIPT, prefixed(key), [value])) > 0;
+		}
+	};
+}
+//#endregion
+//#region src/cookie-stores/ioredis.ts
+function ioredisCookieStore(redis, options) {
+	const base = {
+		async get(key) {
+			return readCookieValue(await redis.get(prefixKey(options, key)));
+		},
+		async set(key, value, ttlSeconds) {
+			await redis.set(prefixKey(options, key), value, "EX", wholeSeconds(ttlSeconds, 1));
+		},
+		async delete(key) {
+			await redis.del(prefixKey(options, key));
+		}
+	};
+	const evaluate = redis.eval?.bind(redis);
+	if (!evaluate) return finalizeCookieStore(base, options);
+	const atomic = atomicOperations((script, key, args) => evaluate(script, 1, key, ...args), (key) => prefixKey(options, key), (ttlSeconds) => wholeSeconds(ttlSeconds, 1));
+	return finalizeCookieStore({
+		...base,
+		...atomic
+	}, options);
+}
+//#endregion
+//#region src/cookie-stores/node-redis.ts
+function nodeRedisCookieStore(client, options) {
+	const base = {
+		async get(key) {
+			return readCookieValue(await client.get(prefixKey(options, key)));
+		},
+		async set(key, value, ttlSeconds) {
+			await client.set(prefixKey(options, key), value, { EX: wholeSeconds(ttlSeconds, 1) });
+		},
+		async delete(key) {
+			await client.del(prefixKey(options, key));
+		}
+	};
+	const evaluate = client.eval?.bind(client);
+	if (!evaluate) return finalizeCookieStore(base, options);
+	const atomic = atomicOperations((script, key, args) => evaluate(script, {
+		keys: [key],
+		arguments: args
+	}), (key) => prefixKey(options, key), (ttlSeconds) => wholeSeconds(ttlSeconds, 1));
+	return finalizeCookieStore({
+		...base,
+		...atomic
+	}, options);
+}
+//#endregion
+//#region src/cookie-stores/upstash.ts
+function upstashRedisCookieStore(redis, options) {
+	const base = {
+		async get(key) {
+			return readCookieValue(await redis.get(prefixKey(options, key)));
+		},
+		async set(key, value, ttlSeconds) {
+			await redis.set(prefixKey(options, key), value, { ex: wholeSeconds(ttlSeconds, 1) });
+		},
+		async delete(key) {
+			await redis.del(prefixKey(options, key));
+		}
+	};
+	const evaluate = redis.eval?.bind(redis);
+	if (!evaluate) return finalizeCookieStore(base, options);
+	const atomic = atomicOperations((script, key, args) => evaluate(script, [key], args), (key) => prefixKey(options, key), (ttlSeconds) => wholeSeconds(ttlSeconds, 1));
+	return finalizeCookieStore({
+		...base,
+		...atomic
+	}, options);
+}
+//#endregion
+//#region src/stores/diagnose.ts
+function randomSuffix() {
+	return Array.from(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(8)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+async function diagnoseStore(store, options = {}) {
+	const now = options.now ?? (() => Date.now());
+	const key = `${options.keyPrefix ?? "szamlazz:diagnose:"}${randomSuffix()}`;
+	const capabilities = require_session.storeCapabilities(store);
+	const problems = [];
+	const started = now();
+	const step = async (label, run) => {
+		try {
+			await run();
+			return true;
+		} catch (error) {
+			problems.push(`${label}: ${messageOf(error)}`);
+			return false;
+		}
+	};
+	const basic = await step("írás és olvasás", async () => {
+		await store.set(key, "kassza", 60);
+		const read = await store.get(key);
+		if (read !== "kassza") throw new Error(`a visszaolvasott érték: ${String(read)}`);
+		await store.delete(key);
+		const deleted = await store.get(key);
+		if (deleted !== void 0 && deleted !== null) throw new Error("a törölt kulcs még olvasható");
+	});
+	const lock = capabilities.setIfAbsent && await step("setIfAbsent", async () => {
+		if (await store.setIfAbsent?.(key, "a", 60) !== true) throw new Error("az üres kulcsra false");
+		if (await store.setIfAbsent?.(key, "b", 60) !== false) throw new Error("a foglalt kulcsra true");
+		if (capabilities.deleteIfEquals) {
+			if (await store.deleteIfEquals?.(key, "b") !== false) throw new Error("deleteIfEquals idegen tokenre törölt");
+			if (await store.deleteIfEquals?.(key, "a") !== true) throw new Error("deleteIfEquals a saját tokenre nem törölt");
+		} else await store.delete(key);
+	});
+	const counter = capabilities.increment && await step("increment", async () => {
+		const first = await store.increment?.(key, 60);
+		const second = await store.increment?.(key, 60);
+		if (first !== 1 || second !== 2) throw new Error(`a számláló értékei: ${first}, ${second}`);
+		await store.delete(key);
+	});
+	await Promise.resolve(store.delete(key)).catch(() => void 0);
+	if (!capabilities.setIfAbsent) problems.push("Nincs setIfAbsent: createOnce zárnak nem alkalmas (például Cloudflare KV).");
+	if (!capabilities.increment) problems.push("Nincs increment: naplónak nem alkalmas, a próbálkozás-napló nem atomikus.");
+	return {
+		ok: basic && lock === true && counter === true,
+		capabilities,
+		suitableFor: {
+			session: basic,
+			attemptLedger: basic,
+			createOnceLock: basic && lock === true,
+			journal: basic && counter === true,
+			webhookDedupe: basic
+		},
+		latencyMs: Math.max(0, now() - started),
+		problems
+	};
+}
+//#endregion
+//#region src/stores/durable-object.ts
+const OPERATIONS = /* @__PURE__ */ new Set([
+	"get",
+	"set",
+	"delete",
+	"setIfAbsent",
+	"increment",
+	"deleteIfEquals"
+]);
+const DURABLE_OBJECT_STORE_URL = "https://kassza-store.internal/";
+function isEntry(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const entry = value;
+	return typeof entry.value === "string" && typeof entry.expiresAt === "number";
+}
+async function readLive(storage, key, now) {
+	const stored = await storage.get(key);
+	if (!isEntry(stored)) return void 0;
+	if (stored.expiresAt <= now) {
+		await storage.delete(key);
+		return;
+	}
+	return stored.value;
+}
+function expiresAt(ttlSeconds, now) {
+	return now + Math.max(1, Math.ceil(ttlSeconds !== void 0 && Number.isFinite(ttlSeconds) ? ttlSeconds : 1)) * 1e3;
+}
+function parseCommand(body) {
+	if (typeof body !== "object" || body === null) return void 0;
+	const command = body;
+	if (typeof command.op !== "string" || !OPERATIONS.has(command.op)) return void 0;
+	if (typeof command.key !== "string" || command.key === "") return void 0;
+	if (command.value !== void 0 && typeof command.value !== "string") return void 0;
+	if (command.ttlSeconds !== void 0 && typeof command.ttlSeconds !== "number") return void 0;
+	return command;
+}
+function requireValue(command) {
+	if (command.value === void 0) throw new TypeError(`A(z) ${command.op} művelethez érték kell.`);
+	return command.value;
+}
+async function runCommand(storage, command, now) {
+	const { key } = command;
+	switch (command.op) {
+		case "get": return await readLive(storage, key, now) ?? null;
+		case "set":
+			await storage.put(key, {
+				value: requireValue(command),
+				expiresAt: expiresAt(command.ttlSeconds, now)
+			});
+			return null;
+		case "delete":
+			await storage.delete(key);
+			return null;
+		case "setIfAbsent": {
+			const value = requireValue(command);
+			if (await readLive(storage, key, now) !== void 0) return false;
+			await storage.put(key, {
+				value,
+				expiresAt: expiresAt(command.ttlSeconds, now)
+			});
+			return true;
+		}
+		case "increment": {
+			const current = Number.parseInt(await readLive(storage, key, now) ?? "0", 10);
+			const next = (Number.isInteger(current) ? current : 0) + 1;
+			await storage.put(key, {
+				value: String(next),
+				expiresAt: expiresAt(command.ttlSeconds, now)
+			});
+			return next;
+		}
+		case "deleteIfEquals":
+			if (await readLive(storage, key, now) !== requireValue(command)) return false;
+			await storage.delete(key);
+			return true;
+	}
+}
+function jsonResponse(body, status = 200) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" }
+	});
+}
+async function handleDurableObjectStoreRequest(storage, request) {
+	if (request.method !== "POST") return jsonResponse({ error: "Csak POST kérés engedélyezett." }, 405);
+	let command;
+	try {
+		command = parseCommand(await request.json());
+	} catch {
+		command = void 0;
+	}
+	if (!command) return jsonResponse({ error: "Érvénytelen tároló-parancs." }, 400);
+	try {
+		return jsonResponse({ result: await runCommand(storage, command, Date.now()) });
+	} catch (error) {
+		return jsonResponse({ error: error instanceof Error ? error.message : String(error) }, 400);
+	}
+}
+async function call(stub, command) {
+	const response = await stub.fetch(DURABLE_OBJECT_STORE_URL, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify(command)
+	});
+	const body = await response.json().catch(() => ({}));
+	if (!response.ok) throw new Error(`A Durable Object tároló ${command.op} művelete sikertelen (HTTP ${response.status}): ${body.error ?? "ismeretlen hiba"}`);
+	return body.result ?? null;
+}
+function durableObjectStore(stub) {
+	return {
+		async get(key) {
+			const result = await call(stub, {
+				op: "get",
+				key
+			});
+			return typeof result === "string" ? result : void 0;
+		},
+		async set(key, value, ttlSeconds) {
+			await call(stub, {
+				op: "set",
+				key,
+				value,
+				ttlSeconds
+			});
+		},
+		async delete(key) {
+			await call(stub, {
+				op: "delete",
+				key
+			});
+		},
+		async setIfAbsent(key, value, ttlSeconds) {
+			return await call(stub, {
+				op: "setIfAbsent",
+				key,
+				value,
+				ttlSeconds
+			}) === true;
+		},
+		async increment(key, ttlSeconds) {
+			const result = await call(stub, {
+				op: "increment",
+				key,
+				ttlSeconds
+			});
+			if (typeof result !== "number") throw new TypeError(`A Durable Object tároló nem számot adott vissza: ${String(result)}`);
+			return result;
+		},
+		async deleteIfEquals(key, value) {
+			return await call(stub, {
+				op: "deleteIfEquals",
+				key,
+				value
+			}) === true;
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "CLOUDFLARE_KV_MIN_TTL_SECONDS", {
+	enumerable: true,
+	get: function() {
+		return CLOUDFLARE_KV_MIN_TTL_SECONDS;
+	}
+});
+Object.defineProperty(exports, "DURABLE_OBJECT_STORE_URL", {
+	enumerable: true,
+	get: function() {
+		return DURABLE_OBJECT_STORE_URL;
+	}
+});
+Object.defineProperty(exports, "cloudflareKvCookieStore", {
+	enumerable: true,
+	get: function() {
+		return cloudflareKvCookieStore;
+	}
+});
+Object.defineProperty(exports, "customCookieStore", {
+	enumerable: true,
+	get: function() {
+		return customCookieStore;
+	}
+});
+Object.defineProperty(exports, "diagnoseStore", {
+	enumerable: true,
+	get: function() {
+		return diagnoseStore;
+	}
+});
+Object.defineProperty(exports, "durableObjectStore", {
+	enumerable: true,
+	get: function() {
+		return durableObjectStore;
+	}
+});
+Object.defineProperty(exports, "handleDurableObjectStoreRequest", {
+	enumerable: true,
+	get: function() {
+		return handleDurableObjectStoreRequest;
+	}
+});
+Object.defineProperty(exports, "ioredisCookieStore", {
+	enumerable: true,
+	get: function() {
+		return ioredisCookieStore;
+	}
+});
+Object.defineProperty(exports, "nodeRedisCookieStore", {
+	enumerable: true,
+	get: function() {
+		return nodeRedisCookieStore;
+	}
+});
+Object.defineProperty(exports, "resilientCookieStore", {
+	enumerable: true,
+	get: function() {
+		return resilientCookieStore;
+	}
+});
+Object.defineProperty(exports, "upstashRedisCookieStore", {
+	enumerable: true,
+	get: function() {
+		return upstashRedisCookieStore;
+	}
+});