kassza 0.1.0

package/dist/shared-CrxlxI8n.cjs

@@ -0,0 +1,207 @@
+//#region src/storage/errors.ts
+var StorageError = class extends Error {
+	name = "StorageError";
+	operation;
+	key;
+	status;
+	constructor(message, options) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.operation = options.operation;
+		this.key = options.key;
+		this.status = options.status;
+	}
+};
+function isStorageError(error) {
+	return error instanceof StorageError;
+}
+function describeError(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null && "message" in error) return String(error.message);
+	return String(error);
+}
+async function guardStorageCall(service, operation, key, call) {
+	try {
+		return await call();
+	} catch (error) {
+		throw new StorageError(`${service} hiba (${operation}): ${describeError(error)}`, {
+			operation,
+			key,
+			cause: error
+		});
+	}
+}
+//#endregion
+//#region src/storage/shared.ts
+const PDF_CONTENT_TYPE = "application/pdf";
+const DEFAULT_URL_EXPIRES_SECONDS = 3600;
+const S3_MAX_PRESIGN_SECONDS = 604800;
+const MAX_KEY_LENGTH = 1024;
+const CONTROL_CHARACTERS = /[\p{Cc}]/u;
+function assertStorageKey(key) {
+	const invalid = (reason) => new StorageError(`Érvénytelen tárhelykulcs (${reason}): ${JSON.stringify(key)}`, {
+		operation: "key",
+		key
+	});
+	if (typeof key !== "string" || key.length === 0) throw invalid("üres");
+	if (key.length > MAX_KEY_LENGTH) throw invalid(`legfeljebb ${MAX_KEY_LENGTH} karakter lehet`);
+	if (key.startsWith("/")) throw invalid("nem kezdődhet perjellel");
+	if (key.includes("\\")) throw invalid("visszaperjel nem lehet benne");
+	if (CONTROL_CHARACTERS.test(key)) throw invalid("vezérlőkaraktert tartalmaz");
+	for (const segment of key.split("/")) if (segment === "" || segment === "." || segment === "..") throw invalid("üres, \".\" vagy \"..\" útvonalszakaszt tartalmaz");
+	return key;
+}
+function normalizePrefix(prefix) {
+	if (!prefix) return "";
+	const trimmed = prefix.replace(/^\/+|\/+$/g, "");
+	if (trimmed === "") return "";
+	assertStorageKey(trimmed);
+	return `${trimmed}/`;
+}
+function resolveKey(prefix, key) {
+	return `${prefix}${assertStorageKey(key)}`;
+}
+function encodeRfc3986(value) {
+	return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function encodeKeyPath(key) {
+	return key.split("/").map(encodeRfc3986).join("/");
+}
+function joinPublicUrl(baseUrl, key) {
+	return `${baseUrl.replace(/\/+$/, "")}/${encodeKeyPath(key)}`;
+}
+function assertExpires(expiresInSeconds, maximum, key) {
+	if (!Number.isInteger(expiresInSeconds) || expiresInSeconds < 1 || expiresInSeconds > maximum) throw new StorageError(`Az expiresInSeconds 1 és ${maximum} közötti egész szám legyen, kapott: ${expiresInSeconds}`, {
+		operation: "getUrl",
+		key
+	});
+	return expiresInSeconds;
+}
+function unsupportedSignedUrl(adapter, key) {
+	return new StorageError(`A(z) ${adapter} adapter nem tud lejáró (aláírt) URL-t készíteni. Hagyd el az expiresInSeconds opciót, vagy használj másik adaptert.`, {
+		operation: "getUrl",
+		key
+	});
+}
+function missingPublicBaseUrl(adapter, key) {
+	return new StorageError(`A(z) ${adapter} adapterrel URL készítéséhez add meg a publicBaseUrl opciót.`, {
+		operation: "getUrl",
+		key
+	});
+}
+function toArrayBuffer(bytes) {
+	const copy = new ArrayBuffer(bytes.byteLength);
+	new Uint8Array(copy).set(bytes);
+	return copy;
+}
+function basename(key) {
+	return key.slice(key.lastIndexOf("/") + 1);
+}
+//#endregion
+Object.defineProperty(exports, "DEFAULT_URL_EXPIRES_SECONDS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_URL_EXPIRES_SECONDS;
+	}
+});
+Object.defineProperty(exports, "PDF_CONTENT_TYPE", {
+	enumerable: true,
+	get: function() {
+		return PDF_CONTENT_TYPE;
+	}
+});
+Object.defineProperty(exports, "S3_MAX_PRESIGN_SECONDS", {
+	enumerable: true,
+	get: function() {
+		return S3_MAX_PRESIGN_SECONDS;
+	}
+});
+Object.defineProperty(exports, "StorageError", {
+	enumerable: true,
+	get: function() {
+		return StorageError;
+	}
+});
+Object.defineProperty(exports, "assertExpires", {
+	enumerable: true,
+	get: function() {
+		return assertExpires;
+	}
+});
+Object.defineProperty(exports, "assertStorageKey", {
+	enumerable: true,
+	get: function() {
+		return assertStorageKey;
+	}
+});
+Object.defineProperty(exports, "basename", {
+	enumerable: true,
+	get: function() {
+		return basename;
+	}
+});
+Object.defineProperty(exports, "describeError", {
+	enumerable: true,
+	get: function() {
+		return describeError;
+	}
+});
+Object.defineProperty(exports, "encodeKeyPath", {
+	enumerable: true,
+	get: function() {
+		return encodeKeyPath;
+	}
+});
+Object.defineProperty(exports, "encodeRfc3986", {
+	enumerable: true,
+	get: function() {
+		return encodeRfc3986;
+	}
+});
+Object.defineProperty(exports, "guardStorageCall", {
+	enumerable: true,
+	get: function() {
+		return guardStorageCall;
+	}
+});
+Object.defineProperty(exports, "isStorageError", {
+	enumerable: true,
+	get: function() {
+		return isStorageError;
+	}
+});
+Object.defineProperty(exports, "joinPublicUrl", {
+	enumerable: true,
+	get: function() {
+		return joinPublicUrl;
+	}
+});
+Object.defineProperty(exports, "missingPublicBaseUrl", {
+	enumerable: true,
+	get: function() {
+		return missingPublicBaseUrl;
+	}
+});
+Object.defineProperty(exports, "normalizePrefix", {
+	enumerable: true,
+	get: function() {
+		return normalizePrefix;
+	}
+});
+Object.defineProperty(exports, "resolveKey", {
+	enumerable: true,
+	get: function() {
+		return resolveKey;
+	}
+});
+Object.defineProperty(exports, "toArrayBuffer", {
+	enumerable: true,
+	get: function() {
+		return toArrayBuffer;
+	}
+});
+Object.defineProperty(exports, "unsupportedSignedUrl", {
+	enumerable: true,
+	get: function() {
+		return unsupportedSignedUrl;
+	}
+});

