vsrepo 1.4.2 → 2.1.0

package/dist/internal/resolvers/merge-wheres.resolver.d.ts

@@ -0,0 +1,7 @@
+import { SeeMode } from "../../types/utils/see-mode.type";
+import { VSRepoWhere } from "../../types/vsrepo/vsrepo-where.type";
+export declare class MergeWheresResolver<T> {
+    private readonly softRemoveKey?;
+    constructor(softRemoveKey?: keyof T | undefined);
+    resolve(see?: SeeMode, provided?: VSRepoWhere<T>): VSRepoWhere<T>;
+}

package/dist/internal/resolvers/merge-wheres.resolver.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeWheresResolver = void 0;
+const deepmerge_1 = __importDefault(require("deepmerge"));
+class MergeWheresResolver {
+    softRemoveKey;
+    constructor(softRemoveKey) {
+        this.softRemoveKey = softRemoveKey;
+    }
+    resolve(see = "active", provided) {
+        const objectsToMerge = [];
+        if (provided)
+            objectsToMerge.push(provided);
+        if (this.softRemoveKey && see !== "all") {
+            objectsToMerge.push({
+                [this.softRemoveKey]: see === "active" ? null : { not: null },
+            });
+        }
+        const whereResolved = deepmerge_1.default.all(objectsToMerge);
+        return whereResolved;
+    }
+}
+exports.MergeWheresResolver = MergeWheresResolver;

package/dist/internal/utils/uncapitalize.util.d.ts

@@ -0,0 +1 @@
+export declare function uncapitalize(text: string): string;

package/dist/internal/utils/vs-logger.util.d.ts

@@ -0,0 +1,25 @@
+import { VSLogLevel } from "../enums/vs-log-level.enum";
+import { PerformData } from "../../types/utils/perform-data.type";
+export declare class VSLogger {
+    private readonly logLevel;
+    private readonly loggerName;
+    private readonly slowOperationThresholdMs;
+    private static readonly DEFAULT_SLOW_OPERATION_MS;
+    private readonly useColors;
+    constructor(logLevel: VSLogLevel, loggerName: string, slowOperationThresholdMs?: number);
+    getLogLevel(): VSLogLevel;
+    private color;
+    private stringfy;
+    private buildPrefix;
+    private log;
+    logDebug(text: string, obj?: any): void;
+    logInfo(text: string, obj?: any): void;
+    logWarn(text: string, obj?: any): void;
+    /**
+     * Loga um erro. Se `err` for uma instância de `Error`, apenas nome, mensagem,
+     * stack e cause são logados (evita despejar propriedades internas desnecessárias).
+     */
+    logError(text: string, err?: unknown): void;
+    startPerformLog(operation: string): PerformData | undefined;
+    endPerformLog(data: PerformData | undefined): void;
+}

