unischema 1.0.1 → 1.1.0

package/dist/chunk-BVRXGZLS.js

@@ -0,0 +1,17 @@
+'use strict';
+
+// src/types/index.ts
+function toEnterpriseResponse(result, data) {
+  return {
+    status: result.valid ? "success" : "validation_error",
+    data: result.valid ? data : void 0,
+    errors: [...result.hardErrors, ...result.softErrors],
+    msg: result.valid ? "Validation successful" : "Validation failed",
+    validation: {
+      hard_validations: result.hardErrors,
+      soft_validations: result.softErrors
+    }
+  };
+}
+
+exports.toEnterpriseResponse = toEnterpriseResponse;

package/dist/chunk-CQYXR2LZ.js

@@ -0,0 +1,353 @@
+'use strict';
+
+var chunkNUW55QTO_js = require('./chunk-NUW55QTO.js');
+
+// src/validators/string/email.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var emailValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_EMAIL", "Email must be a string", soft);
+  }
+  if (!EMAIL_REGEX.test(value)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_EMAIL",
+      message || "Invalid email address",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/url.ts
+var urlValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_URL", "URL must be a string", soft);
+  }
+  try {
+    new URL(value);
+    return null;
+  } catch {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_URL",
+      message || "Invalid URL format",
+      soft
+    );
+  }
+};
+
+// src/validators/string/ipAddress.ts
+var IPV4_REGEX = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+var ipAddressValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_IP", "IP address must be a string", soft);
+  }
+  if (!IPV4_REGEX.test(value)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_IP",
+      message || "Invalid IP address format",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/ipv6.ts
+var IPV6_REGEX = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|::)$/;
+var ipv6Validator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_IPV6", "IPv6 address must be a string", soft);
+  }
+  if (!IPV6_REGEX.test(value)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_IPV6",
+      message || "Invalid IPv6 address format",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/alpha.ts
+var ALPHA_REGEX = /^[a-zA-Z]+$/;
+var alphaValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_ALPHA", "Value must be a string", soft);
+  }
+  if (!ALPHA_REGEX.test(value)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_ALPHA",
+      message || "Must contain only letters",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/alphanumeric.ts
+var ALPHANUMERIC_REGEX = /^[a-zA-Z0-9]+$/;
+var alphanumericValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_ALPHANUMERIC", "Value must be a string", soft);
+  }
+  if (!ALPHANUMERIC_REGEX.test(value)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_ALPHANUMERIC",
+      message || "Must contain only letters and numbers",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/numeric.ts
+var NUMERIC_REGEX = /^[0-9]+$/;
+var numericValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_NUMERIC", "Value must be a string", soft);
+  }
+  if (!NUMERIC_REGEX.test(value)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_NUMERIC",
+      message || "Must contain only numbers",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/lowercase.ts
+var lowercaseValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_LOWERCASE", "Value must be a string", soft);
+  }
+  if (value !== value.toLowerCase()) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_LOWERCASE",
+      message || "Must be lowercase",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/uppercase.ts
+var uppercaseValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_UPPERCASE", "Value must be a string", soft);
+  }
+  if (value !== value.toUpperCase()) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_UPPERCASE",
+      message || "Must be uppercase",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/slug.ts
+var SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var slugValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_SLUG", "Slug must be a string", soft);
+  }
+  if (!SLUG_REGEX.test(value)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_SLUG",
+      message || "Must be a valid URL slug (lowercase, numbers, hyphens)",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/hex.ts
+var HEX_REGEX = /^(0x)?[0-9a-fA-F]+$/;
+var hexValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_HEX", "Hex value must be a string", soft);
+  }
+  if (!HEX_REGEX.test(value)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_HEX",
+      message || "Must be a valid hexadecimal string",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/base64.ts
+var BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+var base64Validator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_BASE64", "Base64 value must be a string", soft);
+  }
+  if (!BASE64_REGEX.test(value)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_BASE64",
+      message || "Must be a valid base64 string",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/json.ts
+var jsonValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) {
+    return chunkNUW55QTO_js.createError(context, "INVALID_JSON", "JSON value must be a string", soft);
+  }
+  try {
+    JSON.parse(value);
+    return null;
+  } catch {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_JSON",
+      message || "Must be valid JSON",
+      soft
+    );
+  }
+};
+
+// src/validators/string/length.ts
+var lengthValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const length = params?.length;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) return null;
+  if (value.length !== length) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_LENGTH",
+      message || `Must be exactly ${length} characters`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/contains.ts
+var containsValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const substring = params?.substring;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) return null;
+  if (!value.includes(substring)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_CONTAINS",
+      message || `Must contain "${substring}"`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/startsWith.ts
+var startsWithValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const prefix = params?.prefix;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) return null;
+  if (!value.startsWith(prefix)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_STARTS_WITH",
+      message || `Must start with "${prefix}"`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/string/endsWith.ts
+var endsWithValidator = (value, params, context) => {
+  if (chunkNUW55QTO_js.isEmpty(value)) return null;
+  const suffix = params?.suffix;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkNUW55QTO_js.isString(value)) return null;
+  if (!value.endsWith(suffix)) {
+    return chunkNUW55QTO_js.createError(
+      context,
+      "INVALID_ENDS_WITH",
+      message || `Must end with "${suffix}"`,
+      soft
+    );
+  }
+  return null;
+};
+
+exports.alphaValidator = alphaValidator;
+exports.alphanumericValidator = alphanumericValidator;
+exports.base64Validator = base64Validator;
+exports.containsValidator = containsValidator;
+exports.emailValidator = emailValidator;
+exports.endsWithValidator = endsWithValidator;
+exports.hexValidator = hexValidator;
+exports.ipAddressValidator = ipAddressValidator;
+exports.ipv6Validator = ipv6Validator;
+exports.jsonValidator = jsonValidator;
+exports.lengthValidator = lengthValidator;
+exports.lowercaseValidator = lowercaseValidator;
+exports.numericValidator = numericValidator;
+exports.slugValidator = slugValidator;
+exports.startsWithValidator = startsWithValidator;
+exports.uppercaseValidator = uppercaseValidator;
+exports.urlValidator = urlValidator;

