@vibeorm/parser 1.0.0

package/src/schema-validator.ts

@@ -0,0 +1,625 @@
+/**
+ * Schema IR Validator
+ *
+ * Performs semantic validation on the parsed Schema IR,
+ * catching issues that the structural TypeScript types cannot express:
+ * missing primary keys, dangling relation references, FK type mismatches, etc.
+ */
+
+import type {
+  Schema,
+  Model,
+  Field,
+  ScalarField,
+  EnumField,
+  RelationField,
+} from "./types.ts";
+import { PRISMA_TO_TS, PRISMA_TO_PG } from "./types.ts";
+
+// ─── Validation Result Types ──────────────────────────────────────
+
+export type ValidationSeverity = "error" | "warning";
+
+export type SchemaValidationError = {
+  severity: ValidationSeverity;
+  path: string;
+  code: string;
+  message: string;
+};
+
+export type ValidationResult =
+  | { valid: true; warnings: SchemaValidationError[] }
+  | { valid: false; errors: SchemaValidationError[]; warnings: SchemaValidationError[] };
+
+const VALID_PRISMA_TYPES = new Set<string>([
+  "String", "Boolean", "Int", "BigInt", "Float", "Decimal", "DateTime", "Json", "Bytes",
+]);
+
+// ─── Public API ───────────────────────────────────────────────────
+
+export function validateSchema(params: { schema: Schema }): ValidationResult {
+  const { schema } = params;
+  const errors: SchemaValidationError[] = [];
+  const warnings: SchemaValidationError[] = [];
+
+  const modelNames = new Set(schema.models.map((m) => m.name));
+  const enumNames = new Set(schema.enums.map((e) => e.name));
+
+  // Build lookup maps
+  const modelMap = new Map<string, Model>();
+  for (const model of schema.models) {
+    modelMap.set(model.name, model);
+  }
+
+  // ── Schema-level checks ──
+  validateSchemaLevel({ schema, modelNames, enumNames, errors, warnings });
+
+  // ── Enum-level checks ──
+  for (const enumDef of schema.enums) {
+    validateEnum({ enumDef, path: `enums.${enumDef.name}`, errors, warnings });
+  }
+
+  // ── Model-level checks ──
+  for (const model of schema.models) {
+    validateModel({
+      model,
+      modelNames,
+      enumNames,
+      modelMap,
+      errors,
+      warnings,
+    });
+  }
+
+  if (errors.length > 0) {
+    return { valid: false, errors, warnings };
+  }
+  return { valid: true, warnings };
+}
+
+// ─── Schema-Level Validation ──────────────────────────────────────
+
+function validateSchemaLevel(params: {
+  schema: Schema;
+  modelNames: Set<string>;
+  enumNames: Set<string>;
+  errors: SchemaValidationError[];
+  warnings: SchemaValidationError[];
+}): void {
+  const { schema, modelNames, enumNames, errors } = params;
+
+  // Check for duplicate model names
+  const seenModels = new Set<string>();
+  for (const model of schema.models) {
+    if (seenModels.has(model.name)) {
+      errors.push({
+        severity: "error",
+        path: `models.${model.name}`,
+        code: "DUPLICATE_MODEL_NAME",
+        message: `Duplicate model name "${model.name}"`,
+      });
+    }
+    seenModels.add(model.name);
+  }
+
+  // Check for duplicate enum names
+  const seenEnums = new Set<string>();
+  for (const enumDef of schema.enums) {
+    if (seenEnums.has(enumDef.name)) {
+      errors.push({
+        severity: "error",
+        path: `enums.${enumDef.name}`,
+        code: "DUPLICATE_ENUM_NAME",
+        message: `Duplicate enum name "${enumDef.name}"`,
+      });
+    }
+    seenEnums.add(enumDef.name);
+  }
+
+  // Check for model/enum name collisions
+  for (const name of modelNames) {
+    if (enumNames.has(name)) {
+      errors.push({
+        severity: "error",
+        path: `schema`,
+        code: "MODEL_ENUM_NAME_COLLISION",
+        message: `Model and enum share the same name "${name}"`,
+      });
+    }
+  }
+}
+
+// ─── Enum Validation ──────────────────────────────────────────────
+
+function validateEnum(params: {
+  enumDef: Schema["enums"][number];
+  path: string;
+  errors: SchemaValidationError[];
+  warnings: SchemaValidationError[];
+}): void {
+  const { enumDef, path, errors } = params;
+
+  if (enumDef.values.length === 0) {
+    errors.push({
+      severity: "error",
+      path,
+      code: "EMPTY_ENUM",
+      message: `Enum "${enumDef.name}" has no values`,
+    });
+  }
+
+  // Check for duplicate enum value names
+  const seenValues = new Set<string>();
+  for (const value of enumDef.values) {
+    if (seenValues.has(value.name)) {
+      errors.push({
+        severity: "error",
+        path: `${path}.${value.name}`,
+        code: "DUPLICATE_ENUM_VALUE",
+        message: `Duplicate enum value "${value.name}" in enum "${enumDef.name}"`,
+      });
+    }
+    seenValues.add(value.name);
+  }
+}
+
+// ─── Model Validation ─────────────────────────────────────────────
+
+function validateModel(params: {
+  model: Model;
+  modelNames: Set<string>;
+  enumNames: Set<string>;
+  modelMap: Map<string, Model>;
+  errors: SchemaValidationError[];
+  warnings: SchemaValidationError[];
+}): void {
+  const { model, modelNames, enumNames, modelMap, errors, warnings } = params;
+  const modelPath = `models.${model.name}`;
+
+  // Build field lookup for this model
+  const fieldMap = new Map<string, Field>();
+  const scalarEnumFieldNames = new Set<string>();
+
+  // Check for duplicate field names
+  const seenFields = new Set<string>();
+  for (const field of model.fields) {
+    if (seenFields.has(field.name)) {
+      errors.push({
+        severity: "error",
+        path: `${modelPath}.fields.${field.name}`,
+        code: "DUPLICATE_FIELD_NAME",
+        message: `Duplicate field name "${field.name}" in model "${model.name}"`,
+      });
+    }
+    seenFields.add(field.name);
+    fieldMap.set(field.name, field);
+    if (field.kind === "scalar" || field.kind === "enum") {
+      scalarEnumFieldNames.add(field.name);
+    }
+  }
+
+  // Primary key validation
+  if (model.primaryKey.fields.length === 0) {
+    errors.push({
+      severity: "error",
+      path: `${modelPath}.primaryKey`,
+      code: "MISSING_PRIMARY_KEY",
+      message: `Model "${model.name}" has no primary key -- every model must have an @id or @@id`,
+    });
+  } else {
+    // isComposite consistency
+    const shouldBeComposite = model.primaryKey.fields.length > 1;
+    if (model.primaryKey.isComposite !== shouldBeComposite) {
+      warnings.push({
+        severity: "warning",
+        path: `${modelPath}.primaryKey`,
+        code: "INCONSISTENT_COMPOSITE_FLAG",
+        message: `Model "${model.name}" has isComposite=${model.primaryKey.isComposite} but ${model.primaryKey.fields.length} PK field(s)`,
+      });
+    }
+
+    // PK fields reference actual scalar/enum fields
+    for (const pkField of model.primaryKey.fields) {
+      if (!scalarEnumFieldNames.has(pkField)) {
+        errors.push({
+          severity: "error",
+          path: `${modelPath}.primaryKey`,
+          code: "PK_FIELD_NOT_FOUND",
+          message: `Primary key field "${pkField}" does not exist as a scalar/enum field on model "${model.name}"`,
+        });
+      }
+    }
+  }
+
+  // Unique constraint field references
+  for (const uc of model.uniqueConstraints) {
+    for (const ucField of uc.fields) {
+      if (!scalarEnumFieldNames.has(ucField)) {
+        errors.push({
+          severity: "error",
+          path: `${modelPath}.uniqueConstraints`,
+          code: "UNIQUE_FIELD_NOT_FOUND",
+          message: `Unique constraint references field "${ucField}" which does not exist on model "${model.name}"`,
+        });
+      }
+    }
+  }
+
+  // Index field references
+  for (const idx of model.indexes) {
+    for (const idxField of idx.fields) {
+      if (!scalarEnumFieldNames.has(idxField)) {
+        errors.push({
+          severity: "error",
+          path: `${modelPath}.indexes`,
+          code: "INDEX_FIELD_NOT_FOUND",
+          message: `Index references field "${idxField}" which does not exist on model "${model.name}"`,
+        });
+      }
+    }
+  }
+
+  // Per-field validation
+  for (const field of model.fields) {
+    const fieldPath = `${modelPath}.fields.${field.name}`;
+
+    switch (field.kind) {
+      case "scalar":
+        validateScalarField({
+          field,
+          model,
+          fieldPath,
+          errors,
+          warnings,
+        });
+        break;
+      case "enum":
+        validateEnumField({
+          field,
+          enumNames,
+          fieldPath,
+          errors,
+        });
+        break;
+      case "relation":
+        validateRelationField({
+          field,
+          model,
+          modelNames,
+          modelMap,
+          fieldPath,
+          errors,
+          warnings,
+        });
+        break;
+    }
+  }
+}
+
+// ─── Scalar Field Validation ──────────────────────────────────────
+
+function validateScalarField(params: {
+  field: ScalarField;
+  model: Model;
+  fieldPath: string;
+  errors: SchemaValidationError[];
+  warnings: SchemaValidationError[];
+}): void {
+  const { field, model, fieldPath, errors, warnings } = params;
+
+  // Valid Prisma type
+  if (!VALID_PRISMA_TYPES.has(field.prismaType)) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "INVALID_PRISMA_TYPE",
+      message: `Field "${field.name}" has invalid Prisma type "${field.prismaType}"`,
+    });
+  }
+
+  // tsType consistency (only when no nativeType override)
+  if (!field.nativeType) {
+    const expectedTs = PRISMA_TO_TS[field.prismaType];
+    if (expectedTs && field.tsType !== expectedTs) {
+      warnings.push({
+        severity: "warning",
+        path: fieldPath,
+        code: "TS_TYPE_MISMATCH",
+        message: `Field "${field.name}" has tsType "${field.tsType}" but expected "${expectedTs}" for Prisma type "${field.prismaType}"`,
+      });
+    }
+
+    const expectedPg = PRISMA_TO_PG[field.prismaType];
+    if (expectedPg && field.pgType !== expectedPg) {
+      warnings.push({
+        severity: "warning",
+        path: fieldPath,
+        code: "PG_TYPE_MISMATCH",
+        message: `Field "${field.name}" has pgType "${field.pgType}" but expected "${expectedPg}" for Prisma type "${field.prismaType}"`,
+      });
+    }
+  }
+
+  // @default(autoincrement()) only on Int/BigInt
+  if (field.default?.kind === "autoincrement") {
+    if (field.prismaType !== "Int" && field.prismaType !== "BigInt") {
+      errors.push({
+        severity: "error",
+        path: fieldPath,
+        code: "AUTOINCREMENT_WRONG_TYPE",
+        message: `Field "${field.name}" uses @default(autoincrement()) but has type "${field.prismaType}" (must be Int or BigInt)`,
+      });
+    }
+  }
+
+  // @updatedAt only on DateTime
+  if (field.isUpdatedAt && field.prismaType !== "DateTime") {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "UPDATED_AT_WRONG_TYPE",
+      message: `Field "${field.name}" uses @updatedAt but has type "${field.prismaType}" (must be DateTime)`,
+    });
+  }
+
+  // isId consistency with primaryKey
+  if (field.isId && !model.primaryKey.fields.includes(field.name)) {
+    warnings.push({
+      severity: "warning",
+      path: fieldPath,
+      code: "ID_NOT_IN_PK",
+      message: `Field "${field.name}" has isId=true but is not listed in model "${model.name}" primaryKey.fields`,
+    });
+  }
+
+  // dbName must be non-empty
+  if (!field.dbName) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "EMPTY_DB_NAME",
+      message: `Field "${field.name}" has an empty dbName`,
+    });
+  }
+}
+
+// ─── Enum Field Validation ────────────────────────────────────────
+
+function validateEnumField(params: {
+  field: EnumField;
+  enumNames: Set<string>;
+  fieldPath: string;
+  errors: SchemaValidationError[];
+}): void {
+  const { field, enumNames, fieldPath, errors } = params;
+
+  if (!enumNames.has(field.enumName)) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "ENUM_NOT_FOUND",
+      message: `Field "${field.name}" references enum "${field.enumName}" which does not exist`,
+    });
+  }
+
+  if (!field.dbName) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "EMPTY_DB_NAME",
+      message: `Field "${field.name}" has an empty dbName`,
+    });
+  }
+}
+
+// ─── Relation Field Validation ────────────────────────────────────
+
+function validateRelationField(params: {
+  field: RelationField;
+  model: Model;
+  modelNames: Set<string>;
+  modelMap: Map<string, Model>;
+  fieldPath: string;
+  errors: SchemaValidationError[];
+  warnings: SchemaValidationError[];
+}): void {
+  const { field, model, modelNames, modelMap, fieldPath, errors, warnings } = params;
+  const rel = field.relation;
+
+  // relatedModel exists
+  if (!modelNames.has(field.relatedModel)) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "RELATED_MODEL_NOT_FOUND",
+      message: `Field "${field.name}" references model "${field.relatedModel}" which does not exist`,
+    });
+    return; // Can't do further relation checks without the related model
+  }
+
+  // relatedModel consistency (two places store the same value)
+  if (field.relatedModel !== rel.relatedModel) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "RELATED_MODEL_MISMATCH",
+      message: `Field "${field.name}" has relatedModel="${field.relatedModel}" but relation.relatedModel="${rel.relatedModel}"`,
+    });
+  }
+
+  // isList / type consistency
+  if ((rel.type === "oneToMany" || rel.type === "manyToMany") && !field.isList) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "LIST_TYPE_MISMATCH",
+      message: `Field "${field.name}" has relation type "${rel.type}" but isList=false (should be true)`,
+    });
+  }
+  if ((rel.type === "manyToOne" || rel.type === "oneToOne") && field.isList) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "LIST_TYPE_MISMATCH",
+      message: `Field "${field.name}" has relation type "${rel.type}" but isList=true (should be false)`,
+    });
+  }
+
+  // isForeignKey / type consistency
+  if (rel.type === "manyToOne" && !rel.isForeignKey) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "FK_TYPE_MISMATCH",
+      message: `Field "${field.name}" has relation type "manyToOne" but isForeignKey=false (should be true)`,
+    });
+  }
+  if (rel.type === "oneToMany" && rel.isForeignKey) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "FK_TYPE_MISMATCH",
+      message: `Field "${field.name}" has relation type "oneToMany" but isForeignKey=true (should be false)`,
+    });
+  }
+  if (rel.type === "manyToMany" && rel.isForeignKey) {
+    errors.push({
+      severity: "error",
+      path: fieldPath,
+      code: "FK_TYPE_MISMATCH",
+      message: `Field "${field.name}" has relation type "manyToMany" but isForeignKey=true (should be false)`,
+    });
+  }
+
+  // FK fields/references validation
+  if (rel.isForeignKey) {
+    if (rel.fields.length === 0) {
+      errors.push({
+        severity: "error",
+        path: fieldPath,
+        code: "FK_FIELDS_EMPTY",
+        message: `Field "${field.name}" has isForeignKey=true but relation.fields is empty`,
+      });
+    }
+    if (rel.references.length === 0) {
+      errors.push({
+        severity: "error",
+        path: fieldPath,
+        code: "FK_REFERENCES_EMPTY",
+        message: `Field "${field.name}" has isForeignKey=true but relation.references is empty`,
+      });
+    }
+    if (rel.fields.length !== rel.references.length) {
+      errors.push({
+        severity: "error",
+        path: fieldPath,
+        code: "FK_FIELDS_REFERENCES_LENGTH_MISMATCH",
+        message: `Field "${field.name}" has ${rel.fields.length} FK field(s) but ${rel.references.length} reference(s)`,
+      });
+    }
+
+    // FK fields reference actual scalar/enum fields on THIS model
+    const thisScalarFields = new Set(
+      model.fields
+        .filter((f): f is ScalarField | EnumField => f.kind === "scalar" || f.kind === "enum")
+        .map((f) => f.name)
+    );
+
+    for (const fkField of rel.fields) {
+      if (!thisScalarFields.has(fkField)) {
+        errors.push({
+          severity: "error",
+          path: fieldPath,
+          code: "FK_FIELD_NOT_FOUND",
+          message: `Relation field "${field.name}" references FK field "${fkField}" which does not exist on model "${model.name}"`,
+        });
+      }
+    }
+
+    // References point to actual fields on the RELATED model
+    const relatedModel = modelMap.get(field.relatedModel);
+    if (relatedModel) {
+      const relatedScalarFields = new Set(
+        relatedModel.fields
+          .filter((f): f is ScalarField | EnumField => f.kind === "scalar" || f.kind === "enum")
+          .map((f) => f.name)
+      );
+
+      for (const refField of rel.references) {
+        if (!relatedScalarFields.has(refField)) {
+          errors.push({
+            severity: "error",
+            path: fieldPath,
+            code: "FK_REFERENCE_NOT_FOUND",
+            message: `Relation field "${field.name}" references field "${refField}" on model "${field.relatedModel}" which does not exist`,
+          });
+        }
+      }
+    }
+  } else {
+    // Non-FK side should have empty fields/references
+    if (rel.fields.length > 0) {
+      warnings.push({
+        severity: "warning",
+        path: fieldPath,
+        code: "NON_FK_HAS_FIELDS",
+        message: `Field "${field.name}" has isForeignKey=false but relation.fields is non-empty`,
+      });
+    }
+    if (rel.references.length > 0) {
+      warnings.push({
+        severity: "warning",
+        path: fieldPath,
+        code: "NON_FK_HAS_REFERENCES",
+        message: `Field "${field.name}" has isForeignKey=false but relation.references is non-empty`,
+      });
+    }
+  }
+
+  // Cross-model: check for inverse relation
+  const relatedModel = modelMap.get(field.relatedModel);
+  if (relatedModel) {
+    const inverseRelations = relatedModel.fields.filter(
+      (f): f is RelationField =>
+        f.kind === "relation" &&
+        f.relatedModel === model.name &&
+        (!rel.name || !f.relation.name || f.relation.name === rel.name)
+    );
+
+    if (inverseRelations.length === 0) {
+      warnings.push({
+        severity: "warning",
+        path: fieldPath,
+        code: "MISSING_INVERSE_RELATION",
+        message: `Field "${field.name}" on "${model.name}" has no inverse relation on "${field.relatedModel}"`,
+      });
+    }
+  }
+}
+
+// ─── Format Errors for CLI Output ─────────────────────────────────
+
+export function formatValidationErrors(params: {
+  result: ValidationResult;
+}): string {
+  const { result } = params;
+  const lines: string[] = [];
+
+  if (!result.valid) {
+    lines.push(`Schema validation failed with ${result.errors.length} error(s):`);
+    lines.push("");
+    for (const err of result.errors) {
+      lines.push(`  [ERROR] ${err.path}: ${err.message}`);
+    }
+  }
+
+  if (result.warnings.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push(`${result.warnings.length} warning(s):`);
+    for (const warn of result.warnings) {
+      lines.push(`  [WARN]  ${warn.path}: ${warn.message}`);
+    }
+  }
+
+  return lines.join("\n");
+}