synthra 0.1.0

data/lib/synthra/migration_generator.rb

@@ -0,0 +1,301 @@
+# frozen_string_literal: true
+
+module Synthra
+  # Schema Migration Generator
+  #
+  # Generate database migrations from schema changes.
+  # Works with the ContractsRegistry to track versions
+  # and produce Rails-compatible migrations.
+  #
+  # @example Generate migration from diff
+  #   MigrationGenerator.generate(
+  #     from: "User@v1.0.0",
+  #     to: "User@v2.0.0",
+  #     output: "db/migrate/"
+  #   )
+  #
+  # @example CLI
+  #   $ synthra schema migrate User --from v1.0.0 --to v2.0.0
+  #
+  class MigrationGenerator
+    # Type mapping from Synthra to ActiveRecord
+    TYPE_MAP = {
+      "text" => "string",
+      "name" => "string",
+      "email" => "string",
+      "url" => "string",
+      "paragraph" => "text",
+      "uuid" => "uuid",
+      "number" => "integer",
+      "integer" => "integer",
+      "float" => "float",
+      "money" => "decimal, precision: 10, scale: 2",
+      "decimal" => "decimal, precision: 10, scale: 2",
+      "boolean" => "boolean",
+      "timestamp" => "datetime",
+      "datetime" => "datetime",
+      "date" => "date",
+      "time" => "time",
+      "object" => "jsonb",
+      "json" => "jsonb",
+      "binary" => "binary",
+      "array" => "text, array: true"
+    }.freeze
+
+    class << self
+      private
+
+      # Convert CamelCase to snake_case
+      def underscore(str)
+        str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+
+      # Simple pluralization
+      def pluralize(str)
+        if str.end_with?('s', 'x', 'z', 'ch', 'sh')
+          "#{str}es"
+        elsif str.end_with?('y') && !%w[a e i o u].include?(str[-2])
+          "#{str[0..-2]}ies"
+        else
+          "#{str}s"
+        end
+      end
+
+      public
+
+      # Generate a migration from schema changes
+      #
+      # @param from [String] source schema/version
+      # @param to [String] target schema/version
+      # @param output [String] output directory
+      # @param options [Hash] generation options
+      # @return [String] migration file path
+      #
+      def generate(from:, to:, output: nil, **options)
+        from_schema = resolve_schema(from)
+        to_schema = resolve_schema(to)
+
+        diff = calculate_diff(from_schema, to_schema)
+        migration = build_migration(from_schema, to_schema, diff, options)
+
+        if output
+          write_migration(migration, output, from_schema, to_schema)
+        else
+          migration
+        end
+      end
+
+      # Generate migration from two schema files
+      #
+      # @param old_path [String] path to old schema
+      # @param new_path [String] path to new schema
+      # @param output [String] output directory
+      # @return [String] migration content or file path
+      #
+      def from_files(old_path:, new_path:, output: nil)
+        old_reg = Synthra::Registry.new
+        old_reg.load_file(old_path)
+        old_schemas = old_reg.schemas.values
+
+        new_reg = Synthra::Registry.new
+        new_reg.load_file(new_path)
+        new_schemas = new_reg.schemas.values
+
+        # Match by name
+        old_schema = old_schemas.first
+        new_schema = new_schemas.first
+
+        diff = calculate_diff(old_schema, new_schema)
+        migration = build_migration(old_schema, new_schema, diff, {})
+
+        if output
+          write_migration(migration, output, old_schema, new_schema)
+        else
+          migration
+        end
+      end
+
+      # Generate initial migration for a schema
+      #
+      # @param schema [Schema, String] schema to migrate
+      # @param output [String] output directory
+      # @return [String] migration content or file path
+      #
+      def create_table(schema, output: nil)
+        schema = resolve_schema(schema) if schema.is_a?(String)
+
+        migration = build_create_table_migration(schema)
+
+        if output
+          write_migration(migration, output, nil, schema, action: "create")
+        else
+          migration
+        end
+      end
+
+      private
+
+      def resolve_schema(identifier)
+        # Handle versioned identifiers like "User@v1.0.0"
+        if identifier.include?("@")
+          name, version = identifier.split("@")
+          contracts = Synthra::ContractsRegistry.new("contracts")
+          contract = contracts.get(name, version: version)
+          raise ArgumentError, "Contract not found: #{identifier}" unless contract
+
+          # Rebuild schema from contract
+          reg = Synthra::Registry.new
+          reg.load_string(contract[:dsl_content])
+          reg.schemas.values.first
+        elsif Synthra.registry.schema?(identifier)
+          Synthra.registry.schema(identifier)
+        else
+          raise ArgumentError, "Schema not found: #{identifier}"
+        end
+      end
+
+      def calculate_diff(old_schema, new_schema)
+        old_fields = old_schema.fields.each_with_object({}) { |f, h| h[f.name] = f }
+        new_fields = new_schema.fields.each_with_object({}) { |f, h| h[f.name] = f }
+
+        {
+          added: new_fields.keys - old_fields.keys,
+          removed: old_fields.keys - new_fields.keys,
+          type_changed: (old_fields.keys & new_fields.keys).select do |name|
+            old_fields[name].type_name != new_fields[name].type_name
+          end,
+          nullable_changed: (old_fields.keys & new_fields.keys).select do |name|
+            old_fields[name].nullable? != new_fields[name].nullable? ||
+              old_fields[name].optional? != new_fields[name].optional?
+          end,
+          old_fields: old_fields,
+          new_fields: new_fields
+        }
+      end
+
+      def build_migration(old_schema, new_schema, diff, options)
+        table_name = pluralize(underscore(new_schema.name))
+        class_name = "Migrate#{old_schema.name}To#{new_schema.name.sub(/.*/, '')}"
+
+        # If versions exist in names
+        if old_schema.name.include?("@") || new_schema.name.include?("@")
+          old_version = old_schema.name.split("@").last rescue "v1"
+          new_version = new_schema.name.split("@").last rescue "v2"
+          class_name = "Migrate#{old_schema.name.split('@').first}#{old_version.gsub('.', '')}To#{new_version.gsub('.', '')}"
+        else
+          class_name = "Update#{new_schema.name}Schema"
+        end
+
+        changes = []
+
+        # Added columns
+        diff[:added].each do |name|
+          field = diff[:new_fields][name]
+          ar_type = TYPE_MAP[field.type_name] || "string"
+          null = field.optional? || field.nullable? ? "null: true" : "null: false"
+          changes << "    add_column :#{table_name}, :#{name}, :#{ar_type}, #{null}"
+        end
+
+        # Removed columns
+        diff[:removed].each do |name|
+          field = diff[:old_fields][name]
+          ar_type = TYPE_MAP[field.type_name] || "string"
+          changes << "    remove_column :#{table_name}, :#{name}, :#{ar_type}"
+        end
+
+        # Type changes
+        diff[:type_changed].each do |name|
+          old_field = diff[:old_fields][name]
+          new_field = diff[:new_fields][name]
+          new_type = TYPE_MAP[new_field.type_name] || "string"
+          changes << "    change_column :#{table_name}, :#{name}, :#{new_type}  # was: #{old_field.type_name}"
+        end
+
+        # Nullable changes
+        diff[:nullable_changed].each do |name|
+          next if diff[:type_changed].include?(name)
+
+          new_field = diff[:new_fields][name]
+          null = new_field.optional? || new_field.nullable?
+          changes << "    change_column_null :#{table_name}, :#{name}, #{null}"
+        end
+
+        <<~MIGRATION
+          # frozen_string_literal: true
+
+          # Generated by Synthra
+          # From: #{old_schema.name}
+          # To: #{new_schema.name}
+
+          class #{class_name} < ActiveRecord::Migration[7.1]
+            def change
+          #{changes.join("\n")}
+            end
+          end
+        MIGRATION
+      end
+
+      def build_create_table_migration(schema)
+        table_name = pluralize(underscore(schema.name))
+        class_name = "Create#{pluralize(schema.name)}"
+
+        columns = schema.fields.map do |field|
+          ar_type = TYPE_MAP[field.type_name] || "string"
+          null = field.optional? || field.nullable? ? "null: true" : "null: false"
+
+          if field.name == "id"
+            nil # Skip id, handled by primary key
+          else
+            "      t.#{ar_type.split(',').first} :#{field.name}, #{null}"
+          end
+        end.compact
+
+        # Check for timestamps
+        has_created_at = schema.fields.any? { |f| f.name == "created_at" }
+        has_updated_at = schema.fields.any? { |f| f.name == "updated_at" }
+
+        timestamps = if has_created_at && has_updated_at
+                       columns.reject! { |c| c.include?(":created_at") || c.include?(":updated_at") }
+                       "\n      t.timestamps"
+                     else
+                       ""
+                     end
+
+        <<~MIGRATION
+          # frozen_string_literal: true
+
+          # Generated by Synthra
+          # Schema: #{schema.name}
+
+          class #{class_name} < ActiveRecord::Migration[7.1]
+            def change
+              create_table :#{table_name}, id: :uuid do |t|
+          #{columns.join("\n")}#{timestamps}
+              end
+            end
+          end
+        MIGRATION
+      end
+
+      def write_migration(content, output_dir, old_schema, new_schema, action: "update")
+        FileUtils.mkdir_p(output_dir)
+
+        timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+        schema_name = underscore(new_schema.name)
+
+        filename = case action
+                   when "create"
+                     "#{timestamp}_create_#{pluralize(schema_name)}.rb"
+                   else
+                     "#{timestamp}_update_#{schema_name}.rb"
+                   end
+
+        path = File.join(output_dir, filename)
+        File.write(path, content)
+        path
+      end
+    end
+  end
+end

