@famgia/omnify-core 0.0.6 → 0.0.7

package/dist/index.cjs

@@ -810,29 +810,544 @@ async function loadSchemas(directoryPath, options = {}) {
   return schemas;
 }
 
-// src/validation/validator.ts
-var BUILT_IN_TYPES = [
-  "String",
-  "Int",
-  "BigInt",
-  "Float",
-  "Boolean",
-  "Text",
-  "LongText",
-  "Date",
-  "Time",
-  "Timestamp",
-  "Json",
-  "Email",
-  "Password",
-  "File",
-  "MultiFile",
-  "Enum",
-  "Select",
-  "Lookup",
-  "Association",
-  "Polymorphic"
+// src/validation/types/base.ts
+var BASE_PROPERTY_FIELDS = [
+  "type",
+  "displayName",
+  "nullable",
+  "default",
+  "unique",
+  "description",
+  "renamedFrom"
+];
+function createValidFields(additionalFields) {
+  return [...BASE_PROPERTY_FIELDS, ...additionalFields];
+}
+function fullDbCompatibility() {
+  return {
+    mysql: "full",
+    postgres: "full",
+    sqlite: "full",
+    sqlserver: "full"
+  };
+}
+
+// src/validation/types/registry.ts
+var TypeRegistry = class {
+  types = /* @__PURE__ */ new Map();
+  /**
+   * Register a type definition.
+   */
+  register(type) {
+    if (this.types.has(type.name)) {
+      throw new Error(`Type '${type.name}' is already registered`);
+    }
+    this.types.set(type.name, type);
+  }
+  /**
+   * Register multiple type definitions.
+   */
+  registerAll(types) {
+    for (const type of types) {
+      this.register(type);
+    }
+  }
+  /**
+   * Get a type definition by name.
+   */
+  get(name) {
+    return this.types.get(name);
+  }
+  /**
+   * Check if a type is registered.
+   */
+  has(name) {
+    return this.types.has(name);
+  }
+  /**
+   * Get valid fields for a type.
+   * Returns base fields if type not found.
+   */
+  getValidFields(name) {
+    const type = this.types.get(name);
+    return type?.validFields ?? BASE_PROPERTY_FIELDS;
+  }
+  /**
+   * Get database compatibility for a type.
+   * Returns 'full' if type not found (custom types assumed compatible).
+   */
+  getDbCompatibility(name, driver) {
+    const type = this.types.get(name);
+    return type?.dbCompatibility[driver] ?? "full";
+  }
+  /**
+   * Get default values for a type.
+   */
+  getDefaults(name) {
+    return this.types.get(name)?.defaults;
+  }
+  /**
+   * Validate a property using its type's validator.
+   * Returns empty array if type not found (validation handled elsewhere).
+   */
+  validateProperty(propertyName, property, filePath) {
+    const type = this.types.get(property.type);
+    if (!type) {
+      return [];
+    }
+    return type.validate(propertyName, property, filePath);
+  }
+  /**
+   * Get all registered type names.
+   */
+  getAllTypeNames() {
+    return [...this.types.keys()];
+  }
+  /**
+   * Get count of registered types.
+   */
+  get size() {
+    return this.types.size;
+  }
+  /**
+   * Clear all registered types.
+   * Useful for testing.
+   */
+  clear() {
+    this.types.clear();
+  }
+};
+var typeRegistry = new TypeRegistry();
+
+// src/validation/types/primitives.ts
+var BooleanType = {
+  name: "Boolean",
+  category: "primitive",
+  validFields: createValidFields([]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var primitiveTypes = [
+  BooleanType
+];
+
+// src/validation/types/text.ts
+function buildLocation2(file) {
+  return { file };
+}
+function validateLength(propertyName, property, filePath) {
+  const { length } = property;
+  if (length !== void 0) {
+    if (typeof length !== "number" || length < 1 || length > 65535) {
+      return [
+        validationError(
+          `Property '${propertyName}' has invalid length '${length}'`,
+          buildLocation2(filePath),
+          "length must be a positive number between 1 and 65535"
+        )
+      ];
+    }
+  }
+  return [];
+}
+var StringType = {
+  name: "String",
+  category: "text",
+  validFields: createValidFields(["length"]),
+  dbCompatibility: fullDbCompatibility(),
+  defaults: {
+    // Default length depends on database, handled by generator
+  },
+  validate(propertyName, property, filePath) {
+    return validateLength(propertyName, property, filePath);
+  }
+};
+var TextType = {
+  name: "Text",
+  category: "text",
+  validFields: createValidFields([]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var LongTextType = {
+  name: "LongText",
+  category: "text",
+  validFields: createValidFields([]),
+  dbCompatibility: {
+    mysql: "full",
+    postgres: "full",
+    sqlite: "full",
+    sqlserver: "limited"
+    // Uses NVARCHAR(MAX)
+  },
+  validate() {
+    return [];
+  }
+};
+var EmailType = {
+  name: "Email",
+  category: "text",
+  validFields: createValidFields(["length"]),
+  dbCompatibility: fullDbCompatibility(),
+  validate(propertyName, property, filePath) {
+    return validateLength(propertyName, property, filePath);
+  }
+};
+var PasswordType = {
+  name: "Password",
+  category: "text",
+  validFields: createValidFields(["length"]),
+  dbCompatibility: fullDbCompatibility(),
+  validate(propertyName, property, filePath) {
+    return validateLength(propertyName, property, filePath);
+  }
+};
+var textTypes = [
+  StringType,
+  TextType,
+  LongTextType,
+  EmailType,
+  PasswordType
+];
+
+// src/validation/types/numeric.ts
+function buildLocation3(file) {
+  return { file };
+}
+var IntType = {
+  name: "Int",
+  category: "numeric",
+  validFields: createValidFields(["unsigned"]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var BigIntType = {
+  name: "BigInt",
+  category: "numeric",
+  validFields: createValidFields(["unsigned"]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var FloatType = {
+  name: "Float",
+  category: "numeric",
+  validFields: createValidFields(["unsigned"]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var DecimalType = {
+  name: "Decimal",
+  category: "numeric",
+  validFields: createValidFields(["precision", "scale", "unsigned"]),
+  dbCompatibility: {
+    mysql: "full",
+    postgres: "full",
+    sqlite: "limited",
+    // Stored as REAL, loses precision
+    sqlserver: "full"
+  },
+  defaults: {
+    // precision: 8, scale: 2 - handled by generator
+  },
+  validate(propertyName, property, filePath) {
+    const errors = [];
+    const { precision, scale } = property;
+    if (precision !== void 0) {
+      if (typeof precision !== "number" || precision < 1 || precision > 65) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' has invalid precision '${precision}'`,
+            buildLocation3(filePath),
+            "precision must be a number between 1 and 65"
+          )
+        );
+      }
+    }
+    if (scale !== void 0) {
+      if (typeof scale !== "number" || scale < 0 || scale > 30) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' has invalid scale '${scale}'`,
+            buildLocation3(filePath),
+            "scale must be a number between 0 and 30"
+          )
+        );
+      }
+      const effectivePrecision = typeof precision === "number" ? precision : 8;
+      if (typeof scale === "number" && scale > effectivePrecision) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' has scale (${scale}) greater than precision (${effectivePrecision})`,
+            buildLocation3(filePath),
+            "scale cannot be greater than precision"
+          )
+        );
+      }
+    }
+    return errors;
+  }
+};
+var numericTypes = [
+  IntType,
+  BigIntType,
+  FloatType,
+  DecimalType
+];
+
+// src/validation/types/temporal.ts
+var DateType = {
+  name: "Date",
+  category: "temporal",
+  validFields: createValidFields([]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var TimeType = {
+  name: "Time",
+  category: "temporal",
+  validFields: createValidFields([]),
+  dbCompatibility: {
+    mysql: "full",
+    postgres: "full",
+    sqlite: "limited",
+    // Stored as TEXT
+    sqlserver: "full"
+  },
+  validate() {
+    return [];
+  }
+};
+var DateTimeType = {
+  name: "DateTime",
+  category: "temporal",
+  validFields: createValidFields([]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var TimestampType = {
+  name: "Timestamp",
+  category: "temporal",
+  validFields: createValidFields([]),
+  dbCompatibility: {
+    mysql: "full",
+    postgres: "full",
+    sqlite: "limited",
+    // Stored as INTEGER or TEXT
+    sqlserver: "full"
+  },
+  validate() {
+    return [];
+  }
+};
+var temporalTypes = [
+  DateType,
+  TimeType,
+  DateTimeType,
+  TimestampType
+];
+
+// src/validation/types/special.ts
+var JsonType = {
+  name: "Json",
+  category: "special",
+  validFields: createValidFields([]),
+  dbCompatibility: {
+    mysql: "full",
+    // Native JSON type
+    postgres: "full",
+    // Native JSONB type
+    sqlite: "limited",
+    // Stored as TEXT
+    sqlserver: "limited"
+    // Stored as NVARCHAR(MAX)
+  },
+  validate() {
+    return [];
+  }
+};
+var UuidType = {
+  name: "Uuid",
+  category: "special",
+  validFields: createValidFields([]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var FileType = {
+  name: "File",
+  category: "special",
+  validFields: createValidFields([]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var MultiFileType = {
+  name: "MultiFile",
+  category: "special",
+  validFields: createValidFields([]),
+  dbCompatibility: fullDbCompatibility(),
+  validate() {
+    return [];
+  }
+};
+var specialTypes = [
+  JsonType,
+  UuidType,
+  FileType,
+  MultiFileType
+];
+
+// src/validation/types/enum.ts
+function buildLocation4(file) {
+  return { file };
+}
+var EnumType = {
+  name: "Enum",
+  category: "enum",
+  validFields: createValidFields(["enum"]),
+  requiredFields: ["enum"],
+  dbCompatibility: fullDbCompatibility(),
+  validate(propertyName, property, filePath) {
+    const errors = [];
+    const { enum: enumValues } = property;
+    if (enumValues === void 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type 'Enum' requires 'enum' field`,
+          buildLocation4(filePath),
+          "Add enum values: enum: [value1, value2]"
+        )
+      );
+    } else if (!Array.isArray(enumValues)) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' enum field must be an array`,
+          buildLocation4(filePath),
+          "enum: [value1, value2]"
+        )
+      );
+    } else if (enumValues.length === 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' enum field cannot be empty`,
+          buildLocation4(filePath),
+          "Add at least one enum value"
+        )
+      );
+    } else {
+      const seen = /* @__PURE__ */ new Set();
+      for (const value of enumValues) {
+        if (typeof value !== "string") {
+          errors.push(
+            validationError(
+              `Property '${propertyName}' enum values must be strings, got ${typeof value}`,
+              buildLocation4(filePath)
+            )
+          );
+        } else if (seen.has(value)) {
+          errors.push(
+            validationError(
+              `Property '${propertyName}' has duplicate enum value '${value}'`,
+              buildLocation4(filePath)
+            )
+          );
+        } else {
+          seen.add(value);
+        }
+      }
+    }
+    return errors;
+  }
+};
+var SelectType = {
+  name: "Select",
+  category: "enum",
+  validFields: createValidFields(["options", "source"]),
+  dbCompatibility: fullDbCompatibility(),
+  validate(propertyName, property, filePath) {
+    const errors = [];
+    const { options, source } = property;
+    if (options === void 0 && source === void 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type 'Select' requires 'options' or 'source' field`,
+          buildLocation4(filePath),
+          "Add options: [value1, value2] or source: SchemaName"
+        )
+      );
+    }
+    if (options !== void 0 && !Array.isArray(options)) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' options field must be an array`,
+          buildLocation4(filePath)
+        )
+      );
+    }
+    if (source !== void 0 && typeof source !== "string") {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' source field must be a string`,
+          buildLocation4(filePath)
+        )
+      );
+    }
+    return errors;
+  }
+};
+var LookupType = {
+  name: "Lookup",
+  category: "enum",
+  validFields: createValidFields(["options", "source"]),
+  dbCompatibility: fullDbCompatibility(),
+  validate(propertyName, property, filePath) {
+    const errors = [];
+    const { source } = property;
+    if (source === void 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type 'Lookup' requires 'source' field`,
+          buildLocation4(filePath),
+          "Add source: SchemaName"
+        )
+      );
+    } else if (typeof source !== "string") {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' source field must be a string`,
+          buildLocation4(filePath)
+        )
+      );
+    }
+    return errors;
+  }
+};
+var enumTypes = [
+  EnumType,
+  SelectType,
+  LookupType
 ];
