fockeror 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 FOCKUSTY
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const PLACEHOLDER_PATTERN: RegExp;
+export declare const DEFAULT_HTTP_STATUS: 500;
+export declare const CLEAN_SEARCH_REGEX: RegExp;
+export declare const CLEAN_REGEX_REPLACER = "\\$&";

package/dist/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLEAN_REGEX_REPLACER = exports.CLEAN_SEARCH_REGEX = exports.DEFAULT_HTTP_STATUS = exports.PLACEHOLDER_PATTERN = void 0;
+exports.PLACEHOLDER_PATTERN = /\$\{\{\s{1}([^}\s]+)\s{1}\}\}/g;
+exports.DEFAULT_HTTP_STATUS = 500;
+exports.CLEAN_SEARCH_REGEX = /[.*+?^${}()|[\]\\]/g;
+exports.CLEAN_REGEX_REPLACER = "\\$&";

package/dist/exception.d.ts

@@ -0,0 +1,8 @@
+import type { ExceptionFormatterClass, ExceptionOptions } from "./types";
+export declare class Exception {
+    readonly response: string | Record<string, unknown>;
+    readonly status: number;
+    readonly options?: ExceptionOptions | undefined;
+    constructor(response: string | Record<string, unknown>, status: number, options?: ExceptionOptions | undefined);
+    format<T>(formatterClass: ExceptionFormatterClass<T>): T;
+}

package/dist/exception.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Exception = void 0;
+class Exception {
+    response;
+    status;
+    options;
+    constructor(response, status, options) {
+        this.response = response;
+        this.status = status;
+        this.options = options;
+    }
+    format(formatterClass) {
+        return new formatterClass(this.response, this.status, this.options);
+    }
+}
+exports.Exception = Exception;

package/dist/factory.d.ts

@@ -0,0 +1,9 @@
+import type { ErrorTemplateInput, ExceptionFormatterClass, Ferors, Logger } from "./types";
+export declare class FerorFactory<FormatterClass> {
+    private readonly logger;
+    private readonly formatterClass;
+    constructor(logger: Logger, formatterClass: ExceptionFormatterClass<FormatterClass>);
+    execute<const Templates extends Record<string, ErrorTemplateInput>>(prefix: string, templates: Templates): Ferors<Templates, FormatterClass>;
+    private generateCode;
+    private defineError;
+}

package/dist/factory.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FerorFactory = void 0;
+const constants_1 = require("./constants");
+const feror_1 = require("./feror");
+class FerorFactory {
+    logger;
+    formatterClass;
+    constructor(logger, formatterClass) {
+        this.logger = logger;
+        this.formatterClass = formatterClass;
+    }
+    execute(prefix, templates) {
+        const templateKeys = Object.keys(templates);
+        const entries = templateKeys.map((key, index) => {
+            const input = templates[key];
+            const errorTemplate = this.defineError(input);
+            const code = this.generateCode(prefix, key, index);
+            this.logger.execute(`Загрузка ошибки ${prefix} ${code} : ${errorTemplate.message}`);
+            const prefixed = {
+                ...errorTemplate,
+                message: `${code} : ${errorTemplate.message}`,
+            };
+            return [key, new feror_1.Feror(prefixed, this.logger, this.formatterClass)];
+        });
+        return Object.fromEntries(entries);
+    }
+    generateCode(prefix, key, index) {
+        const prefixEncoded = Buffer.from(prefix).toString("base64url");
+        const suffix = Buffer.from(`${key}:${index}`).toString("hex");
+        return `${prefixEncoded}:${suffix}`;
+    }
+    defineError(error) {
+        const combined = `${error.message} ${error.description}`;
+        const matches = combined.match(constants_1.PLACEHOLDER_PATTERN);
+        const allKeys = matches?.map((m) => m.slice(1, -1)) ?? [];
+        const uniqueKeys = Array.from(new Set(allKeys));
+        return { ...error, placeholders: uniqueKeys };
+    }
+}
+exports.FerorFactory = FerorFactory;

package/dist/feror.d.ts

