@famgia/omnify-core 0.0.136 → 0.0.137

package/dist/index.cjs

@@ -1217,10 +1217,89 @@ var BASE_PROPERTY_FIELDS = [
   // Per-field settings for compound types
 ];
 var VALID_RULES_FIELDS = [
+  // Basic
   "required",
+  // String length
   "minLength",
-  "maxLength"
+  "maxLength",
+  // Format (String only)
+  "url",
+  "uuid",
+  "ip",
+  "ipv4",
+  "ipv6",
+  // Character pattern (String only)
+  "alpha",
+  "alphaNum",
+  "alphaDash",
+  "numeric",
+  "digits",
+  "digitsBetween",
+  // String matching (String only)
+  "startsWith",
+  "endsWith",
+  "lowercase",
+  "uppercase",
+  // Numeric (Int/Float only)
+  "min",
+  "max",
+  "between",
+  "gt",
+  "lt",
+  "multipleOf",
+  // Array
+  "arrayMin",
+  "arrayMax"
 ];
+var RULES_TYPE_GROUPS = {
+  string: ["String", "Text", "MediumText", "LongText", "Password", "Email"],
+  numeric: ["TinyInt", "Int", "BigInt", "Float", "Decimal"],
+  date: ["Date", "DateTime", "Time", "Timestamp"],
+  any: []
+  // 全タイプに適用可能
+};
+var RULES_TYPE_COMPATIBILITY = {
+  // Basic - any type
+  required: "any",
+  // String length rules
+  minLength: "string",
+  maxLength: "string",
+  // Format rules (String only)
+  url: "string",
+  uuid: "string",
+  ip: "string",
+  ipv4: "string",
+  ipv6: "string",
+  // Character pattern rules (String only)
+  alpha: "string",
+  alphaNum: "string",
+  alphaDash: "string",
+  numeric: "string",
+  digits: "string",
+  digitsBetween: "string",
+  // String matching rules (String only)
+  startsWith: "string",
+  endsWith: "string",
+  lowercase: "string",
+  uppercase: "string",
+  // Numeric rules (Int/Float only)
+  min: "numeric",
+  max: "numeric",
+  between: "numeric",
+  gt: "numeric",
+  lt: "numeric",
+  multipleOf: "numeric",
+  // Array rules - handled separately
+  arrayMin: "any",
+  arrayMax: "any"
+};
+function isRuleCompatibleWithType(rule, propertyType) {
+  const category = RULES_TYPE_COMPATIBILITY[rule];
+  if (!category) return false;
+  if (category === "any") return true;
+  const allowedTypes = RULES_TYPE_GROUPS[category];
+  return allowedTypes.includes(propertyType);
+}
 function createValidFields(additionalFields) {
   return [...BASE_PROPERTY_FIELDS, ...additionalFields];
 }
@@ -2693,13 +2772,13 @@ Example:
   }
   return `Unknown field '${field}'. Valid property fields: type, displayName, placeholder, nullable, default, unique, primary, description, length, unsigned, precision, scale, enum, relation, target, onDelete, onUpdate, joinTable, rules, hidden, fillable, fields`;
 }