package/dist/internal/utils/vs-logger.util.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VSLogger = void 0;
+const vs_log_level_enum_1 = require("../enums/vs-log-level.enum");
+/**
+ * ANSI escape codes used to colorize log output.
+ * Kept as raw codes (instead of a dependency like chalk) since colors here
+ * are a "nice to have" for local/dev usage, not a hard requirement.
+ */
+const ANSI = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    gray: "\x1b[90m",
+    cyan: "\x1b[36m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    magenta: "\x1b[35m",
+};
+const LEVEL_LABEL = {
+    [vs_log_level_enum_1.VSLogLevel.DEBUG]: "DEBUG",
+    [vs_log_level_enum_1.VSLogLevel.INFO]: "INFO",
+    [vs_log_level_enum_1.VSLogLevel.WARN]: "WARN",
+    [vs_log_level_enum_1.VSLogLevel.ERROR]: "ERROR",
+};
+const LEVEL_COLOR = {
+    [vs_log_level_enum_1.VSLogLevel.DEBUG]: ANSI.gray,
+    [vs_log_level_enum_1.VSLogLevel.INFO]: ANSI.cyan,
+    [vs_log_level_enum_1.VSLogLevel.WARN]: ANSI.yellow,
+    [vs_log_level_enum_1.VSLogLevel.ERROR]: ANSI.red,
+};
+class VSLogger {
+    logLevel;
+    loggerName;
+    slowOperationThresholdMs;
+    // * Acima disso, uma operação concluída é logada como WARN ao invés de DEBUG
+    static DEFAULT_SLOW_OPERATION_MS = 300;
+    useColors;
+    constructor(logLevel, loggerName, slowOperationThresholdMs = VSLogger.DEFAULT_SLOW_OPERATION_MS) {
+        this.logLevel = logLevel;
+        this.loggerName = loggerName;
+        this.slowOperationThresholdMs = slowOperationThresholdMs;
+        this.useColors = !process.env.NO_COLOR && !!process.stdout?.isTTY;
+    }
+    getLogLevel() {
+        return this.logLevel;
+    }
+    color(text, ansiColor) {
+        if (!this.useColors)
+            return text;
+        return `${ansiColor}${text}${ANSI.reset}`;
+    }
+    // * Evita quebrar em BigInt (comum em counts/ids do Prisma)
+    stringfy(obj) {
+        // const seen = new WeakSet<object>();
+        return JSON.stringify(obj, (_key, value) => {
+            if (typeof value === "bigint")
+                return `${value.toString()}n`;
+            if (value instanceof Error) {
+                return { name: value.name, message: value.message, stack: value.stack };
+            }
+            // if (typeof value === "object" && value !== null) {
+            //     if (seen.has(value)) return "[Circular]";
+            //     seen.add(value);
+            // }
+            return value;
+        }, 2);
+    }
+    buildPrefix(level) {
+        const timestamp = this.color(new Date().toISOString(), ANSI.dim);
+        const levelLabel = this.color(`[${LEVEL_LABEL[level]}]`, `${ANSI.bold}${LEVEL_COLOR[level]}`);
+        const name = this.color(`[${this.loggerName}]`, ANSI.magenta);
+        return `${timestamp} ${levelLabel} ${name}`;
+    }
+    log(level, text, obj) {
+        if (this.logLevel > level)
+            return;
+        const args = [`${this.buildPrefix(level)} ${text}`];
+        if (obj !== undefined) {
+            args.push("\n" + this.stringfy(obj));
+        }
+        if (level === vs_log_level_enum_1.VSLogLevel.ERROR) {
+            console.error(...args);
+        }
+        else if (level === vs_log_level_enum_1.VSLogLevel.WARN) {
+            console.warn(...args);
+        }
+        else {
+            console.log(...args);
+        }
+    }
+    logDebug(text, obj) {
+        this.log(vs_log_level_enum_1.VSLogLevel.DEBUG, text, obj);
+    }
+    logInfo(text, obj) {
+        this.log(vs_log_level_enum_1.VSLogLevel.INFO, text, obj);
+    }
+    logWarn(text, obj) {
+        this.log(vs_log_level_enum_1.VSLogLevel.WARN, text, obj);
+    }
+    /**
+     * Loga um erro. Se `err` for uma instância de `Error`, apenas nome, mensagem,
+     * stack e cause são logados (evita despejar propriedades internas desnecessárias).
+     */
+    logError(text, err) {
+        if (err instanceof Error) {
+            this.log(vs_log_level_enum_1.VSLogLevel.ERROR, text, {
+                name: err.name,
+                message: err.message,
+                stack: err.stack,
+                cause: err.cause,
+            });
+            return;
+        }
+        this.log(vs_log_level_enum_1.VSLogLevel.ERROR, text, err);
+    }
+    startPerformLog(operation) {
+        // * O timestamp é sempre capturado (é barato) para permitir detectar operações
+        // * lentas mesmo fora do DEBUG; a linha "Starting to X..." em si só aparece em DEBUG.
+        this.logDebug(`Starting to ${operation}...`);
+        return {
+            operation,
+            start: performance.now(),
+        };
+    }
+    endPerformLog(data) {
+        if (!data)
+            return;
+        const end = performance.now();
+        const timeTook = end - data.start;
+        const timeTookLabel = timeTook.toFixed(2);
+        if (timeTook >= this.slowOperationThresholdMs) {
+            this.logWarn(`Took ${timeTookLabel}ms to ${data.operation} (slower than the ${this.slowOperationThresholdMs}ms threshold)`);
+            return;
+        }
+        this.logDebug(`Took ${timeTookLabel}ms to ${data.operation}`);
+    }
+}
+exports.VSLogger = VSLogger;

package/dist/internal/validators/decorators.validator.d.ts