+
+// src/validation/types/relations.ts
+function buildLocation5(file) {
+  return { file };
+}
 var VALID_RELATIONS = [
   "OneToOne",
   "OneToMany",
@@ -846,8 +1361,150 @@ var VALID_REFERENTIAL_ACTIONS = [
   "RESTRICT",
   "NO ACTION"
 ];
+var ASSOCIATION_FIELDS = [
+  "relation",
+  "target",
+  "inversedBy",
+  "mappedBy",
+  "onDelete",
+  "onUpdate",
+  "owning",
+  "joinTable"
+];
+var AssociationType = {
+  name: "Association",
+  category: "relation",
+  validFields: createValidFields(ASSOCIATION_FIELDS),
+  requiredFields: ["relation", "target"],
+  dbCompatibility: fullDbCompatibility(),
+  validate(propertyName, property, filePath) {
+    const errors = [];
+    const {
+      relation,
+      target,
+      onDelete,
+      onUpdate
+    } = property;
+    if (relation === void 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type 'Association' requires 'relation' field`,
+          buildLocation5(filePath),
+          "Add relation: OneToOne, OneToMany, ManyToOne, or ManyToMany"
+        )
+      );
+    } else if (typeof relation !== "string") {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' relation field must be a string`,
+          buildLocation5(filePath)
+        )
+      );
+    } else if (!VALID_RELATIONS.includes(relation)) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' has invalid relation '${relation}'`,
+          buildLocation5(filePath),
+          `Use one of: ${VALID_RELATIONS.join(", ")}`
+        )
+      );
+    }
+    if (target === void 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type 'Association' requires 'target' field`,
+          buildLocation5(filePath),
+          "Add target schema name: target: User"
+        )
+      );
+    } else if (typeof target !== "string") {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' target field must be a string`,
+          buildLocation5(filePath)
+        )
+      );
+    }
+    if (onDelete !== void 0 && typeof onDelete === "string") {
+      if (!VALID_REFERENTIAL_ACTIONS.includes(onDelete)) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' has invalid onDelete action '${onDelete}'`,
+            buildLocation5(filePath),
+            `Use one of: ${VALID_REFERENTIAL_ACTIONS.join(", ")}`
+          )
+        );
+      }
+    }
+    if (onUpdate !== void 0 && typeof onUpdate === "string") {
+      if (!VALID_REFERENTIAL_ACTIONS.includes(onUpdate)) {
+        errors.push(
+          validationError(
+            `Property '${propertyName}' has invalid onUpdate action '${onUpdate}'`,
+            buildLocation5(filePath),
+            `Use one of: ${VALID_REFERENTIAL_ACTIONS.join(", ")}`
+          )
+        );
+      }
+    }
+    return errors;
+  }
+};
+var PolymorphicType = {
+  name: "Polymorphic",
+  category: "relation",
+  validFields: createValidFields(ASSOCIATION_FIELDS),
+  dbCompatibility: fullDbCompatibility(),
+  validate(propertyName, property, filePath) {
+    const errors = [];
+    const { relation, target } = property;
+    if (relation === void 0) {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' of type 'Polymorphic' requires 'relation' field`,
+          buildLocation5(filePath),
+          "Add relation type"
+        )
+      );
+    }
+    if (target !== void 0 && typeof target !== "string") {
+      errors.push(
+        validationError(
+          `Property '${propertyName}' target field must be a string`,
+          buildLocation5(filePath)
+        )
+      );
+    }
+    return errors;
+  }
+};
+var relationTypes = [
+  AssociationType,
+  PolymorphicType
+];
+
+// src/validation/types/index.ts
+var allBuiltInTypes = [
+  ...primitiveTypes,
+  ...textTypes,
+  ...numericTypes,
+  ...temporalTypes,
+  ...specialTypes,
+  ...enumTypes,
+  ...relationTypes
+];
+function registerBuiltInTypes() {
+  for (const type of allBuiltInTypes) {
+    if (!typeRegistry.has(type.name)) {
+      typeRegistry.register(type);
+    }
+  }
+}
+registerBuiltInTypes();
+
+// src/validation/validator.ts
 var VALID_PRIMARY_KEY_TYPES = ["Int", "BigInt", "Uuid", "String"];
