@rotyro-tools/nestjs-typeorm-validator 1.0.0

package/dist/index.js

@@ -0,0 +1,429 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decoratorStart = (base) => {
+  var _a3;
+  return [, , , __create((_a3 = base == null ? void 0 : base[__knownSymbol("metadata")]) != null ? _a3 : null)];
+};
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ExistsIn: () => ExistsIn,
+  UniqueIn: () => UniqueIn,
+  registerDataSourceForValidation: () => registerDataSourceForValidation
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors/validator.error.ts
+var ValidatorError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = this.constructor.name;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    if (cause == null ? void 0 : cause.stack) {
+      this.stack = `${this.stack}
+Caused by: ${cause.stack}`;
+    }
+  }
+};
+
+// src/errors/validation-configuration.error.ts
+var ValidationConfigurationError = class extends ValidatorError {
+  constructor(message, context) {
+    super(message);
+    this.context = context;
+  }
+};
+
+// src/errors/validation-query.error.ts
+var ValidationQueryError = class extends ValidatorError {
+  constructor(message, cause, context) {
+    super(message, cause);
+    this.context = context;
+  }
+};
+
+// src/errors/data-source-initialization.error.ts
+var DataSourceInitializationError = class extends ValidatorError {
+  constructor(dataSourceName, cause) {
+    super(
+      `DataSource "${dataSourceName}" is not initialized. Please ensure it's initialized before use.`,
+      cause
+    );
+  }
+};
+
+// src/errors/data-source-not-registered.error.ts
+var DataSourceNotRegisteredError = class extends ValidatorError {
+  constructor(dataSourceName = "default") {
+    super(
+      `DataSource "${dataSourceName}" is not registered. Please call registerDataSourceForValidation() first.`
+    );
+  }
+};
+
+// src/errors/data-source-invalid.error.ts
+var DataSourceInvalidError = class extends ValidatorError {
+  constructor(cause) {
+    super(`Invalid DataSource instance provided`, cause);
+  }
+};
+
+// src/utils/data-source.util.ts
+var dataSources = /* @__PURE__ */ new Map();
+var DEFAULT_DATA_SOURCE_NAME = "default";
+function registerDataSourceForValidation(dataSourceInstance, dataSourceName) {
+  if (!dataSourceInstance || typeof dataSourceInstance.getRepository !== "function") {
+    throw new DataSourceInvalidError();
+  }
+  const normalizedName = normalizeDataSourceName(dataSourceName);
+  dataSources.set(normalizedName, dataSourceInstance);
+}
+async function getDataSourceForValidation(dataSourceName) {
+  const normalizedName = normalizeDataSourceName(dataSourceName);
+  const dataSource = dataSources.get(normalizedName);
+  if (!dataSource) {
+    throw new DataSourceNotRegisteredError(normalizedName);
+  }
+  if (!dataSource.isInitialized) {
+    await dataSource.initialize();
+  }
+  if (!dataSource.isInitialized) {
+    throw new DataSourceInitializationError(normalizedName);
+  }
+  return dataSource;
+}
+function normalizeDataSourceName(dataSourceName) {
+  if (dataSourceName === null || dataSourceName === void 0) {
+    return DEFAULT_DATA_SOURCE_NAME;
+  }
+  if (typeof dataSourceName !== "string") {
+    throw new DataSourceInvalidError();
+  }
+  const trimmed = dataSourceName.trim();
+  if (trimmed === "") {
+    return DEFAULT_DATA_SOURCE_NAME;
+  }
+  return trimmed;
+}
+
+// src/decorators/exists-in.decorator.ts
+var import_class_validator3 = require("class-validator");
+
+// src/validators/base.validator.ts
+var BaseValidator = class {
+  /**
+   * Validates the configuration constraints.
+   *
+   * @param validatorArguments - Validation arguments
+   * @throws {ValidationConfigurationError} if constraints are invalid
+   *
+   * @protected
+   */
+  validateConstraints(validatorArguments, validatorName) {
+    const [entityOrTableName, columnName] = validatorArguments.constraints;
+    if (!entityOrTableName || !columnName) {
+      throw new ValidationConfigurationError(
+        `${validatorName}: entity/table name and column name are required`,
+        {
+          property: validatorArguments.property,
+          constraints: validatorArguments.constraints
+        }
+      );
+    }
+  }
+  /**
+   * Executes a database query to check for value existence.
+   *
+   * Returns a tuple: [anyExists, allExists]
+   * - anyExists: true if at least one of the provided values exists
+   * - allExists: true if all of the provided values exist
+   *
+   * For single values both flags are identical.
+   *
+   * @param value - The value to query
+   * @param validatorArguments - Validator arguments
+   * @returns Promise resolving to [anyExists, allExists]
+   * @throws {ValidationQueryError} if database query fails
+   *
+   * @protected
+   */
+  async valueExists(value, validatorArguments) {
+    var _a3;
+    const [entityOrTableName, columnName, dataSourceName, each] = validatorArguments.constraints;
+    try {
+      const normalizedDataSourceName = dataSourceName && typeof dataSourceName === "string" && dataSourceName.trim() !== "" ? dataSourceName.trim() : void 0;
+      const dataSource = await getDataSourceForValidation(
+        normalizedDataSourceName
+      );
+      const repository = typeof entityOrTableName === "string" ? dataSource.getRepository(entityOrTableName) : dataSource.getRepository(entityOrTableName != null ? entityOrTableName : "");
+      let queryValue = value;
+      if (each && each === true) {
+        queryValue = queryValue.split(",").map((v) => v.trim()).filter((v) => v !== "");
+      }
+      if (Array.isArray(queryValue)) {
+        const values = queryValue;
+        if (values.length === 0) {
+          return [false, false];
+        }
+        const uniqueValues = Array.from(new Set(values));
+        const countResult = await repository.createQueryBuilder("entityOrTableName").select(`COUNT(DISTINCT entityOrTableName.${columnName})`, "cnt").where(`entityOrTableName.${columnName} IN (:...values)`, {
+          values: uniqueValues
+        }).getRawOne();
+        const found = (_a3 = countResult && ("cnt" in countResult ? Number(countResult.cnt) : 0)) != null ? _a3 : 0;
+        const anyExists = found > 0;
+        const allExists = found === uniqueValues.length;
+        return [anyExists, allExists];
+      }
+      const result = await repository.createQueryBuilder("entityOrTableName").select("1").where(`entityOrTableName.${columnName} = :value`, {
+        value: queryValue
+      }).take(1).getRawOne();
+      const exists = result !== null && result !== void 0;
+      return [exists, exists];
+    } catch (error) {
+      if (error instanceof ValidationConfigurationError || error instanceof DataSourceNotRegisteredError || error instanceof DataSourceInitializationError || error instanceof DataSourceInvalidError) {
+        throw error;
+      }
+      const errMsg = error instanceof Error ? error.message : String(error);
+      if (/no metadata/i.test(errMsg) || /doesn't exist/i.test(errMsg)) {
+        const entityName2 = this.getEntityName(entityOrTableName);
+        throw new ValidationConfigurationError(
+          `No metadata found for "${entityName2}". Ensure it exists and is properly registered in the data source.`,
+          {
+            property: validatorArguments.property,
+            constraints: validatorArguments.constraints
+          }
+        );
+      }
+      const originalError = error instanceof Error ? error : new Error(String(error));
+      const entityName = this.getEntityName(entityOrTableName);
+      throw new ValidationQueryError(
+        `Failed to validate in ${entityName}.${columnName}`,
+        originalError,
+        {
+          property: validatorArguments.property,
+          value,
+          entity: entityName,
+          columnName
+        }
+      );
+    }
+  }
+  /**
+   * Extracts the entity name from entity target or table name string.
+   *
+   * @param entityOrTableName - Entity class or table name
+   * @returns The entity name
+   *
+   * @protected
+   */
+  getEntityName(entityOrTableName) {
+    return typeof entityOrTableName === "string" ? entityOrTableName : entityOrTableName.name || "entity";
+  }
+};
+
+// src/validators/exists-in.validator.ts
+var import_class_validator = require("class-validator");
+var _ExistsInValidator_decorators, _init, _a;
+_ExistsInValidator_decorators = [(0, import_class_validator.ValidatorConstraint)({ name: "ExistsIn", async: true })];
+var ExistsInValidator = class extends (_a = BaseValidator) {
+  /**
+   * Validates that the value exists in the specified database column.
+   *
+   * @param value - The value to validate
+   * @param validatorArguments - Validation arguments containing entity/table and column information
+   * @returns Promise resolving to true if the value exists, false otherwise
+   * @throws {ValidationConfigurationError} if configuration is invalid
+   * @throws {ValidationQueryError} if database query fails
+   *
+   * @public
+   */
+  async validate(value, validatorArguments) {
+    if (value === null || value === void 0) {
+      return false;
+    }
+    this.validateConstraints(validatorArguments, "ExistsIn");
+    const [anyExists, allExists] = await this.valueExists(
+      value,
+      validatorArguments
+    );
+    const each = validatorArguments.constraints[3];
+    if (each && each === true) {
+      return allExists;
+    }
+    return anyExists;
+  }
+  /**
+   * Generates the default error message when validation fails.
+   *
+   * @param validatorArguments - Validation arguments containing column information
+   * @returns The formatted error message
+   *
+   * @public
+   */
+  defaultMessage(validatorArguments) {
+    const [entityOrTableName, columnName, _dataSourceName, each] = validatorArguments.constraints;
+    const propertyName = validatorArguments.property;
+    const entityName = this.getEntityName(entityOrTableName);
+    if (each && each === true) {
+      return `${propertyName} with values [${validatorArguments.value}] do not all exist in ${entityName}.${columnName}`;
+    }
+    return `${propertyName} with value "${validatorArguments.value}" does not exist in ${entityName}.${columnName}`;
+  }
+};
+_init = __decoratorStart(_a);
+ExistsInValidator = __decorateElement(_init, 0, "ExistsInValidator", _ExistsInValidator_decorators, ExistsInValidator);
+__runInitializers(_init, 1, ExistsInValidator);
+
+// src/validators/unique-in.validator.ts
+var import_class_validator2 = require("class-validator");
+var _UniqueInValidator_decorators, _init2, _a2;
+_UniqueInValidator_decorators = [(0, import_class_validator2.ValidatorConstraint)({ name: "UniqueIn", async: true })];
+var UniqueInValidator = class extends (_a2 = BaseValidator) {
+  /**
+   * Validates that the value is unique in the specified database column.
+   *
+   * @param value - The value to validate
+   * @param validatorArguments - Validation arguments containing entity/table and column information
+   * @returns Promise resolving to true if the value is unique, false otherwise
+   * @throws {ValidationConfigurationError} if configuration is invalid
+   * @throws {ValidationQueryError} if database query fails
+   *
+   * @public
+   */
+  async validate(value, validatorArguments) {
+    if (value === null || value === void 0) {
+      return true;
+    }
+    this.validateConstraints(validatorArguments, "UniqueIn");
+    const [anyExists] = await this.valueExists(value, validatorArguments);
+    return !anyExists;
+  }
+  /**
+   * Generates the default error message when validation fails.
+   *
+   * @param validatorArguments - Validation arguments containing column information
+   * @returns The formatted error message
+   *
+   * @public
+   */
+  defaultMessage(validatorArguments) {
+    const [entityOrTableName, columnName, _dataSourceName, each] = validatorArguments.constraints;
+    const propertyName = validatorArguments.property;
+    const entityName = this.getEntityName(entityOrTableName);
+    if (each && each === true) {
+      return `${propertyName} with values [${validatorArguments.value}] are not all unique in ${entityName}.${columnName}`;
+    }
+    return `${propertyName} with value "${validatorArguments.value}" is not unique in ${entityName}.${columnName}`;
+  }
+};
+_init2 = __decoratorStart(_a2);
+UniqueInValidator = __decorateElement(_init2, 0, "UniqueInValidator", _UniqueInValidator_decorators, UniqueInValidator);
+__runInitializers(_init2, 1, UniqueInValidator);
+
+// src/decorators/exists-in.decorator.ts
+function ExistsIn(entityOrTableName, columnName, dataSourceName, validationOptions) {
+  return function(object, propertyName) {
+    (0, import_class_validator3.registerDecorator)({
+      target: object.constructor,
+      propertyName,
+      options: validationOptions,
+      constraints: [
+        entityOrTableName,
+        columnName,
+        dataSourceName,
+        validationOptions == null ? void 0 : validationOptions.each
+      ],
+      validator: ExistsInValidator
+    });
+  };
+}
+
+// src/decorators/unique-in.decorator.ts
+var import_class_validator4 = require("class-validator");
+function UniqueIn(entityOrTableName, columnName, dataSourceName, validationOptions) {
+  return function(object, propertyName) {
+    (0, import_class_validator4.registerDecorator)({
+      target: object.constructor,
+      propertyName,
+      options: validationOptions,
+      constraints: [
+        entityOrTableName,
+        columnName,
+        dataSourceName,
+        validationOptions == null ? void 0 : validationOptions.each
+      ],
+      validator: UniqueInValidator
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExistsIn,
+  UniqueIn,
+  registerDataSourceForValidation
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/errors/validator.error.ts","../src/errors/validation-configuration.error.ts","../src/errors/validation-query.error.ts","../src/errors/data-source-initialization.error.ts","../src/errors/data-source-not-registered.error.ts","../src/errors/data-source-invalid.error.ts","../src/utils/data-source.util.ts","../src/decorators/exists-in.decorator.ts","../src/validators/base.validator.ts","../src/validators/exists-in.validator.ts","../src/validators/unique-in.validator.ts","../src/decorators/unique-in.decorator.ts"],"sourcesContent":["export { registerDataSourceForValidation } from '@/utils';\nexport { ExistsIn } from '@/decorators';\nexport { UniqueIn } from '@/decorators';\n","/**\n * Base error class for all validator errors.\n * Preserves the original error stack trace when wrapping errors.\n *\n * @public\n */\nexport class ValidatorError extends Error {\n  constructor(\n    message: string,\n    public readonly cause?: Error,\n  ) {\n    super(message);\n    this.name = this.constructor.name;\n\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, this.constructor);\n    }\n\n    if (cause?.stack) {\n      this.stack = `${this.stack}\\nCaused by: ${cause.stack}`;\n    }\n  }\n}\n","import { ValidatorError } from '@/errors';\n\n/**\n * Error thrown when validation configuration is invalid.\n *\n * @public\n */\nexport class ValidationConfigurationError extends ValidatorError {\n  constructor(\n    message: string,\n    public readonly context?: Record<string, unknown>,\n  ) {\n    super(message);\n  }\n}\n","import { ValidatorError } from '@/errors';\n\n/**\n * Error thrown when a database query fails during validation.\n *\n * @public\n */\nexport class ValidationQueryError extends ValidatorError {\n  constructor(\n    message: string,\n    cause: Error,\n    public readonly context?: Record<string, unknown>,\n  ) {\n    super(message, cause);\n  }\n}\n","import { ValidatorError } from '@/errors';\n\n/**\n * Error thrown when data source initialization fails.\n *\n * @public\n */\nexport class DataSourceInitializationError extends ValidatorError {\n  constructor(dataSourceName: string, cause?: Error) {\n    super(\n      `DataSource \"${dataSourceName}\" is not initialized. Please ensure it's initialized before use.`,\n      cause,\n    );\n  }\n}\n","import { ValidatorError } from '@/errors';\n\n/**\n * Error thrown when data source is not registered.\n *\n * @public\n */\nexport class DataSourceNotRegisteredError extends ValidatorError {\n  constructor(dataSourceName: string = 'default') {\n    super(\n      `DataSource \"${dataSourceName}\" is not registered. Please call registerDataSourceForValidation() first.`,\n    );\n  }\n}\n","import { ValidatorError } from '@/errors';\n\n/**\n * Error thrown when data source is invalid.\n *\n * @public\n */\nexport class DataSourceInvalidError extends ValidatorError {\n  constructor(cause?: Error) {\n    super(`Invalid DataSource instance provided`, cause);\n  }\n}\n","import type { DataSource } from 'typeorm';\n\nimport {\n  DataSourceInitializationError,\n  DataSourceInvalidError,\n  DataSourceNotRegisteredError,\n} from '@/errors';\nimport type { DataSourceLike } from '@/types';\n\nconst dataSources = new Map<string, DataSourceLike>();\nconst DEFAULT_DATA_SOURCE_NAME = 'default';\n\n/**\n * Register a DataSource instance to be used for validation.\n * @param dataSourceInstance - TypeORM DataSource instance\n * @param dataSourceName - Optional DataSource name (defaults to 'default'). If `null`, `undefined`, or an empty string is passed,\n *                         the registration will use the 'default' name — the same name used when registering without specifying one.\n * @throws {DataSourceInvalidError} if the instance is invalid\n */\nexport function registerDataSourceForValidation(\n  dataSourceInstance: DataSourceLike,\n  dataSourceName?: string,\n): void {\n  if (\n    !dataSourceInstance ||\n    typeof dataSourceInstance.getRepository !== 'function'\n  ) {\n    throw new DataSourceInvalidError();\n  }\n\n  const normalizedName = normalizeDataSourceName(dataSourceName);\n  dataSources.set(normalizedName, dataSourceInstance);\n}\n\n/**\n * Get the registered DataSource for validation.\n * @param dataSourceName - DataSource name (defaults to 'default'). Passing `null`, `undefined`, or an empty string will resolve to 'default'.\n * @returns DataSource instance\n * @throws {DataSourceNotRegisteredError} if DataSource is not registered\n * @throws {DataSourceInitializationError} if DataSource fails to initialize\n */\nexport async function getDataSourceForValidation(\n  dataSourceName?: string,\n): Promise<DataSource> {\n  const normalizedName = normalizeDataSourceName(dataSourceName);\n  const dataSource = dataSources.get(normalizedName);\n\n  if (!dataSource) {\n    throw new DataSourceNotRegisteredError(normalizedName);\n  }\n\n  if (!dataSource.isInitialized) {\n    await dataSource.initialize();\n  }\n\n  if (!dataSource.isInitialized) {\n    throw new DataSourceInitializationError(normalizedName);\n  }\n\n  return dataSource as DataSource;\n}\n\n/**\n * Clear all registered data sources.\n */\nexport function clearDataSourcesForValidation(): void {\n  dataSources.clear();\n}\n\n/**\n * Normalizes and validates the data source name.\n * @param dataSourceName - The data source name to normalize. `null`, `undefined`, or empty string will map to the 'default' name.\n * @returns Normalized data source name\n * @throws {DataSourceInvalidError} if the name is invalid\n */\nfunction normalizeDataSourceName(dataSourceName?: string): string {\n  if (dataSourceName === null || dataSourceName === undefined) {\n    return DEFAULT_DATA_SOURCE_NAME;\n  }\n\n  if (typeof dataSourceName !== 'string') {\n    throw new DataSourceInvalidError();\n  }\n\n  const trimmed = dataSourceName.trim();\n\n  if (trimmed === '') {\n    return DEFAULT_DATA_SOURCE_NAME;\n  }\n\n  return trimmed;\n}\n","import { type ValidationOptions, registerDecorator } from 'class-validator';\nimport type { EntityTarget } from 'typeorm';\n\nimport { ExistsInValidator } from '@/validators';\n\n/**\n * Validates that the decorated property's value **exists in** a specific database column.\n *\n * @description\n * The `@ExistsIn` decorator performs a database lookup (via TypeORM) to verify that the\n * provided value **exists** in the specified table column.\n * It supports both:\n * - **Entity classes** (e.g., `User`, `Post`)\n * - **Table name strings** (e.g., `'user'`, `'post'`)\n *\n *\n * You can also specify which registered data source to use by passing the dataSourceName\n * (the same name you used when calling `registerDataSourceForValidation(dataSourceInstance, 'yourName')`).\n * If you pass `null` or `undefined` (or leave the parameter omitted), the decorator will use the\n * 'default' data source — the same default used when registering a data source without specifying a name.\n *\n * The `validationOptions` parameter accepts the same ValidationOptions used by `class-validator`.\n * Therefore options such as `each: true` (to validate array elements) and `message` (to provide a custom error message)\n * behave exactly as they do in `class-validator`.\n *\n * @example\n * **Using with an Entity class:**\n * ```typescript\n * class CreatePostDto {\n *   @ExistsIn(User, 'id')\n *   authorId: number;\n * }\n * ```\n *\n * @example\n * **Using with a table name:**\n * ```typescript\n * class CreatePostDto {\n *   @ExistsIn('user', 'id')\n *   authorId: number;\n * }\n * ```\n *\n * @example\n * **Using with a specific data source (registered as 'secondary'):**\n * ```typescript\n * class CreatePostDto {\n *   @ExistsIn(User, 'id', 'secondary')\n *   authorId: number;\n * }\n * ```\n *\n * @example\n * **Using a default data source and validating arrays with custom message:**\n * ```typescript\n * class CreateMultiplePostsDto {\n *   @ExistsIn('user', 'id', null, { each: true, message: 'Every authorId must exist' })\n *   authorIds: number[];\n * }\n * ```\n *\n * @param entityOrTableName - The entity class or table name to check against.\n * @param columnName - The column name in which to look for the value.\n * @param dataSourceName - Optional name of the data source to use for validation (must match a registered name).\n *                         Passing `null`/`undefined` (or omitting this argument) will use the 'default' data source.\n * @param validationOptions - Optional validation settings from `class-validator` (use `{ each: true }` for arrays and `message` for custom text).\n * @returns A property decorator function used by `class-validator`.\n *\n * @public\n */\nexport function ExistsIn<T extends EntityTarget<unknown> | string>(\n  entityOrTableName: T,\n  columnName: T extends string\n    ? string\n    : T extends EntityTarget<infer E>\n      ? keyof E & string\n      : string,\n  dataSourceName?: string,\n  validationOptions?: ValidationOptions,\n): PropertyDecorator {\n  return function (object: object, propertyName: string | symbol): void {\n    registerDecorator({\n      target: object.constructor,\n      propertyName: propertyName as string,\n      options: validationOptions,\n      constraints: [\n        entityOrTableName,\n        columnName,\n        dataSourceName,\n        validationOptions?.each,\n      ] as const,\n      validator: ExistsInValidator,\n    });\n  };\n}\n","import type {\n  DataSource,\n  EntityTarget,\n  ObjectLiteral,\n  Repository,\n} from 'typeorm';\n\nimport {\n  DataSourceInitializationError,\n  DataSourceInvalidError,\n  DataSourceNotRegisteredError,\n  ValidationConfigurationError,\n  ValidationQueryError,\n} from '@/errors';\nimport type { BaseValidatorArguments } from '@/types';\nimport { getDataSourceForValidation } from '@/utils';\n\n/**\n * Base validator.\n *\n * @description\n * Provides common functionality for validators,\n * including data source management, error handling, and entity name resolution.\n *\n * @abstract\n * @public\n */\nexport abstract class BaseValidator {\n  /**\n   * Validates the configuration constraints.\n   *\n   * @param validatorArguments - Validation arguments\n   * @throws {ValidationConfigurationError} if constraints are invalid\n   *\n   * @protected\n   */\n  protected validateConstraints(\n    validatorArguments: BaseValidatorArguments,\n    validatorName: string,\n  ): void {\n    const [entityOrTableName, columnName] = validatorArguments.constraints;\n\n    if (!entityOrTableName || !columnName) {\n      throw new ValidationConfigurationError(\n        `${validatorName}: entity/table name and column name are required`,\n        {\n          property: validatorArguments.property,\n          constraints: validatorArguments.constraints,\n        },\n      );\n    }\n  }\n\n  /**\n   * Executes a database query to check for value existence.\n   *\n   * Returns a tuple: [anyExists, allExists]\n   * - anyExists: true if at least one of the provided values exists\n   * - allExists: true if all of the provided values exist\n   *\n   * For single values both flags are identical.\n   *\n   * @param value - The value to query\n   * @param validatorArguments - Validator arguments\n   * @returns Promise resolving to [anyExists, allExists]\n   * @throws {ValidationQueryError} if database query fails\n   *\n   * @protected\n   */\n  protected async valueExists(\n    value: unknown,\n    validatorArguments: BaseValidatorArguments,\n  ): Promise<[boolean, boolean]> {\n    const [entityOrTableName, columnName, dataSourceName, each] =\n      validatorArguments.constraints;\n\n    try {\n      const normalizedDataSourceName =\n        dataSourceName &&\n        typeof dataSourceName === 'string' &&\n        dataSourceName.trim() !== ''\n          ? dataSourceName.trim()\n          : undefined;\n\n      const dataSource: DataSource = await getDataSourceForValidation(\n        normalizedDataSourceName,\n      );\n\n      const repository: Repository<ObjectLiteral> =\n        typeof entityOrTableName === 'string'\n          ? dataSource.getRepository(entityOrTableName)\n          : dataSource.getRepository(entityOrTableName ?? '');\n\n      let queryValue: unknown = value;\n      if (each && each === true) {\n        queryValue = (queryValue as string)\n          .split(',')\n          .map((v) => v.trim())\n          .filter((v) => v !== '');\n      }\n\n      // Array-value path\n      if (Array.isArray(queryValue)) {\n        const values = queryValue as unknown[];\n        if (values.length === 0) {\n          return [false, false];\n        }\n\n        const uniqueValues = Array.from(new Set(values));\n\n        const countResult = await repository\n          .createQueryBuilder('entityOrTableName')\n          .select(`COUNT(DISTINCT entityOrTableName.${columnName})`, 'cnt')\n          .where(`entityOrTableName.${columnName} IN (:...values)`, {\n            values: uniqueValues,\n          })\n          .getRawOne<{ cnt: string | number }>();\n\n        const found =\n          (countResult &&\n            ('cnt' in countResult ? Number(countResult.cnt) : 0)) ??\n          0;\n\n        const anyExists = found > 0;\n        const allExists = found === uniqueValues.length;\n\n        return [anyExists, allExists];\n      }\n\n      // Single-value path\n      const result: { '1': number } | null | undefined = await repository\n        .createQueryBuilder('entityOrTableName')\n        .select('1')\n        .where(`entityOrTableName.${columnName} = :value`, {\n          value: queryValue,\n        })\n        .take(1)\n        .getRawOne<{ '1': number }>();\n\n      const exists = result !== null && result !== undefined;\n      return [exists, exists];\n    } catch (error) {\n      if (\n        error instanceof ValidationConfigurationError ||\n        error instanceof DataSourceNotRegisteredError ||\n        error instanceof DataSourceInitializationError ||\n        error instanceof DataSourceInvalidError\n      ) {\n        throw error;\n      }\n      const errMsg = error instanceof Error ? error.message : String(error);\n\n      if (/no metadata/i.test(errMsg) || /doesn't exist/i.test(errMsg)) {\n        const entityName = this.getEntityName(entityOrTableName);\n        throw new ValidationConfigurationError(\n          `No metadata found for \"${entityName}\". Ensure it exists and is properly registered in the data source.`,\n          {\n            property: validatorArguments.property,\n            constraints: validatorArguments.constraints,\n          },\n        );\n      }\n      const originalError =\n        error instanceof Error ? error : new Error(String(error));\n\n      const entityName = this.getEntityName(entityOrTableName);\n\n      throw new ValidationQueryError(\n        `Failed to validate in ${entityName}.${columnName}`,\n        originalError,\n        {\n          property: validatorArguments.property,\n          value,\n          entity: entityName,\n          columnName: columnName,\n        },\n      );\n    }\n  }\n\n  /**\n   * Extracts the entity name from entity target or table name string.\n   *\n   * @param entityOrTableName - Entity class or table name\n   * @returns The entity name\n   *\n   * @protected\n   */\n  protected getEntityName(\n    entityOrTableName: EntityTarget<ObjectLiteral> | string,\n  ): string {\n    return typeof entityOrTableName === 'string'\n      ? entityOrTableName\n      : (entityOrTableName as { name?: string }).name || 'entity';\n  }\n}\n","import {\n  ValidatorConstraint,\n  type ValidatorConstraintInterface,\n} from 'class-validator';\n\nimport type { BaseValidatorArguments } from '@/types';\nimport { BaseValidator } from '@/validators';\n\n/**\n * Validator that checks if a value exists in a database table column.\n *\n * @description\n * This validator performs an asynchronous database query to verify the existence\n * of a value in the specified column. Used internally by the ExistsIn decorator.\n *\n * @public\n */\n@ValidatorConstraint({ name: 'ExistsIn', async: true })\nexport class ExistsInValidator\n  extends BaseValidator\n  implements ValidatorConstraintInterface\n{\n  /**\n   * Validates that the value exists in the specified database column.\n   *\n   * @param value - The value to validate\n   * @param validatorArguments - Validation arguments containing entity/table and column information\n   * @returns Promise resolving to true if the value exists, false otherwise\n   * @throws {ValidationConfigurationError} if configuration is invalid\n   * @throws {ValidationQueryError} if database query fails\n   *\n   * @public\n   */\n  async validate(\n    value: unknown,\n    validatorArguments: BaseValidatorArguments,\n  ): Promise<boolean> {\n    if (value === null || value === undefined) {\n      return false;\n    }\n\n    this.validateConstraints(validatorArguments, 'ExistsIn');\n\n    const [anyExists, allExists] = await this.valueExists(\n      value,\n      validatorArguments,\n    );\n\n    const each = validatorArguments.constraints[3];\n    if (each && each === true) {\n      return allExists;\n    }\n    return anyExists;\n  }\n  /**\n   * Generates the default error message when validation fails.\n   *\n   * @param validatorArguments - Validation arguments containing column information\n   * @returns The formatted error message\n   *\n   * @public\n   */\n  defaultMessage(validatorArguments: BaseValidatorArguments): string {\n    const [entityOrTableName, columnName, _dataSourceName, each] =\n      validatorArguments.constraints;\n    const propertyName = validatorArguments.property;\n    const entityName = this.getEntityName(entityOrTableName);\n\n    if (each && each === true) {\n      return `${propertyName} with values [${validatorArguments.value}] do not all exist in ${entityName}.${columnName}`;\n    }\n\n    return `${propertyName} with value \"${validatorArguments.value}\" does not exist in ${entityName}.${columnName}`;\n  }\n}\n","import {\n  ValidatorConstraint,\n  type ValidatorConstraintInterface,\n} from 'class-validator';\n\nimport type { BaseValidatorArguments } from '@/types';\nimport { BaseValidator } from '@/validators';\n\n/**\n * Validator that checks if a value is unique in a database table column.\n *\n * @description\n * This validator performs an asynchronous database query to verify the uniqueness\n * of a value in the specified column. Used internally by the UniqueIn decorator.\n *\n * @public\n */\n@ValidatorConstraint({ name: 'UniqueIn', async: true })\nexport class UniqueInValidator\n  extends BaseValidator\n  implements ValidatorConstraintInterface\n{\n  /**\n   * Validates that the value is unique in the specified database column.\n   *\n   * @param value - The value to validate\n   * @param validatorArguments - Validation arguments containing entity/table and column information\n   * @returns Promise resolving to true if the value is unique, false otherwise\n   * @throws {ValidationConfigurationError} if configuration is invalid\n   * @throws {ValidationQueryError} if database query fails\n   *\n   * @public\n   */\n  async validate(\n    value: unknown,\n    validatorArguments: BaseValidatorArguments,\n  ): Promise<boolean> {\n    if (value === null || value === undefined) {\n      return true;\n    }\n\n    this.validateConstraints(validatorArguments, 'UniqueIn');\n\n    const [anyExists] = await this.valueExists(value, validatorArguments);\n    return !anyExists;\n  }\n\n  /**\n   * Generates the default error message when validation fails.\n   *\n   * @param validatorArguments - Validation arguments containing column information\n   * @returns The formatted error message\n   *\n   * @public\n   */\n  defaultMessage(validatorArguments: BaseValidatorArguments): string {\n    const [entityOrTableName, columnName, _dataSourceName, each] =\n      validatorArguments.constraints;\n    const propertyName = validatorArguments.property;\n    const entityName = this.getEntityName(entityOrTableName);\n\n    if (each && each === true) {\n      return `${propertyName} with values [${validatorArguments.value}] are not all unique in ${entityName}.${columnName}`;\n    }\n\n    return `${propertyName} with value \"${validatorArguments.value}\" is not unique in ${entityName}.${columnName}`;\n  }\n}\n","import { type ValidationOptions, registerDecorator } from 'class-validator';\nimport type { EntityTarget } from 'typeorm';\n\nimport { UniqueInValidator } from '@/validators';\n\n/**\n * Validates that the decorated property's value is **unique** within a specified database column.\n *\n * @description\n * The `@UniqueIn` decorator performs a database lookup (via TypeORM) to ensure that the provided\n * value does **not already exist** in the specified table column.\n * It supports both:\n * - **Entity class references** (e.g., `User`, `Post`)\n * - **Direct table name strings** (e.g., `'user'`, `'post'`)\n *\n *\n * You can also specify which registered data source to use by passing the dataSourceName\n * (the same name you used when calling `registerDataSourceForValidation(dataSourceInstance, 'yourName')`).\n * If you pass `null` or `undefined` (or leave the parameter omitted), the decorator will use the\n * 'default' data source — the same default used when registering a data source without specifying a name.\n *\n * The `validationOptions` parameter accepts the same ValidationOptions used by `class-validator`.\n * Therefore options such as `each: true` (to validate array elements) and `message` (to provide a custom error message)\n * behave exactly as they do in `class-validator`.\n *\n * @example\n * **Using with an Entity class:**\n * ```typescript\n * class CreateUserDto {\n *   @UniqueIn(User, 'email')\n *   email: string;\n * }\n * ```\n *\n * @example\n * **Using with a table name:**\n * ```typescript\n * class CreateUserDto {\n *   @UniqueIn('user', 'email')\n *   email: string;\n * }\n * ```\n *\n * @example\n * **Using with a specific data source (registered as 'secondary'):**\n * ```typescript\n * class CreateUserDto {\n *   @UniqueIn(User, 'email', 'secondary')\n *   email: string;\n * }\n * ```\n *\n * @example\n * **Using a default data source and validating arrays with custom message:**\n * ```typescript\n * class CreateUsersDto {\n *   @UniqueIn('user', 'email', null, { each: true, message: 'Each user email must be unique' })\n *   emails: string[];\n * }\n * ```\n *\n * @param entityOrTableName - The entity class or table name to check against.\n * @param columnName - The column name to validate uniqueness in.\n * @param dataSourceName - Optional name of the data source to use for validation (must match a registered name).\n *                         Passing `null`/`undefined` (or omitting this argument) will use the 'default' data source.\n * @param validationOptions - Optional validation settings from `class-validator` (use `{ each: true }` for arrays and `message` for custom text).\n * @returns A property decorator function used by `class-validator`.\n *\n * @public\n */\nexport function UniqueIn<T extends EntityTarget<unknown> | string>(\n  entityOrTableName: T,\n  columnName: T extends string\n    ? string\n    : T extends EntityTarget<infer E>\n      ? keyof E & string\n      : string,\n  dataSourceName?: string,\n  validationOptions?: ValidationOptions,\n): PropertyDecorator {\n  return function (object: object, propertyName: string | symbol): void {\n    registerDecorator({\n      target: object.constructor,\n      propertyName: propertyName as string,\n      options: validationOptions,\n      constraints: [\n        entityOrTableName,\n        columnName,\n        dataSourceName,\n        validationOptions?.each,\n      ] as const,\n      validator: UniqueInValidator,\n    });\n  };\n}\n"],"mappings":"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","names":["import_class_validator","_a","entityName","import_class_validator","_init","_a","import_class_validator"]}