package/dist/shared-D6DLa4b7.js

@@ -0,0 +1,100 @@
+//#region src/storage/errors.ts
+var StorageError = class extends Error {
+	name = "StorageError";
+	operation;
+	key;
+	status;
+	constructor(message, options) {
+		super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+		this.operation = options.operation;
+		this.key = options.key;
+		this.status = options.status;
+	}
+};
+function isStorageError(error) {
+	return error instanceof StorageError;
+}
+function describeError(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null && "message" in error) return String(error.message);
+	return String(error);
+}
+async function guardStorageCall(service, operation, key, call) {
+	try {
+		return await call();
+	} catch (error) {
+		throw new StorageError(`${service} hiba (${operation}): ${describeError(error)}`, {
+			operation,
+			key,
+			cause: error
+		});
+	}
+}
+//#endregion
+//#region src/storage/shared.ts
+const PDF_CONTENT_TYPE = "application/pdf";
+const DEFAULT_URL_EXPIRES_SECONDS = 3600;
+const S3_MAX_PRESIGN_SECONDS = 604800;
+const MAX_KEY_LENGTH = 1024;
+const CONTROL_CHARACTERS = /[\p{Cc}]/u;
+function assertStorageKey(key) {
+	const invalid = (reason) => new StorageError(`Érvénytelen tárhelykulcs (${reason}): ${JSON.stringify(key)}`, {
+		operation: "key",
+		key
+	});
+	if (typeof key !== "string" || key.length === 0) throw invalid("üres");
+	if (key.length > MAX_KEY_LENGTH) throw invalid(`legfeljebb ${MAX_KEY_LENGTH} karakter lehet`);
+	if (key.startsWith("/")) throw invalid("nem kezdődhet perjellel");
+	if (key.includes("\\")) throw invalid("visszaperjel nem lehet benne");
+	if (CONTROL_CHARACTERS.test(key)) throw invalid("vezérlőkaraktert tartalmaz");
+	for (const segment of key.split("/")) if (segment === "" || segment === "." || segment === "..") throw invalid("üres, \".\" vagy \"..\" útvonalszakaszt tartalmaz");
+	return key;
+}
+function normalizePrefix(prefix) {
+	if (!prefix) return "";
+	const trimmed = prefix.replace(/^\/+|\/+$/g, "");
+	if (trimmed === "") return "";
+	assertStorageKey(trimmed);
+	return `${trimmed}/`;
+}
+function resolveKey(prefix, key) {
+	return `${prefix}${assertStorageKey(key)}`;
+}
+function encodeRfc3986(value) {
+	return encodeURIComponent(value).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function encodeKeyPath(key) {
+	return key.split("/").map(encodeRfc3986).join("/");
+}
+function joinPublicUrl(baseUrl, key) {
+	return `${baseUrl.replace(/\/+$/, "")}/${encodeKeyPath(key)}`;
+}
+function assertExpires(expiresInSeconds, maximum, key) {
+	if (!Number.isInteger(expiresInSeconds) || expiresInSeconds < 1 || expiresInSeconds > maximum) throw new StorageError(`Az expiresInSeconds 1 és ${maximum} közötti egész szám legyen, kapott: ${expiresInSeconds}`, {
+		operation: "getUrl",
+		key
+	});
+	return expiresInSeconds;
+}
+function unsupportedSignedUrl(adapter, key) {
+	return new StorageError(`A(z) ${adapter} adapter nem tud lejáró (aláírt) URL-t készíteni. Hagyd el az expiresInSeconds opciót, vagy használj másik adaptert.`, {
+		operation: "getUrl",
+		key
+	});
+}
+function missingPublicBaseUrl(adapter, key) {
+	return new StorageError(`A(z) ${adapter} adapterrel URL készítéséhez add meg a publicBaseUrl opciót.`, {
+		operation: "getUrl",
+		key
+	});
+}
+function toArrayBuffer(bytes) {
+	const copy = new ArrayBuffer(bytes.byteLength);
+	new Uint8Array(copy).set(bytes);
+	return copy;
+}
+function basename(key) {
+	return key.slice(key.lastIndexOf("/") + 1);
+}
+//#endregion
+export { guardStorageCall as _, assertStorageKey as a, encodeRfc3986 as c, normalizePrefix as d, resolveKey as f, describeError as g, StorageError as h, assertExpires as i, joinPublicUrl as l, unsupportedSignedUrl as m, PDF_CONTENT_TYPE as n, basename as o, toArrayBuffer as p, S3_MAX_PRESIGN_SECONDS as r, encodeKeyPath as s, DEFAULT_URL_EXPIRES_SECONDS as t, missingPublicBaseUrl as u, isStorageError as v };

package/dist/storage/fs.cjs

@@ -0,0 +1,88 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("../errors-B0QJhUW1.cjs");
+const require_shared = require("../shared-CrxlxI8n.cjs");
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+//#region src/storage/fs.ts
+function isInside(root, target) {
+	const path = (0, node_path.relative)(root, target);
+	return path !== "" && !path.startsWith("..") && !(0, node_path.isAbsolute)(path);
+}
+function hasCode(error, code) {
+	return error?.code === code;
+}
+function traversal(operation, key) {
+	return new require_shared.StorageError(`A kulcs a tárhely könyvtárán kívülre mutat: ${JSON.stringify(key)}`, {
+		operation,
+		key
+	});
+}
+function fsStorage(options) {
+	if (typeof options.directory !== "string" || options.directory.trim() === "") throw new require_errors.SzamlazzError("Az fsStorage directory opciója kötelező.", { category: "configuration" });
+	const root = (0, node_path.resolve)(options.directory);
+	const prefix = require_shared.normalizePrefix(options.prefix);
+	function pathFor(key, operation = "key") {
+		const target = (0, node_path.resolve)(root, require_shared.resolveKey(prefix, key));
+		if (!isInside(root, target)) throw traversal(operation, key);
+		return target;
+	}
+	async function assertRealPathInside(path, operation, key) {
+		const [realRoot, realTarget] = await Promise.all([(0, node_fs_promises.realpath)(root), (0, node_fs_promises.realpath)(path)]);
+		if (realTarget !== realRoot && !isInside(realRoot, realTarget)) throw traversal(operation, key);
+	}
+	return {
+		directory: root,
+		pathFor: (key) => pathFor(key),
+		async put(key, body, putOptions) {
+			const target = pathFor(key, "put");
+			const directory = (0, node_path.dirname)(target);
+			await require_shared.guardStorageCall("Fájlrendszer", "put", key, () => (0, node_fs_promises.mkdir)(directory, { recursive: true }));
+			await assertRealPathInside(directory, "put", key);
+			const temporary = `${target}.${crypto.randomUUID()}.tmp`;
+			try {
+				await (0, node_fs_promises.writeFile)(temporary, body);
+				await (0, node_fs_promises.rename)(temporary, target);
+			} catch (error) {
+				await (0, node_fs_promises.rm)(temporary, { force: true }).catch(() => void 0);
+				throw new require_shared.StorageError(`Fájlrendszer hiba (put): ${String(error)}`, {
+					operation: "put",
+					key,
+					cause: error
+				});
+			}
+			return {
+				key,
+				url: options.publicBaseUrl ? require_shared.joinPublicUrl(options.publicBaseUrl, require_shared.resolveKey(prefix, key)) : void 0,
+				size: body.byteLength,
+				contentType: putOptions.contentType
+			};
+		},
+		async get(key) {
+			const target = pathFor(key, "get");
+			try {
+				await assertRealPathInside(target, "get", key);
+				return new Uint8Array(await (0, node_fs_promises.readFile)(target));
+			} catch (error) {
+				if (hasCode(error, "ENOENT")) return void 0;
+				if (error instanceof require_shared.StorageError) throw error;
+				throw new require_shared.StorageError(`Fájlrendszer hiba (get): ${String(error)}`, {
+					operation: "get",
+					key,
+					cause: error
+				});
+			}
+		},
+		async delete(key) {
+			const target = pathFor(key, "delete");
+			await require_shared.guardStorageCall("Fájlrendszer", "delete", key, () => (0, node_fs_promises.rm)(target, { force: true }));
+		},
+		async getUrl(key, urlOptions = {}) {
+			const fullKey = require_shared.resolveKey(prefix, key);
+			if (urlOptions.expiresInSeconds !== void 0) throw require_shared.unsupportedSignedUrl("fsStorage", key);
+			if (!options.publicBaseUrl) throw require_shared.missingPublicBaseUrl("fsStorage", key);
+			return require_shared.joinPublicUrl(options.publicBaseUrl, fullKey);
+		}
+	};
+}
+//#endregion
+exports.fsStorage = fsStorage;

package/dist/storage/fs.d.cts

@@ -0,0 +1,13 @@
+import { t as CompleteStorageAdapter } from "../types-DVRgwcqg.cjs";
+//#region src/storage/fs.d.ts
+export interface FsStorageOptions {
+  readonly directory: string;
+  readonly publicBaseUrl?: string | undefined;
+  readonly prefix?: string | undefined;
+}
+export interface FsStorage extends CompleteStorageAdapter {
+  readonly directory: string;
+  pathFor(key: string): string;
+}
+export declare function fsStorage(options: FsStorageOptions): FsStorage;
+//#endregion

package/dist/storage/fs.d.ts

@@ -0,0 +1,13 @@
+import { t as CompleteStorageAdapter } from "../types-DVRgwcqg.js";
+//#region src/storage/fs.d.ts
+export interface FsStorageOptions {
+  readonly directory: string;
+  readonly publicBaseUrl?: string | undefined;
+  readonly prefix?: string | undefined;
+}
+export interface FsStorage extends CompleteStorageAdapter {
+  readonly directory: string;
+  pathFor(key: string): string;
+}
+export declare function fsStorage(options: FsStorageOptions): FsStorage;
+//#endregion

package/dist/storage/fs.js

@@ -0,0 +1,87 @@
+import { n as SzamlazzError } from "../errors-DapdV5DK.js";
+import { _ as guardStorageCall, d as normalizePrefix, f as resolveKey, h as StorageError, l as joinPublicUrl, m as unsupportedSignedUrl, u as missingPublicBaseUrl } from "../shared-D6DLa4b7.js";
+import { mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+//#region src/storage/fs.ts
+function isInside(root, target) {
+	const path = relative(root, target);
+	return path !== "" && !path.startsWith("..") && !isAbsolute(path);
+}
+function hasCode(error, code) {
+	return error?.code === code;
+}
+function traversal(operation, key) {
+	return new StorageError(`A kulcs a tárhely könyvtárán kívülre mutat: ${JSON.stringify(key)}`, {
+		operation,
+		key
+	});
+}
+function fsStorage(options) {
+	if (typeof options.directory !== "string" || options.directory.trim() === "") throw new SzamlazzError("Az fsStorage directory opciója kötelező.", { category: "configuration" });
+	const root = resolve(options.directory);
+	const prefix = normalizePrefix(options.prefix);
+	function pathFor(key, operation = "key") {
+		const target = resolve(root, resolveKey(prefix, key));
+		if (!isInside(root, target)) throw traversal(operation, key);
+		return target;
+	}
+	async function assertRealPathInside(path, operation, key) {
+		const [realRoot, realTarget] = await Promise.all([realpath(root), realpath(path)]);
+		if (realTarget !== realRoot && !isInside(realRoot, realTarget)) throw traversal(operation, key);
+	}
+	return {
+		directory: root,
+		pathFor: (key) => pathFor(key),
+		async put(key, body, putOptions) {
+			const target = pathFor(key, "put");
+			const directory = dirname(target);
+			await guardStorageCall("Fájlrendszer", "put", key, () => mkdir(directory, { recursive: true }));
+			await assertRealPathInside(directory, "put", key);
+			const temporary = `${target}.${crypto.randomUUID()}.tmp`;
+			try {
+				await writeFile(temporary, body);
+				await rename(temporary, target);
+			} catch (error) {
+				await rm(temporary, { force: true }).catch(() => void 0);
+				throw new StorageError(`Fájlrendszer hiba (put): ${String(error)}`, {
+					operation: "put",
+					key,
+					cause: error
+				});
+			}
+			return {
+				key,
+				url: options.publicBaseUrl ? joinPublicUrl(options.publicBaseUrl, resolveKey(prefix, key)) : void 0,
+				size: body.byteLength,
+				contentType: putOptions.contentType
+			};
+		},
+		async get(key) {
+			const target = pathFor(key, "get");
+			try {
+				await assertRealPathInside(target, "get", key);
+				return new Uint8Array(await readFile(target));
+			} catch (error) {
+				if (hasCode(error, "ENOENT")) return void 0;
+				if (error instanceof StorageError) throw error;
+				throw new StorageError(`Fájlrendszer hiba (get): ${String(error)}`, {
+					operation: "get",
+					key,
+					cause: error
+				});
+			}
+		},
+		async delete(key) {
+			const target = pathFor(key, "delete");
+			await guardStorageCall("Fájlrendszer", "delete", key, () => rm(target, { force: true }));
+		},
+		async getUrl(key, urlOptions = {}) {
+			const fullKey = resolveKey(prefix, key);
+			if (urlOptions.expiresInSeconds !== void 0) throw unsupportedSignedUrl("fsStorage", key);
+			if (!options.publicBaseUrl) throw missingPublicBaseUrl("fsStorage", key);
+			return joinPublicUrl(options.publicBaseUrl, fullKey);
+		}
+	};
+}
+//#endregion
+export { fsStorage };