Module: DbSchema::Validator

Defined in:
lib/db_schema/validator.rb

Defined Under Namespace

Classes: Result

Class Method Summary collapse

Class Method Details

.validate(schema) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/db_schema/validator.rb', line 4

def validate(schema)
  tables = Utils.filter_by_class(schema, Definitions::Table)
  enums  = Utils.filter_by_class(schema, Definitions::Enum)

  table_errors = tables.each_with_object([]) do |table, errors|
    primary_keys_count = table.fields.select(&:primary_key?).count
    if primary_keys_count > 1
      error_message = %(Table "#{table.name}" has #{primary_keys_count} primary keys)
      errors << error_message
    end

    table.fields.each do |field|
      if field.is_a?(Definitions::Field::Custom)
        unless enums.map(&:name).include?(field.type_name)
          error_message = %(Field "#{table.name}.#{field.name}" has unknown type "#{field.type_name}")
          errors << error_message
        end
      end
    end

    field_names = table.fields.map(&:name)

    table.indices.each do |index|
      index.columns.reject(&:expression?).map(&:name).each do |field_name|
        unless field_names.include?(field_name)
          error_message = %(Index "#{index.name}" refers to a missing field "#{table.name}.#{field_name}")
          errors << error_message
        end
      end
    end

    table.foreign_keys.each do |fkey|
      fkey.fields.each do |field_name|
        unless field_names.include?(field_name)
          error_message = %(Foreign key "#{fkey.name}" constrains a missing field "#{table.name}.#{field_name}")
          errors << error_message
        end
      end

      if referenced_table = schema.find { |table| table.name == fkey.table }
        if fkey.references_primary_key?
          unless referenced_table.fields.any?(&:primary_key?)
            error_message = %(Foreign key "#{fkey.name}" refers to primary key of table "#{fkey.table}" which does not have a primary key)
            errors << error_message
          end
        else
          referenced_table_field_names = referenced_table.fields.map(&:name)

          fkey.keys.each do |key|
            unless referenced_table_field_names.include?(key)
              error_message = %(Foreign key "#{fkey.name}" refers to a missing field "#{fkey.table}.#{key}")
              errors << error_message
            end
          end
        end
      else
        error_message = %(Foreign key "#{fkey.name}" refers to a missing table "#{fkey.table}")
        errors << error_message
      end
    end
  end

  enum_errors = enums.each_with_object([]) do |enum, errors|
    if enum.values.empty?
      error_message = %(Enum "#{enum.name}" contains no values)
      errors << error_message
    end
  end

  Result.new(table_errors + enum_errors)
end