-function buildLocation2(file, line, column) {
+function buildLocation6(file, line, column) {
   const loc = { file };
   if (line !== void 0) {
     loc.line = line;
@@ -857,56 +1514,75 @@ function buildLocation2(file, line, column) {
   }
   return loc;
 }
+function validateDbCompatibility(propertyName, property, filePath, databaseDriver) {
+  const errors = [];
+  const warnings = [];
+  if (!databaseDriver || !property.type) {
+    return { errors, warnings };
+  }
+  const compatibility = typeRegistry.getDbCompatibility(property.type, databaseDriver);
+  if (compatibility === "unsupported") {
+    errors.push(
+      validationError(
+        `Property '${propertyName}' uses type '${property.type}' which is not supported in ${databaseDriver}`,
+        buildLocation6(filePath),
+        `Consider using a different type or database driver`
+      )
+    );
+  } else if (compatibility === "limited") {
+    warnings.push(
+      validationError(
+        `Property '${propertyName}' uses type '${property.type}' which has limited support in ${databaseDriver}`,
+        buildLocation6(filePath),
+        `The type will work but may have precision or feature limitations`
+      )
+    );
+  }
+  return { errors, warnings };
+}
+function validateUnknownFields(propertyName, property, filePath) {
+  const warnings = [];
+  if (!property.type) {
+    return warnings;
+  }
+  const validFields = typeRegistry.getValidFields(property.type);
+  const propertyFields = Object.keys(property);
+  for (const field of propertyFields) {
+    if (!validFields.includes(field)) {
+      warnings.push(
+        validationError(
+          `Property '${propertyName}' has unknown field '${field}'`,
+          buildLocation6(filePath),
+          `Valid fields for type '${property.type}': ${validFields.join(", ")}`
+        )
+      );
+    }
+  }
+  return warnings;
+}
 function validatePropertyType(propertyName, property, filePath, customTypes = []) {
   const errors = [];
-  const validTypes = [...BUILT_IN_TYPES, ...customTypes];
   if (!property.type) {
     errors.push(
-      missingFieldError("type", buildLocation2(filePath))
+      missingFieldError("type", buildLocation6(filePath))
     );
     return errors;
   }
-  if (!validTypes.includes(property.type)) {
+  const isBuiltIn = typeRegistry.has(property.type);
+  const isCustom = customTypes.includes(property.type);
+  if (!isBuiltIn && !isCustom) {
     errors.push(
       invalidPropertyTypeError(
         property.type,
-        buildLocation2(filePath),
-        BUILT_IN_TYPES
+        buildLocation6(filePath),
+        typeRegistry.getAllTypeNames()
       )
     );
+    return errors;
   }
-  if (property.type === "Enum") {
-    const enumProp = property;
-    if (enumProp.enum === void 0) {
-      errors.push(
-        validationError(
-          `Property '${propertyName}' of type 'Enum' requires 'enum' field`,
-          buildLocation2(filePath),
-          "Add enum values: enum: [value1, value2]"
-        )
-      );
-    }
-  }
-  if (property.type === "Association") {
-    const assocProp = property;
-    if (assocProp.relation === void 0) {
-      errors.push(
-        validationError(
-          `Property '${propertyName}' of type 'Association' requires 'relation' field`,
-          buildLocation2(filePath),
-          "Add relation: OneToOne, OneToMany, ManyToOne, or ManyToMany"
-        )
-      );
-    }
-    if (assocProp.target === void 0) {
-      errors.push(
-        validationError(
-          `Property '${propertyName}' of type 'Association' requires 'target' field`,
-          buildLocation2(filePath),
-          "Add target schema name: target: User"
-        )
-      );
-    }
+  if (isBuiltIn) {
+    const typeErrors = typeRegistry.validateProperty(propertyName, property, filePath);
+    errors.push(...typeErrors);
   }
   return errors;
 }
@@ -938,7 +1614,7 @@ function validateAssociations(schema, allSchemas) {
       errors.push(
         validationError(
           `Property '${name}' has invalid relation '${assocProp.relation}'`,
-          buildLocation2(schema.filePath),
+          buildLocation6(schema.filePath),
           `Use one of: ${VALID_RELATIONS.join(", ")}`
         )
       );
@@ -947,7 +1623,7 @@ function validateAssociations(schema, allSchemas) {
       errors.push(
         invalidAssociationTargetError(
           assocProp.target,
-          buildLocation2(schema.filePath),
+          buildLocation6(schema.filePath),
           availableSchemas
         )
       );
@@ -960,7 +1636,7 @@ function validateAssociations(schema, allSchemas) {
           errors.push(
             validationError(
               `Property '${name}' references non-existent inverse property '${assocProp.inversedBy}' on '${assocProp.target}'`,
-              buildLocation2(schema.filePath),
+              buildLocation6(schema.filePath),
               `Add property '${assocProp.inversedBy}' to ${assocProp.target} schema`
             )
           );
@@ -971,7 +1647,7 @@ function validateAssociations(schema, allSchemas) {
       errors.push(
         validationError(
           `Property '${name}' has invalid onDelete action '${assocProp.onDelete}'`,
-          buildLocation2(schema.filePath),
+          buildLocation6(schema.filePath),
           `Use one of: ${VALID_REFERENTIAL_ACTIONS.join(", ")}`
         )
       );
@@ -980,7 +1656,7 @@ function validateAssociations(schema, allSchemas) {
       errors.push(
         validationError(
           `Property '${name}' has invalid onUpdate action '${assocProp.onUpdate}'`,
-          buildLocation2(schema.filePath),
+          buildLocation6(schema.filePath),
           `Use one of: ${VALID_REFERENTIAL_ACTIONS.join(", ")}`
         )
       );
@@ -999,7 +1675,7 @@ function validateOptions(schema, filePath) {
       errors.push(
         validationError(
           `Invalid primaryKeyType '${options.primaryKeyType}'`,
-          buildLocation2(filePath),
+          buildLocation6(filePath),
           `Use one of: ${VALID_PRIMARY_KEY_TYPES.join(", ")}`
         )
       );
@@ -1014,7 +1690,7 @@ function validateOptions(schema, filePath) {
           errors.push(
             validationError(
               `Unique constraint references non-existent property '${column}'`,
-              buildLocation2(filePath),
+              buildLocation6(filePath),
               `Available properties: ${propertyNames.join(", ")}`
             )
           );
@@ -1030,7 +1706,7 @@ function validateOptions(schema, filePath) {
           errors.push(
             validationError(
               `Index references non-existent property '${column}'`,
-              buildLocation2(filePath),
+              buildLocation6(filePath),
               `Available properties: ${propertyNames.join(", ")}`
             )
           );
@@ -1044,7 +1720,7 @@ function validateOptions(schema, filePath) {
         errors.push(
           validationError(
             `authenticatableLoginIdField references non-existent property '${options.authenticatableLoginIdField}'`,
-            buildLocation2(filePath)
+            buildLocation6(filePath)
           )
         );
       }
@@ -1054,7 +1730,7 @@ function validateOptions(schema, filePath) {
         errors.push(
           validationError(
             `authenticatablePasswordField references non-existent property '${options.authenticatablePasswordField}'`,
-            buildLocation2(filePath)
+            buildLocation6(filePath)
           )
         );
       }
@@ -1071,7 +1747,7 @@ function validateEnumSchema(schema, filePath) {
     errors.push(
       validationError(
         "Enum schema requires at least one value",
-        buildLocation2(filePath),
+        buildLocation6(filePath),
         "Add values: [value1, value2, ...]"
       )
     );
@@ -1083,7 +1759,7 @@ function validateEnumSchema(schema, filePath) {
         errors.push(
           validationError(
             `Duplicate enum value '${value}'`,
-            buildLocation2(filePath)
+            buildLocation6(filePath)
           )
         );
       }
@@ -1109,12 +1785,21 @@ function validateSchema(schema, options = {}) {
       errors.push(
         validationError(
           `titleIndex references non-existent property '${schema.titleIndex}'`,
-          buildLocation2(schema.filePath),
+          buildLocation6(schema.filePath),
           `Available properties: ${Object.keys(schema.properties).join(", ")}`
         )
       );
     }
   }
+  if (schema.properties) {
+    for (const [name, property] of Object.entries(schema.properties)) {
+      const unknownFieldWarnings = validateUnknownFields(name, property, schema.filePath);
+      warnings.push(...unknownFieldWarnings);
+      const dbCompat = validateDbCompatibility(name, property, schema.filePath, options.databaseDriver);
+      errors.push(...dbCompat.errors);
+      warnings.push(...dbCompat.warnings);
+    }
+  }
   return {
     schemaName: schema.name,
     valid: errors.length === 0,