-var STRING_TYPES_WITH_LENGTH_RULES = ["String", "Email", "Password"];
 function validateRules(propertyName, property, filePath) {
   const errors = [];
   const rules = property.rules;
   if (!rules || typeof rules !== "object") {
     return errors;
   }
+  const propertyType = property.type;
   const validRulesSet = new Set(VALID_RULES_FIELDS);
   for (const field of Object.keys(rules)) {
     if (!validRulesSet.has(field)) {
@@ -2712,77 +2791,260 @@ function validateRules(propertyName, property, filePath) {
       );
     }
   }
-  const { required, minLength, maxLength } = rules;
-  if (required !== void 0 && typeof required !== "boolean") {
+  for (const [ruleName, ruleValue] of Object.entries(rules)) {
+    if (ruleValue === void 0 || ruleValue === null) continue;
+    if (!validRulesSet.has(ruleName)) continue;
+    if (!isRuleCompatibleWithType(ruleName, propertyType)) {
+      const stringTypes = RULES_TYPE_GROUPS.string.join(", ");
+      const numericTypes2 = RULES_TYPE_GROUPS.numeric.join(", ");
+      let allowedTypes = "";
+      if ([
+        "minLength",
+        "maxLength",
+        "url",
+        "uuid",
+        "ip",
+        "ipv4",
+        "ipv6",
+        "alpha",
+        "alphaNum",
+        "alphaDash",
+        "numeric",
+        "digits",
+        "digitsBetween",
+        "startsWith",
+        "endsWith",
+        "lowercase",
+        "uppercase"
+      ].includes(ruleName)) {
+        allowedTypes = stringTypes;
+      } else if (["min", "max", "between", "gt", "lt", "multipleOf"].includes(ruleName)) {
+        allowedTypes = numericTypes2;
+      }
+      if (allowedTypes) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' of type '${propertyType}' cannot use rules.${ruleName}`,
+            buildLocation7(filePath),
+            `rules.${ruleName} is only valid for types: ${allowedTypes}`
+          )
+        );
+      }
+    }
+  }
+  const {
+    required,
+    minLength,
+    maxLength,
+    url,
+    uuid,
+    ip,
+    ipv4,
+    ipv6,
+    alpha,
+    alphaNum,
+    alphaDash,
+    numeric,
+    lowercase,
+    uppercase,
+    digits,
+    digitsBetween,
+    startsWith,
+    endsWith,
+    min,
+    max,
+    between,
+    gt,
+    lt,
+    multipleOf,
+    arrayMin,
+    arrayMax
+  } = rules;
+  const booleanRules = { required, url, uuid, ip, ipv4, ipv6, alpha, alphaNum, alphaDash, numeric, lowercase, uppercase };
+  for (const [name, value] of Object.entries(booleanRules)) {
+    if (value !== void 0 && typeof value !== "boolean") {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has invalid rules.${name} value`,
+          buildLocation7(filePath),
+          `rules.${name} must be a boolean (true or false)`
+        )
+      );
+    }
+  }
+  if (minLength !== void 0 && isRuleCompatibleWithType("minLength", propertyType)) {
+    if (typeof minLength !== "number" || minLength < 0 || !Number.isInteger(minLength)) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has invalid rules.minLength '${minLength}'`,
+          buildLocation7(filePath),
+          "rules.minLength must be a non-negative integer"
+        )
+      );
+    }
+  }
+  if (maxLength !== void 0 && isRuleCompatibleWithType("maxLength", propertyType)) {
+    if (typeof maxLength !== "number" || maxLength < 1 || !Number.isInteger(maxLength)) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has invalid rules.maxLength '${maxLength}'`,
+          buildLocation7(filePath),
+          "rules.maxLength must be a positive integer"
+        )
+      );
+    } else {
+      const dbLength = property.length;
+      if (dbLength !== void 0 && typeof dbLength === "number" && maxLength > dbLength) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' has rules.maxLength (${maxLength}) greater than length (${dbLength})`,
+            buildLocation7(filePath),
+            "rules.maxLength must be <= length (database column size)"
+          )
+        );
+      }
+    }
+  }
+  if (typeof minLength === "number" && typeof maxLength === "number" && minLength > maxLength) {
     errors.push(
       validationError(
-        `Property '${propertyName}' has invalid rules.required value`,
+        `Property '${propertyName}' has rules.minLength (${minLength}) > rules.maxLength (${maxLength})`,
         buildLocation7(filePath),
-        "rules.required must be a boolean (true or false)"
+        "rules.minLength must be <= rules.maxLength"
       )
     );
   }
-  const propertyType = property.type;
-  const allowsLengthRules = STRING_TYPES_WITH_LENGTH_RULES.includes(
-    propertyType
-  );
-  if (minLength !== void 0 && !allowsLengthRules) {
+  if (digits !== void 0) {
+    if (typeof digits !== "number" || digits < 1 || !Number.isInteger(digits)) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has invalid rules.digits '${digits}'`,
+          buildLocation7(filePath),
+          "rules.digits must be a positive integer"
+        )
+      );
+    }
+  }
+  if (digitsBetween !== void 0) {
+    if (!Array.isArray(digitsBetween) || digitsBetween.length !== 2 || typeof digitsBetween[0] !== "number" || typeof digitsBetween[1] !== "number") {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has invalid rules.digitsBetween`,
+          buildLocation7(filePath),
+          "rules.digitsBetween must be [min, max] tuple of numbers"
+        )
+      );
+    } else if (digitsBetween[0] > digitsBetween[1]) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has rules.digitsBetween[0] (${digitsBetween[0]}) > [1] (${digitsBetween[1]})`,
+          buildLocation7(filePath),
+          "First value must be <= second value"
+        )
+      );
+    }
+  }
+  if (startsWith !== void 0) {
+    if (typeof startsWith !== "string" && (!Array.isArray(startsWith) || !startsWith.every((s) => typeof s === "string"))) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has invalid rules.startsWith`,
+          buildLocation7(filePath),
+          "rules.startsWith must be a string or array of strings"
+        )
+      );
+    }
+  }
+  if (endsWith !== void 0) {
+    if (typeof endsWith !== "string" && (!Array.isArray(endsWith) || !endsWith.every((s) => typeof s === "string"))) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has invalid rules.endsWith`,
+          buildLocation7(filePath),
+          "rules.endsWith must be a string or array of strings"
+        )
+      );
+    }
+  }
+  const numericSingleRules = { min, max, gt, lt, multipleOf };
+  for (const [name, value] of Object.entries(numericSingleRules)) {
+    if (value !== void 0 && isRuleCompatibleWithType(name, propertyType)) {
+      if (typeof value !== "number") {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' has invalid rules.${name} '${value}'`,
+            buildLocation7(filePath),
+            `rules.${name} must be a number`
+          )
+        );
+      }
+    }
+  }
+  if (between !== void 0 && isRuleCompatibleWithType("between", propertyType)) {
+    if (!Array.isArray(between) || between.length !== 2 || typeof between[0] !== "number" || typeof between[1] !== "number") {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has invalid rules.between`,
+          buildLocation7(filePath),
+          "rules.between must be [min, max] tuple of numbers"
+        )
+      );
+    } else if (between[0] > between[1]) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has rules.between[0] (${between[0]}) > [1] (${between[1]})`,
+          buildLocation7(filePath),
+          "First value must be <= second value"
+        )
+      );
+    }
+  }
+  if (typeof min === "number" && typeof max === "number" && min > max) {
     errors.push(
       validationError(
-        `Property '${propertyName}' of type '${propertyType}' cannot use rules.minLength`,
+        `Property '${propertyName}' has rules.min (${min}) > rules.max (${max})`,
         buildLocation7(filePath),
-        `rules.minLength is only valid for types: ${STRING_TYPES_WITH_LENGTH_RULES.join(", ")}`
+        "rules.min must be <= rules.max"
       )
     );
   }