@@ -0,0 +1,8 @@
+import { DynamicMethodOptions } from "../../types/decorators/dynamic-method-options.type";
+import { QueryMethodOptions } from "../../types/decorators/query-method-options.type";
+export declare class DecoratorsValidator {
+    private static readonly dynamicMethodOptionsSchema;
+    static validateDynamicMethodOptions(options: unknown): DynamicMethodOptions;
+    private static queryMethodOptionsSchema;
+    static validateQueryMethodOptions(options: unknown): QueryMethodOptions;
+}

package/dist/internal/validators/decorators.validator.js

@@ -0,0 +1,75 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecoratorsValidator = void 0;
+const v = __importStar(require("valibot"));
+const VSRepoError_1 = require("../../errors/VSRepoError");
+const ordering_schema_1 = __importDefault(require("./schemas/ordering.schema"));
+const vsrepo_error_type_enum_1 = require("../enums/vsrepo-error-type.enum");
+class DecoratorsValidator {
+    static dynamicMethodOptionsSchema = v.object({
+        proxyTo: v.optional(v.string()),
+        injectOrdering: v.optional(ordering_schema_1.default),
+    });
+    static validateDynamicMethodOptions(options) {
+        const parsed = v.safeParse(this.dynamicMethodOptionsSchema, options);
+        if (!parsed.success) {
+            const firstIssue = parsed.issues[0];
+            const path = firstIssue.path?.length
+                ? firstIssue.path.map(p => String(p.key)).join(".")
+                : "options";
+            throw new VSRepoError_1.VSRepoError(`${path}: ${firstIssue.message}`, vsrepo_error_type_enum_1.VSRepoErrorType.DECORATOR);
+        }
+        return parsed.output;
+    }
+    static queryMethodOptionsSchema = v.object({
+        modifying: v.optional(v.boolean(), false),
+    });
+    static validateQueryMethodOptions(options) {
+        const parsed = v.safeParse(this.queryMethodOptionsSchema, options);
+        if (!parsed.success) {
+            const firstIssue = parsed.issues[0];
+            const path = firstIssue.path?.length
+                ? firstIssue.path.map(p => String(p.key)).join(".")
+                : "options";
+            throw new VSRepoError_1.VSRepoError(`${path}: ${firstIssue.message}`, vsrepo_error_type_enum_1.VSRepoErrorType.DECORATOR);
+        }
+        return parsed.output;
+    }
+}
+exports.DecoratorsValidator = DecoratorsValidator;

package/dist/internal/validators/schemas/ordering.schema.d.ts

@@ -0,0 +1,3 @@
+import * as v from "valibot";
+declare const _default: v.UnionSchema<[v.RecordSchema<v.StringSchema<undefined>, v.PicklistSchema<["asc", "desc", "ASC", "DESC"], undefined>, undefined>, v.ArraySchema<v.RecordSchema<v.StringSchema<undefined>, v.PicklistSchema<["asc", "desc", "ASC", "DESC"], undefined>, undefined>, undefined>], undefined>;
+export default _default;

package/dist/internal/validators/schemas/ordering.schema.js

@@ -0,0 +1,38 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const v = __importStar(require("valibot"));
+const recordSchema = v.record(v.string(), v.picklist(["asc", "desc", "ASC", "DESC"]));
+exports.default = v.union([recordSchema, v.array(recordSchema)]);

package/dist/internal/validators/schemas/pagination.schema.d.ts

@@ -0,0 +1,6 @@
+import * as v from "valibot";
+declare const _default: v.ObjectSchema<{
+    readonly limit: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+    readonly offset: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+}, undefined>;
+export default _default;

package/dist/internal/validators/schemas/pagination.schema.js

@@ -0,0 +1,40 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const v = __importStar(require("valibot"));
+exports.default = v.object({
+    limit: v.optional(v.number()),
+    offset: v.optional(v.number()),
+});

package/dist/internal/validators/schemas/where.schema.d.ts

@@ -0,0 +1,7 @@
+import * as v from "valibot";
+declare const _default: v.LooseObjectSchema<{
+    readonly AND: v.OptionalSchema<v.UnionSchema<[v.LooseObjectSchema<{}, undefined>, v.ArraySchema<v.LooseObjectSchema<{}, undefined>, undefined>], undefined>, undefined>;
+    readonly OR: v.OptionalSchema<v.UnionSchema<[v.LooseObjectSchema<{}, undefined>, v.ArraySchema<v.LooseObjectSchema<{}, undefined>, undefined>], undefined>, undefined>;
+    readonly NOT: v.OptionalSchema<v.UnionSchema<[v.LooseObjectSchema<{}, undefined>, v.ArraySchema<v.LooseObjectSchema<{}, undefined>, undefined>], undefined>, undefined>;
+}, undefined>;
+export default _default;