package/dist/chunk-ELL7U7IC.mjs

@@ -0,0 +1,237 @@
+import { isEmpty, parseDate, createError } from './chunk-FKDWSZIV.mjs';
+
+// src/validators/date/today.ts
+var todayValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = parseDate(value);
+  if (!date) return null;
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  if (date.getTime() !== today.getTime()) {
+    return createError(
+      context,
+      "INVALID_TODAY",
+      message || "Date must be today",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/yesterday.ts
+var yesterdayValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = parseDate(value);
+  if (!date) return null;
+  const yesterday = /* @__PURE__ */ new Date();
+  yesterday.setDate(yesterday.getDate() - 1);
+  yesterday.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  if (date.getTime() !== yesterday.getTime()) {
+    return createError(
+      context,
+      "INVALID_YESTERDAY",
+      message || "Date must be yesterday",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/tomorrow.ts
+var tomorrowValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = parseDate(value);
+  if (!date) return null;
+  const tomorrow = /* @__PURE__ */ new Date();
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  tomorrow.setHours(0, 0, 0, 0);
+  date.setHours(0, 0, 0, 0);
+  if (date.getTime() !== tomorrow.getTime()) {
+    return createError(
+      context,
+      "INVALID_TOMORROW",
+      message || "Date must be tomorrow",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/thisWeek.ts
+var thisWeekValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = parseDate(value);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const startOfWeek = new Date(now);
+  startOfWeek.setDate(now.getDate() - now.getDay());
+  startOfWeek.setHours(0, 0, 0, 0);
+  const endOfWeek = new Date(startOfWeek);
+  endOfWeek.setDate(startOfWeek.getDate() + 6);
+  endOfWeek.setHours(23, 59, 59, 999);
+  if (date < startOfWeek || date > endOfWeek) {
+    return createError(
+      context,
+      "INVALID_THIS_WEEK",
+      message || "Date must be within this week",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/thisMonth.ts
+var thisMonthValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = parseDate(value);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+  const endOfMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0, 23, 59, 59, 999);
+  if (date < startOfMonth || date > endOfMonth) {
+    return createError(
+      context,
+      "INVALID_THIS_MONTH",
+      message || "Date must be within this month",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/thisYear.ts
+var thisYearValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = parseDate(value);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const startOfYear = new Date(now.getFullYear(), 0, 1);
+  const endOfYear = new Date(now.getFullYear(), 11, 31, 23, 59, 59, 999);
+  if (date < startOfYear || date > endOfYear) {
+    return createError(
+      context,
+      "INVALID_THIS_YEAR",
+      message || "Date must be within this year",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/weekday.ts
+var weekdayValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = parseDate(value);
+  if (!date) return null;
+  const day = date.getDay();
+  if (day === 0 || day === 6) {
+    return createError(
+      context,
+      "INVALID_WEEKDAY",
+      message || "Date must be a weekday",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/weekend.ts
+var weekendValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = parseDate(value);
+  if (!date) return null;
+  const day = date.getDay();
+  if (day !== 0 && day !== 6) {
+    return createError(
+      context,
+      "INVALID_WEEKEND",
+      message || "Date must be a weekend",
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/age.ts
+var ageValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const min = params?.min;
+  const max = params?.max;
+  const soft = params?.soft;
+  const message = params?.message;
+  const birthDate = parseDate(value);
+  if (!birthDate) return null;
+  const today = /* @__PURE__ */ new Date();
+  let age = today.getFullYear() - birthDate.getFullYear();
+  const monthDiff = today.getMonth() - birthDate.getMonth();
+  if (monthDiff < 0 || monthDiff === 0 && today.getDate() < birthDate.getDate()) {
+    age--;
+  }
+  if (min !== void 0 && age < min) {
+    return createError(
+      context,
+      "INVALID_AGE_MIN",
+      message || `Age must be at least ${min}`,
+      soft
+    );
+  }
+  if (max !== void 0 && age > max) {
+    return createError(
+      context,
+      "INVALID_AGE_MAX",
+      message || `Age must be at most ${max}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/date/between.ts
+var betweenValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const start = params?.start;
+  const end = params?.end;
+  const soft = params?.soft;
+  const message = params?.message;
+  const date = parseDate(value);
+  if (!date) return null;
+  const startDate = parseDate(start);
+  const endDate = parseDate(end);
+  if (startDate && date < startDate) {
+    return createError(
+      context,
+      "INVALID_DATE_BEFORE",
+      message || `Date must be after ${startDate.toLocaleDateString()}`,
+      soft
+    );
+  }
+  if (endDate && date > endDate) {
+    return createError(
+      context,
+      "INVALID_DATE_AFTER",
+      message || `Date must be before ${endDate.toLocaleDateString()}`,
+      soft
+    );
+  }
+  return null;
+};
+
+export { ageValidator, betweenValidator, thisMonthValidator, thisWeekValidator, thisYearValidator, todayValidator, tomorrowValidator, weekdayValidator, weekendValidator, yesterdayValidator };

package/dist/chunk-FKDWSZIV.mjs

@@ -0,0 +1,39 @@
+// src/validators/utils.ts
+function createError(context, code, message, soft = false) {
+  return {
+    field: context.path,
+    code,
+    message,
+    severity: soft ? "soft" : "hard"
+  };
+}
+function isEmpty(value) {
+  return value === void 0 || value === null || value === "";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isDate(value) {
+  return value instanceof Date && !isNaN(value.getTime());
+}
+function parseDate(value) {
+  if (value instanceof Date) {
+    return isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value === "string") {
+    const parsed = new Date(value);
+    return isNaN(parsed.getTime()) ? null : parsed;
+  }
+  return null;
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export { createError, isArray, isDate, isEmpty, isNumber, isObject, isString, parseDate };