-  if (maxLength !== void 0 && !allowsLengthRules) {
+  if (typeof multipleOf === "number" && multipleOf <= 0) {
     errors.push(
       validationError(
-        `Property '${propertyName}' of type '${propertyType}' cannot use rules.maxLength`,
+        `Property '${propertyName}' has invalid rules.multipleOf '${multipleOf}'`,
         buildLocation7(filePath),
-        `rules.maxLength is only valid for types: ${STRING_TYPES_WITH_LENGTH_RULES.join(", ")}`
+        "rules.multipleOf must be a positive number"
       )
     );
   }
-  if (minLength !== void 0 && allowsLengthRules) {
-    if (typeof minLength !== "number" || minLength < 0 || minLength > 65535) {
+  if (arrayMin !== void 0) {
+    if (typeof arrayMin !== "number" || arrayMin < 0 || !Number.isInteger(arrayMin)) {
       errors.push(
         validationError(
-          `Property '${propertyName}' has invalid rules.minLength '${minLength}'`,
+          `Property '${propertyName}' has invalid rules.arrayMin '${arrayMin}'`,
           buildLocation7(filePath),
-          "rules.minLength must be a non-negative number between 0 and 65535"
+          "rules.arrayMin must be a non-negative integer"
         )
       );
     }
   }
-  if (maxLength !== void 0 && allowsLengthRules) {
-    if (typeof maxLength !== "number" || maxLength < 1 || maxLength > 65535) {
+  if (arrayMax !== void 0) {
+    if (typeof arrayMax !== "number" || arrayMax < 1 || !Number.isInteger(arrayMax)) {
       errors.push(
         validationError(
-          `Property '${propertyName}' has invalid rules.maxLength '${maxLength}'`,
+          `Property '${propertyName}' has invalid rules.arrayMax '${arrayMax}'`,
           buildLocation7(filePath),
-          "rules.maxLength must be a positive number between 1 and 65535"
+          "rules.arrayMax must be a positive integer"
         )
       );
-    } else {
-      const dbLength = property.length;
-      if (dbLength !== void 0 && typeof dbLength === "number" && maxLength > dbLength) {
-        errors.push(
-          validationError(
-            `Property '${propertyName}' has rules.maxLength (${maxLength}) greater than length (${dbLength})`,
-            buildLocation7(filePath),
-            "rules.maxLength must be less than or equal to length (database column size)"
-          )
-        );
-      }
     }
   }
-  if (minLength !== void 0 && maxLength !== void 0 && typeof minLength === "number" && typeof maxLength === "number" && minLength > maxLength) {
+  if (typeof arrayMin === "number" && typeof arrayMax === "number" && arrayMin > arrayMax) {
     errors.push(
       validationError(
-        `Property '${propertyName}' has rules.minLength (${minLength}) greater than rules.maxLength (${maxLength})`,
+        `Property '${propertyName}' has rules.arrayMin (${arrayMin}) > rules.arrayMax (${arrayMax})`,
         buildLocation7(filePath),
-        "rules.minLength must be less than or equal to rules.maxLength"
+        "rules.arrayMin must be <= rules.arrayMax"
       )
     );
   }