@@ -0,0 +1,21 @@
+import type { ErrorTemplate, ExceptionFormatterClass, Logger, PlaceholderObject } from "./types";
+export declare class Feror<const Placeholders extends string[], FormatterClass> {
+    readonly template: ErrorTemplate<Placeholders>;
+    private readonly logger;
+    private readonly formatterClass;
+    private readonly placeholderRegexes;
+    constructor(template: ErrorTemplate<Placeholders>, logger: Logger, formatterClass: ExceptionFormatterClass<FormatterClass>);
+    execute(placeholders: PlaceholderObject<Placeholders>, cause?: Error): FormatterClass;
+    execute(cause?: Error): FormatterClass;
+    throw(placeholders: PlaceholderObject<Placeholders>, cause?: Error): never;
+    throw(cause?: Error): never;
+    private createStaticException;
+    private createDynamicException;
+    private formatTemplate;
+    private createException;
+    private collectPlaceholdersFromText;
+    private validatePlaceholders;
+    private buildRegexMap;
+    private extractPlaceholders;
+    private createRegEx;
+}

package/dist/feror.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Feror = void 0;
+const constants_1 = require("./constants");
+const exception_1 = require("./exception");
+const PLACEHOLDER_PATTERN = /\$\{\{\s{1}([^}\s]+)\s{1}\}\}/g;
+class Feror {
+    template;
+    logger;
+    formatterClass;
+    placeholderRegexes;
+    constructor(template, logger, formatterClass) {
+        this.template = template;
+        this.logger = logger;
+        this.formatterClass = formatterClass;
+        this.placeholderRegexes = this.extractPlaceholders(template);
+    }
+    execute(placeholdersOrCause, cause) {
+        let placeholders = undefined;
+        let actualCause;
+        if (placeholdersOrCause instanceof Error) {
+            actualCause = placeholdersOrCause;
+        }
+        else {
+            placeholders = placeholdersOrCause;
+            actualCause = cause;
+        }
+        if (!placeholders || Object.keys(placeholders).length === 0) {
+            return this.createStaticException(actualCause);
+        }
+        return this.createDynamicException(placeholders, actualCause);
+    }
+    throw(placeholdersOrCause, cause) {
+        if (placeholdersOrCause instanceof Error) {
+            throw this.execute(placeholdersOrCause);
+        }
+        throw this.execute(placeholdersOrCause, cause);
+    }
+    createStaticException(cause) {
+        return this.createException({ ...this.template, placeholders: [] }, cause);
+    }
+    createDynamicException(placeholders, cause) {
+        const error = this.formatTemplate(placeholders);
+        return this.createException(error, cause);
+    }
+    formatTemplate(placeholders) {
+        let message = this.template.message;
+        let description = this.template.description;
+        for (const [key, regex] of this.placeholderRegexes.entries()) {
+            const value = placeholders[key];
+            if (value === undefined) {
+                this.logger.error(new Error(`Placeholder {${key}} not provided in data`));
+                continue;
+            }
+            message = message.replace(regex, value);
+            description = description.replace(regex, value);
+        }
+        return {
+            ...this.template,
+            message,
+            description,
+            placeholders: [],
+        };
+    }
+    createException(error, cause) {
+        const status = error.status ?? this.template.status ?? constants_1.DEFAULT_HTTP_STATUS;
+        return new exception_1.Exception(error.message, status, {
+            description: error.description,
+            cause: cause ?? error.cause,
+        }).format(this.formatterClass);
+    }
+    collectPlaceholdersFromText(template) {
+        const text = `${template.message} ${template.description}`;
+        const set = new Set();
+        for (const match of text.matchAll(PLACEHOLDER_PATTERN)) {
+            set.add(match[1]);
+        }
+        return set;
+    }
+    validatePlaceholders(collectedPlaceholders, declaredPlaceholders) {
+        if (!declaredPlaceholders) {
+            return;
+        }
+        const errors = [];
+        for (const placeholder of declaredPlaceholders) {
+            if (collectedPlaceholders.has(placeholder)) {
+                continue;
+            }
+            errors.push(new Error(`Placeholder "${placeholder}" not found in text`));
+        }
+        for (const placeholder of collectedPlaceholders) {
+            if (declaredPlaceholders.includes(placeholder)) {
+                continue;
+            }
+            errors.push(new Error(`Placeholder from text "${placeholder}" not found in placeholders list`));
+        }
+        if (errors.length !== 0) {
+            errors.forEach((e) => this.logger.error(e));
+            throw new Error("Placeholder validation failed.");
+        }
+    }
+    buildRegexMap(keys) {
+        const placeholdersMap = new Map();
+        for (const key of keys) {
+            placeholdersMap.set(key, this.createRegEx(key));
+        }
+        return placeholdersMap;
+    }
+    extractPlaceholders(template) {
+        const collected = this.collectPlaceholdersFromText(template);
+        this.validatePlaceholders(collected, template.placeholders);
+        return this.buildRegexMap(collected);
+    }
+    createRegEx(key) {
+        const clean = key.replace(constants_1.CLEAN_SEARCH_REGEX, constants_1.CLEAN_REGEX_REPLACER);
+        return new RegExp(`\\$\\{\\{\\s{1}${clean}\\s{1}\\}\\}`);
+    }
+}
+exports.Feror = Feror;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { FerorFactory } from "./factory";
+export * from "./feror";
+export * from "./factory";
+export * from "./exception";
+export type { Logger, ExceptionOptions, } from "./types";
+export default FerorFactory;

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const factory_1 = require("./factory");
+__exportStar(require("./feror"), exports);
+__exportStar(require("./factory"), exports);
+__exportStar(require("./exception"), exports);
+exports.default = factory_1.FerorFactory;