data/lib/synthra/mixin.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Synthra
+  # Schema Mixin Support
+  #
+  # Allows defining reusable field sets that can be included in multiple schemas.
+  # More flexible than inheritance for cross-cutting concerns.
+  #
+  # @example Define a mixin
+  #   @mixin Timestamps:
+  #     created_at: timestamp
+  #     updated_at: timestamp
+  #
+  # @example Use in a schema
+  #   User:
+  #     @include Timestamps
+  #     id: uuid
+  #     name: name
+  #
+  module Mixin
+    # Registry for storing mixins
+    class Registry
+      class << self
+        def instance
+          @instance ||= new
+        end
+
+        def register(name, fields:, behaviors: [])
+          instance.register(name, fields: fields, behaviors: behaviors)
+        end
+
+        def get(name)
+          instance.get(name)
+        end
+
+        def exists?(name)
+          instance.exists?(name)
+        end
+
+        def clear
+          instance.clear
+        end
+
+        def all
+          instance.all
+        end
+      end
+
+      def initialize
+        @mixins = {}
+        @mutex = Mutex.new
+      end
+
+      # Register a mixin
+      #
+      # @param name [String] mixin name
+      # @param fields [Array<Field>] mixin fields
+      # @param behaviors [Array<Hash>] mixin behaviors
+      #
+      def register(name, fields:, behaviors: [])
+        @mutex.synchronize do
+          @mixins[name.to_s] = {
+            name: name.to_s,
+            fields: fields,
+            behaviors: behaviors
+          }
+        end
+      end
+
+      # Get a mixin by name
+      #
+      # @param name [String] mixin name
+      # @return [Hash, nil] mixin definition
+      #
+      def get(name)
+        @mutex.synchronize { @mixins[name.to_s] }
+      end
+
+      # Check if mixin exists
+      #
+      # @param name [String] mixin name
+      # @return [Boolean]
+      #
+      def exists?(name)
+        @mutex.synchronize { @mixins.key?(name.to_s) }
+      end
+
+      # Clear all mixins
+      def clear
+        @mutex.synchronize { @mixins.clear }
+      end
+
+      # Get all mixins
+      def all
+        @mutex.synchronize { @mixins.dup }
+      end
+    end
+
+    # Apply mixins to a schema
+    #
+    # @param schema_node [AST::SchemaNode] the schema node
+    # @param mixin_names [Array<String>] names of mixins to include
+    # @return [AST::SchemaNode] schema with mixin fields added
+    #
+    def self.apply(schema_node, mixin_names)
+      return schema_node if mixin_names.empty?
+
+      all_fields = []
+      all_behaviors = schema_node.behaviors.dup
+
+      # Add fields from each mixin (in order)
+      mixin_names.each do |mixin_name|
+        mixin = Registry.get(mixin_name)
+        raise Errors::MixinError, "Unknown mixin: #{mixin_name}" unless mixin
+
+        all_fields.concat(mixin[:fields])
+        all_behaviors.concat(mixin[:behaviors])
+      end
+
+      # Add schema's own fields (override mixin fields if same name)
+      existing_names = all_fields.map { |f| f.respond_to?(:name) ? f.name : f[:name] }
+      schema_node.fields.each do |field|
+        field_name = field.respond_to?(:name) ? field.name : field[:name]
+        if existing_names.include?(field_name)
+          # Replace mixin field with schema field
+          all_fields.reject! { |f| (f.respond_to?(:name) ? f.name : f[:name]) == field_name }
+        end
+        all_fields << field
+      end
+
+      # Create new schema node with merged fields
+      Parser::AST::SchemaNode.new(
+        name: schema_node.name,
+        fields: all_fields,
+        behaviors: all_behaviors,
+        parent_name: schema_node.parent_name,
+        line: schema_node.line
+      )
+    end
+  end
+
+  # Common mixins that come pre-registered
+  module CommonMixins
+    def self.register_all!
+      # Timestamps mixin
+      Mixin::Registry.register("Timestamps", fields: [
+        Field.new(name: "created_at", type_name: "timestamp"),
+        Field.new(name: "updated_at", type_name: "timestamp")
+      ])
+
+      # Soft delete mixin
+      Mixin::Registry.register("SoftDelete", fields: [
+        Field.new(name: "deleted_at?", type_name: "timestamp?")
+      ])
+
+      # Auditable mixin
+      Mixin::Registry.register("Auditable", fields: [
+        Field.new(name: "created_by?", type_name: "uuid"),
+        Field.new(name: "updated_by?", type_name: "uuid")
+      ])
+
+      # Sluggable mixin
+      Mixin::Registry.register("Sluggable", fields: [
+        Field.new(name: "slug", type_name: "text")
+      ])
+
+      # Publishable mixin
+      Mixin::Registry.register("Publishable", fields: [
+        Field.new(name: "published_at?", type_name: "timestamp?"),
+        Field.new(name: "published", type_name: "boolean")
+      ])
+    end
+  end
+end