package/dist/internal/validators/schemas/where.schema.js

@@ -0,0 +1,42 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const v = __importStar(require("valibot"));
+// * Validação simplificada para não dar problema em ORMs com especifidades
+exports.default = v.looseObject({
+    AND: v.optional(v.union([v.looseObject({}), v.array(v.looseObject({}))])),
+    OR: v.optional(v.union([v.looseObject({}), v.array(v.looseObject({}))])),
+    NOT: v.optional(v.union([v.looseObject({}), v.array(v.looseObject({}))])),
+});

package/dist/internal/validators/vsrepo.validator.d.ts

@@ -0,0 +1,40 @@
+import { VSRepoOptions } from "../../types/vsrepo/vsrepo-options.type";
+import { MethodOptions } from "../../types/utils/methods-options.type";
+import { QueryMethodArg } from "../../types/utils/query-method-arg.type";
+import { VSRepoTransactionOptions } from "../../types/vsrepo/vsrepo-transaction-options.type";
+import { VSRepoOrmTypes } from "../../types/vsrepo/vsrepo-orm-types.type";
+import { Pagination } from "../../types/utils/pagination.type";
+import { Ordering } from "../../types/utils/ordering.type";
+import { VSLogger } from "../utils/vs-logger.util";
+import { VSRepoWhere } from "../../types/vsrepo/vsrepo-where.type";
+import { VSRepoQueryOptions } from "../../types/vsrepo/vsrepo-query-options.type";
+import { NumericLike } from "../../types/utils/numeric-like.type";
+import { RestrictMethodOptions } from "../../types/utils/restrict-method-options.type";
+export declare class VSRepoValidator<T, K, O extends VSRepoOrmTypes = VSRepoOrmTypes> {
+    private logger?;
+    setLogger(logger: VSLogger): void;
+    private failValidation;
+    private readonly constructorOptionsSchema;
+    validateConstructorOptions(options: unknown): VSRepoOptions<T, K>;
+    private readonly methodOptionsSchema;
+    validateMethodOptions(options?: unknown): MethodOptions<T, O>;
+    private readonly restrictMethodOptionsSchema;
+    validateRestrictMethodOptions(options?: unknown): RestrictMethodOptions<T, O>;
+    private readonly getAllMethodOptionsSchema;
+    validateGetAllMethodOptions(options?: unknown): MethodOptions<T, O> & {
+        pagination?: Pagination;
+        order?: Ordering<T>;
+    };
+    private queryArgSchema;
+    validateQueryMethodArg(arg?: unknown): QueryMethodArg<any>;
+    private queryOptionsSchema;
+    validateQueryOptions(options?: unknown): VSRepoQueryOptions;
+    private transactionOptionsSchema;
+    validateTransactionOptions(options: unknown): VSRepoTransactionOptions;
+    validateOrdering(value: unknown): Ordering<T>;
+    validatePagination(value: unknown): Pagination;
+    validateWhere(value: unknown): VSRepoWhere<T>;
+    private decimalLikeSchema;
+    private numericLikeSchema;
+    assertIsNumericLike(value: unknown): asserts value is NumericLike;
+}

package/dist/internal/validators/vsrepo.validator.js