package/dist/types.d.ts

@@ -0,0 +1,40 @@
+import { Exception } from "./exception";
+import type { Feror } from "./feror";
+export interface Logger {
+    error: (message: Error) => unknown;
+    execute: (message: string) => unknown;
+}
+export type PlaceholderObject<Placeholders extends string[]> = {
+    [P in Placeholders[number]]: string;
+};
+export type ExtractPlaceholdersTuple<InputString extends string, Acc extends string[] = []> = InputString extends `${infer _}\${{ ${infer P} }}${infer Rest}` ? ExtractPlaceholdersTuple<Rest, [...Acc, P]> : Acc;
+export type InferPlaceholders<T extends {
+    message: string;
+    description: string;
+}> = ExtractPlaceholdersTuple<`${T["message"]} ${T["description"]}`>;
+export type ErrorTemplateInput = {
+    message: string;
+    description: string;
+    cause?: Error;
+    status?: number;
+    options?: Record<string, unknown>;
+};
+export interface ErrorTemplate<Placeholders extends string[]> {
+    message: string;
+    description: string;
+    cause?: Error;
+    status?: number;
+    options?: Record<string, unknown>;
+    placeholders: Placeholders;
+}
+export type PlaceholderRegexMap<Placeholders extends string[]> = Map<keyof PlaceholderObject<Placeholders>, RegExp>;
+export type FormattedErrorTemplate = ErrorTemplate<[]>;
+export type Ferors<ErrorTemplate extends Record<string, ErrorTemplateInput>, FormatterClass> = {
+    [K in keyof ErrorTemplate]: Feror<InferPlaceholders<ErrorTemplate[K]>, FormatterClass>;
+};
+export interface ExceptionOptions {
+    cause?: unknown;
+    description?: string;
+}
+export type ExceptionConstuctorParameters = ConstructorParameters<typeof Exception>;
+export type ExceptionFormatterClass<T> = new (...parameters: ExceptionConstuctorParameters) => T;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "fockeror",
+  "version": "0.1.0",
+  "description": "",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fockusty/fockeror.git"
+  },
+  "homepage": "https://github.com/fockusty/fockeror#readme",
+  "bugs": {
+    "url": "https://github.com/fockusty/fockeror/issues"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [],
+  "author": {
+    "name": "FOCKUSTY",
+    "email": "viserd.yt@gmail.com",
+    "url": "https://fockusty.vercel.app"
+  },
+  "license": "MIT",
+  "packageManager": "pnpm@10.33.0",
+  "devDependencies": {
+    "@types/node": "^25.5.2",
+    "typescript": "^6.0.2"
+  }
+}