unischema 1.0.1 → 1.2.0

package/dist/chunk-75YSYC4K.mjs

@@ -0,0 +1,85 @@
+import { isEmpty, isObject, createError } from './chunk-KZZ7NVU3.mjs';
+
+// src/validators/object/keys.ts
+var keysValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const pattern = params?.pattern;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isObject(value)) return null;
+  if (pattern) {
+    const keys = Object.keys(value);
+    const invalidKeys = keys.filter((key) => !pattern.test(key));
+    if (invalidKeys.length > 0) {
+      return createError(
+        context,
+        "INVALID_KEYS",
+        message || `Invalid keys: ${invalidKeys.join(", ")}`,
+        soft
+      );
+    }
+  }
+  return null;
+};
+
+// src/validators/object/pick.ts
+var pickValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const allowedKeys = params?.keys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isObject(value) || !allowedKeys) return null;
+  const keys = Object.keys(value);
+  const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
+  if (extraKeys.length > 0) {
+    return createError(
+      context,
+      "INVALID_PICK",
+      message || `Unexpected keys: ${extraKeys.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/object/omit.ts
+var omitValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const forbiddenKeys = params?.keys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isObject(value) || !forbiddenKeys) return null;
+  const keys = Object.keys(value);
+  const foundForbidden = keys.filter((key) => forbiddenKeys.includes(key));
+  if (foundForbidden.length > 0) {
+    return createError(
+      context,
+      "INVALID_OMIT",
+      message || `Forbidden keys found: ${foundForbidden.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/object/strict.ts
+var strictValidator = (value, params, context) => {
+  if (isEmpty(value)) return null;
+  const allowedKeys = params?.allowedKeys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!isObject(value) || !allowedKeys) return null;
+  const keys = Object.keys(value);
+  const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
+  if (extraKeys.length > 0) {
+    return createError(
+      context,
+      "INVALID_STRICT",
+      message || `Unknown keys not allowed: ${extraKeys.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+export { keysValidator, omitValidator, pickValidator, strictValidator };

package/dist/chunk-76BBWQDH.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var chunkOIYG5D2I_js = require('./chunk-OIYG5D2I.js');
+
+// src/validators/object/keys.ts
+var keysValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const pattern = params?.pattern;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isObject(value)) return null;
+  if (pattern) {
+    const keys = Object.keys(value);
+    const invalidKeys = keys.filter((key) => !pattern.test(key));
+    if (invalidKeys.length > 0) {
+      return chunkOIYG5D2I_js.createError(
+        context,
+        "INVALID_KEYS",
+        message || `Invalid keys: ${invalidKeys.join(", ")}`,
+        soft
+      );
+    }
+  }
+  return null;
+};
+
+// src/validators/object/pick.ts
+var pickValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const allowedKeys = params?.keys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isObject(value) || !allowedKeys) return null;
+  const keys = Object.keys(value);
+  const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
+  if (extraKeys.length > 0) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_PICK",
+      message || `Unexpected keys: ${extraKeys.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/object/omit.ts
+var omitValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const forbiddenKeys = params?.keys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isObject(value) || !forbiddenKeys) return null;
+  const keys = Object.keys(value);
+  const foundForbidden = keys.filter((key) => forbiddenKeys.includes(key));
+  if (foundForbidden.length > 0) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_OMIT",
+      message || `Forbidden keys found: ${foundForbidden.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+// src/validators/object/strict.ts
+var strictValidator = (value, params, context) => {
+  if (chunkOIYG5D2I_js.isEmpty(value)) return null;
+  const allowedKeys = params?.allowedKeys;
+  const soft = params?.soft;
+  const message = params?.message;
+  if (!chunkOIYG5D2I_js.isObject(value) || !allowedKeys) return null;
+  const keys = Object.keys(value);
+  const extraKeys = keys.filter((key) => !allowedKeys.includes(key));
+  if (extraKeys.length > 0) {
+    return chunkOIYG5D2I_js.createError(
+      context,
+      "INVALID_STRICT",
+      message || `Unknown keys not allowed: ${extraKeys.join(", ")}`,
+      soft
+    );
+  }
+  return null;
+};
+
+exports.keysValidator = keysValidator;
+exports.omitValidator = omitValidator;
+exports.pickValidator = pickValidator;
+exports.strictValidator = strictValidator;

package/dist/chunk-7XES4A3M.mjs

@@ -0,0 +1,237 @@
+import { isEmpty, parseDate, createError } from './chunk-KZZ7NVU3.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-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;