@@ -0,0 +1,182 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VSRepoValidator = void 0;
+const v = __importStar(require("valibot"));
+const vs_log_level_enum_1 = require("../enums/vs-log-level.enum");
+const VSRepoError_1 = require("../../errors/VSRepoError");
+const ordering_schema_1 = __importDefault(require("./schemas/ordering.schema"));
+const vsrepo_error_type_enum_1 = require("../enums/vsrepo-error-type.enum");
+const transaction_isolation_level_enum_1 = require("../enums/transaction-isolation-level.enum");
+const pagination_schema_1 = __importDefault(require("./schemas/pagination.schema"));
+const where_schema_1 = __importDefault(require("./schemas/where.schema"));
+class VSRepoValidator {
+    // * Setado depois pelo VSRepository, pois no momento em que validateConstructorOptions
+    // * roda (validação das próprias options do construtor, incluindo o logLevel) o logger ainda não existe.
+    logger;
+    setLogger(logger) {
+        this.logger = logger;
+    }
+    failValidation(issue, type, fallbackPath = "options") {
+        const path = issue?.path?.length
+            ? issue.path.map(p => String(p.key)).join(".")
+            : fallbackPath;
+        const message = `${path}: ${issue?.message ?? "validation failed"}`;
+        this.logger?.logError(`Validation failed (${type}): ${message}`);
+        throw new VSRepoError_1.VSRepoError(message, type);
+    }
+    constructorOptionsSchema = v.object({
+        // * Usando any ao invés de instanceof para não ter erro de referencia
+        adapter: v.any(),
+        pkName: v.string(),
+        softRemoveKey: v.optional(v.string()),
+        logLevel: v.optional(v.enum(vs_log_level_enum_1.VSLogLevel)),
+        logSlowThresholdMs: v.optional(v.pipe(v.number(), v.gtValue(0))),
+        defaultOrdering: v.optional(ordering_schema_1.default),
+    });
+    validateConstructorOptions(options) {
+        const parsed = v.safeParse(this.constructorOptionsSchema, options);
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR);
+        }
+        return parsed.output;
+    }
+    methodOptionsSchema = v.object({
+        db: v.optional(v.any()),
+        see: v.optional(v.picklist(["active", "removed", "all"])),
+        relations: v.optional(v.looseObject({})),
+        select: v.optional(v.looseObject({})),
+    });
+    validateMethodOptions(options) {
+        const parsed = v.safeParse(this.methodOptionsSchema, options ?? {});
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR);
+        }
+        return parsed.output;
+    }
+    restrictMethodOptionsSchema = v.object({
+        db: v.optional(v.any()),
+        see: v.optional(v.picklist(["active", "removed", "all"])),
+    });
+    validateRestrictMethodOptions(options) {
+        const parsed = v.safeParse(this.restrictMethodOptionsSchema, options ?? {});
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR);
+        }
+        return parsed.output;
+    }
+    getAllMethodOptionsSchema = v.object({
+        ...this.methodOptionsSchema.entries,
+        order: v.optional(ordering_schema_1.default),
+        pagination: v.optional(pagination_schema_1.default),
+    });
+    validateGetAllMethodOptions(options) {
+        const parsed = v.safeParse(this.getAllMethodOptionsSchema, options ?? {});
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR);
+        }
+        return parsed.output;
+    }
+    queryArgSchema = v.object({
+        args: v.optional(v.array(v.any())),
+        db: v.optional(v.any()),
+    });
+    validateQueryMethodArg(arg) {
+        const parsed = v.safeParse(this.queryArgSchema, arg ?? {});
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR);
+        }
+        return parsed.output;
+    }
+    queryOptionsSchema = v.object({
+        args: v.optional(v.array(v.any())),
+        db: v.optional(v.any()),
+        modifying: v.optional(v.boolean()),
+    });
+    validateQueryOptions(options) {
+        const parsed = v.safeParse(this.queryOptionsSchema, options ?? {});
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR);
+        }
+        return parsed.output;
+    }
+    transactionOptionsSchema = v.object({
+        timeoutMs: v.optional(v.number()),
+        isolationLevel: v.optional(v.enum(transaction_isolation_level_enum_1.TransactionIsolationLevel)),
+    });
+    validateTransactionOptions(options) {
+        const parsed = v.safeParse(this.transactionOptionsSchema, options ?? {});
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR);
+        }
+        return parsed.output;
+    }
+    validateOrdering(value) {
+        const parsed = v.safeParse(ordering_schema_1.default, value);
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR, "ordering");
+        }
+        return parsed.output;
+    }
+    validatePagination(value) {
+        const parsed = v.safeParse(pagination_schema_1.default, value);
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR, "pagination");
+        }
+        return parsed.output;
+    }
+    validateWhere(value) {
+        const parsed = v.safeParse(where_schema_1.default, value);
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR, "where");
+        }
+        return parsed.output;
+    }
+    decimalLikeSchema = v.looseObject({
+        toNumber: v.function(),
+        decimalPlaces: v.function(),
+    });
+    numericLikeSchema = v.union([v.number(), v.bigint(), this.decimalLikeSchema]);
+    assertIsNumericLike(value) {
+        const parsed = v.safeParse(this.numericLikeSchema, value);
+        if (!parsed.success) {
+            this.failValidation(parsed.issues[0], vsrepo_error_type_enum_1.VSRepoErrorType.VALIDATOR);
+        }
+    }
+}
+exports.VSRepoValidator = VSRepoValidator;