synthra 0.1.0

data/lib/synthra/export/sql.rb

@@ -0,0 +1,381 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Synthra
+  module Export
+    # Exports schema as SQL CREATE TABLE statements
+    #
+    # @example Export a schema
+    #   exporter = Sql.new(schema, registry: registry, dialect: :postgresql)
+    #   sql = exporter.export
+    #
+    class Sql < Base
+      # Supported SQL dialects
+      DIALECTS = %i[postgresql mysql sqlite].freeze
+
+      # Type mappings for PostgreSQL
+      POSTGRESQL_TYPES = {
+        "uuid" => "UUID",
+        "ulid" => "VARCHAR(26)",
+        "email" => "VARCHAR(255)",
+        "url" => "TEXT",
+        "ip" => "INET",
+        "ipv6" => "INET",
+        "date" => "DATE",
+        "date_between" => "DATE",
+        "past_date" => "DATE",
+        "future_date" => "DATE",
+        "mobile_device_release_date" => "DATE",
+        "now" => "DATE",
+        "timestamp" => "TIMESTAMP WITH TIME ZONE",
+        "datetime" => "TIMESTAMP WITH TIME ZONE",
+        "text" => "TEXT",
+        "name" => "VARCHAR(255)",
+        "full_name" => "VARCHAR(255)",
+        "first_name" => "VARCHAR(100)",
+        "last_name" => "VARCHAR(100)",
+        "phone" => "VARCHAR(50)",
+        "city" => "VARCHAR(100)",
+        "country" => "VARCHAR(100)",
+        "country_code" => "CHAR(3)",
+        "postal_code" => "VARCHAR(20)",
+        "state" => "VARCHAR(100)",
+        "street" => "TEXT",
+        "address" => "TEXT",
+        "username" => "VARCHAR(50)",
+        "social_handle" => "VARCHAR(50)",
+        "domain" => "VARCHAR(255)",
+        "user_agent" => "TEXT",
+        "mac_address" => "MACADDR",
+        "iban" => "VARCHAR(34)",
+        "credit_card" => "VARCHAR(20)",
+        "currency" => "VARCHAR(10)",
+        "currency_code" => "CHAR(3)",
+        "paragraph" => "TEXT",
+        "sentence" => "TEXT",
+        "word" => "VARCHAR(100)",
+        "message_text" => "TEXT",
+        "hashtag_text" => "VARCHAR(100)",
+        "snowflake_id" => "BIGINT",
+        "numeric_string_id" => "BIGINT",
+        "number" => "INTEGER",
+        "integer" => "INTEGER",
+        "age" => "INTEGER",
+        "airport_elevation" => "INTEGER",
+        "discount" => "INTEGER",
+        "formula" => "INTEGER",
+        "row_number" => "INTEGER",
+        "sequence" => "INTEGER",
+        "float" => "DECIMAL(15,2)",
+        "money" => "DECIMAL(15,2)",
+        "latitude" => "DECIMAL(10,8)",
+        "longitude" => "DECIMAL(11,8)",
+        "airport_latitude" => "DECIMAL(10,8)",
+        "airport_longitude" => "DECIMAL(11,8)",
+        "product_price" => "DECIMAL(15,2)",
+        "tax_rate" => "DECIMAL(10,4)",
+        "transaction_amount" => "DECIMAL(15,2)",
+        "id_sequence" => "SERIAL",
+        "boolean" => "BOOLEAN",
+        "object" => "JSONB",
+        "map_by_field" => "JSONB",
+        "array" => "JSONB",
+        "empty_array" => "JSONB",
+        "json_array" => "JSONB",
+        "indices_pair" => "INTEGER[]"
+      }.freeze
+
+      # Type mappings for MySQL
+      MYSQL_TYPES = {
+        "uuid" => "CHAR(36)",
+        "ulid" => "CHAR(26)",
+        "email" => "VARCHAR(255)",
+        "url" => "TEXT",
+        "ip" => "VARCHAR(45)",
+        "ipv6" => "VARCHAR(45)",
+        "date" => "DATE",
+        "date_between" => "DATE",
+        "past_date" => "DATE",
+        "future_date" => "DATE",
+        "mobile_device_release_date" => "DATE",
+        "now" => "DATE",
+        "timestamp" => "DATETIME",
+        "datetime" => "DATETIME",
+        "text" => "TEXT",
+        "name" => "VARCHAR(255)",
+        "full_name" => "VARCHAR(255)",
+        "first_name" => "VARCHAR(100)",
+        "last_name" => "VARCHAR(100)",
+        "phone" => "VARCHAR(50)",
+        "city" => "VARCHAR(100)",
+        "country" => "VARCHAR(100)",
+        "country_code" => "CHAR(3)",
+        "postal_code" => "VARCHAR(20)",
+        "state" => "VARCHAR(100)",
+        "street" => "TEXT",
+        "address" => "TEXT",
+        "username" => "VARCHAR(50)",
+        "social_handle" => "VARCHAR(50)",
+        "domain" => "VARCHAR(255)",
+        "user_agent" => "TEXT",
+        "mac_address" => "CHAR(17)",
+        "iban" => "VARCHAR(34)",
+        "credit_card" => "VARCHAR(20)",
+        "currency" => "VARCHAR(10)",
+        "currency_code" => "CHAR(3)",
+        "paragraph" => "TEXT",
+        "sentence" => "TEXT",
+        "word" => "VARCHAR(100)",
+        "message_text" => "TEXT",
+        "hashtag_text" => "VARCHAR(100)",
+        "snowflake_id" => "BIGINT",
+        "numeric_string_id" => "BIGINT",
+        "number" => "INT",
+        "integer" => "INT",
+        "age" => "INT",
+        "airport_elevation" => "INT",
+        "discount" => "INT",
+        "formula" => "INT",
+        "row_number" => "INT",
+        "sequence" => "INT",
+        "float" => "DECIMAL(15,2)",
+        "money" => "DECIMAL(15,2)",
+        "latitude" => "DECIMAL(10,8)",
+        "longitude" => "DECIMAL(11,8)",
+        "airport_latitude" => "DECIMAL(10,8)",
+        "airport_longitude" => "DECIMAL(11,8)",
+        "product_price" => "DECIMAL(15,2)",
+        "tax_rate" => "DECIMAL(10,4)",
+        "transaction_amount" => "DECIMAL(15,2)",
+        "id_sequence" => "INT AUTO_INCREMENT",
+        "boolean" => "TINYINT(1)",
+        "object" => "JSON",
+        "map_by_field" => "JSON",
+        "array" => "JSON",
+        "empty_array" => "JSON",
+        "json_array" => "JSON",
+        "indices_pair" => "JSON"
+      }.freeze
+
+      # Type mappings for SQLite
+      SQLITE_TYPES = {
+        "uuid" => "TEXT",
+        "ulid" => "TEXT",
+        "email" => "TEXT",
+        "url" => "TEXT",
+        "ip" => "TEXT",
+        "ipv6" => "TEXT",
+        "date" => "TEXT",
+        "date_between" => "TEXT",
+        "past_date" => "TEXT",
+        "future_date" => "TEXT",
+        "mobile_device_release_date" => "TEXT",
+        "now" => "TEXT",
+        "timestamp" => "TEXT",
+        "datetime" => "TEXT",
+        "text" => "TEXT",
+        "name" => "TEXT",
+        "full_name" => "TEXT",
+        "first_name" => "TEXT",
+        "last_name" => "TEXT",
+        "phone" => "TEXT",
+        "city" => "TEXT",
+        "country" => "TEXT",
+        "country_code" => "TEXT",
+        "postal_code" => "TEXT",
+        "state" => "TEXT",
+        "street" => "TEXT",
+        "address" => "TEXT",
+        "username" => "TEXT",
+        "social_handle" => "TEXT",
+        "domain" => "TEXT",
+        "user_agent" => "TEXT",
+        "mac_address" => "TEXT",
+        "iban" => "TEXT",
+        "credit_card" => "TEXT",
+        "currency" => "TEXT",
+        "currency_code" => "TEXT",
+        "paragraph" => "TEXT",
+        "sentence" => "TEXT",
+        "word" => "TEXT",
+        "message_text" => "TEXT",
+        "hashtag_text" => "TEXT",
+        "snowflake_id" => "INTEGER",
+        "numeric_string_id" => "INTEGER",
+        "number" => "INTEGER",
+        "integer" => "INTEGER",
+        "age" => "INTEGER",
+        "airport_elevation" => "INTEGER",
+        "discount" => "INTEGER",
+        "formula" => "INTEGER",
+        "row_number" => "INTEGER",
+        "sequence" => "INTEGER",
+        "float" => "REAL",
+        "money" => "REAL",
+        "latitude" => "REAL",
+        "longitude" => "REAL",
+        "airport_latitude" => "REAL",
+        "airport_longitude" => "REAL",
+        "product_price" => "REAL",
+        "tax_rate" => "REAL",
+        "transaction_amount" => "REAL",
+        "id_sequence" => "INTEGER PRIMARY KEY AUTOINCREMENT",
+        "boolean" => "INTEGER",
+        "object" => "TEXT",
+        "map_by_field" => "TEXT",
+        "array" => "TEXT",
+        "empty_array" => "TEXT",
+        "json_array" => "TEXT",
+        "indices_pair" => "TEXT"
+      }.freeze
+
+      def export
+        dialect = options[:dialect] || :postgresql
+        lines = []
+
+        # Add header comment
+        lines << "-- Generated from Synthra schema: #{schema.name}"
+        lines << "-- Dialect: #{dialect.to_s.upcase}"
+        lines << "-- Version: #{schema.version}" if schema.version
+        lines << ""
+
+        # Export referenced schemas first
+        exported = Set.new
+        collect_referenced_schemas.each do |ref_schema|
+          lines << build_table(ref_schema, dialect)
+          lines << ""
+          exported << ref_schema.name
+        end
+
+        # Export main schema
+        lines << build_table(schema, dialect) unless exported.include?(schema.name)
+
+        lines.join("\n")
+      end
+
+      # Export all schemas in a registry
+      #
+      # @param registry [Registry] the registry
+      # @param options [Hash] export options
+      # @return [String] SQL statements
+      #
+      def self.export_all(registry, **options)
+        dialect = options[:dialect] || :postgresql
+        lines = []
+        lines << "-- Generated from Synthra schemas"
+        lines << "-- Dialect: #{dialect.to_s.upcase}"
+        lines << "-- Schemas: #{registry.names.join(', ')}"
+        lines << ""
+
+        registry.schemas.each do |name, schema|
+          exporter = new(schema, registry: registry, **options)
+          lines << exporter.build_table(schema, dialect)
+          lines << ""
+        end
+
+        lines.join("\n")
+      end
+
+      def build_table(target_schema, dialect)
+        type_mappings = case dialect
+                        when :mysql then MYSQL_TYPES
+                        when :sqlite then SQLITE_TYPES
+                        else POSTGRESQL_TYPES
+                        end
+
+        table_name = to_snake_case(target_schema.name)
+        lines = []
+        
+        lines << "CREATE TABLE #{table_name} ("
+
+        columns = target_schema.fields.map do |field|
+          build_column(field, type_mappings, dialect)
+        end
+
+        lines << "  " + columns.join(",\n  ")
+        lines << ");"
+
+        lines.join("\n")
+      end
+
+      private
+
+      def collect_referenced_schemas
+        schemas = []
+        schema.fields.each do |field|
+          collect_field_schemas(field, schemas)
+        end
+        schemas.uniq(&:name)
+      end
+
+      def collect_field_schemas(field, schemas)
+        type_name = field.type_name
+
+        if schema_reference?(type_name)
+          ref_schema = get_schema(type_name)
+          if ref_schema && !schemas.any? { |s| s.name == ref_schema.name }
+            schemas << ref_schema
+          end
+        end
+
+        if type_name == "array"
+          element = field.type_args[:element]
+          if element && schema_reference?(element.to_s)
+            ref_schema = get_schema(element.to_s)
+            if ref_schema && !schemas.any? { |s| s.name == ref_schema.name }
+              schemas << ref_schema
+            end
+          end
+        end
+      end
+
+      def build_column(field, type_mappings, dialect)
+        column_name = to_snake_case(field.name)
+        sql_type = field_to_sql_type(field, type_mappings)
+
+        parts = [column_name, sql_type]
+        parts << "NOT NULL" unless field.optional? || field.nullable?
+        parts << "DEFAULT NULL" if field.nullable? && !field.optional?
+
+        parts.join(" ")
+      end
+
+      def field_to_sql_type(field, type_mappings)
+        type_name = field.type_name
+        type_args = field.type_args
+
+        case type_name
+        when "enum"
+          build_enum_type(type_args, type_mappings)
+        when "const"
+          type_mappings["text"]
+        when "array", "one_of", "map_by_field"
+          type_mappings["object"] || "TEXT"
+        else
+          if type_mappings[type_name]
+            type_mappings[type_name]
+          elsif schema_reference?(type_name)
+            # Foreign key - use UUID or appropriate ID type
+            type_mappings["uuid"] || "TEXT"
+          else
+            type_mappings["text"] || "TEXT"
+          end
+        end
+      end
+
+      def build_enum_type(args, type_mappings)
+        values = args[:values]&.map { |v| v.respond_to?(:value) ? v.value : v } || []
+        # For PostgreSQL, could create an ENUM type, but VARCHAR is more portable
+        max_length = values.map(&:to_s).map(&:length).max || 50
+        "VARCHAR(#{[max_length, 50].max})"
+      end
+
+      def to_snake_case(str)
+        str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+    end
+    # :nocov:
+  end
+end

data/lib/synthra/export/sql_insert.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Synthra
+  module Export
+    # Exports generated data as SQL INSERT statements
+    #
+    # @example Export schema data as SQL INSERTs
+    #   exporter = SqlInsert.new(schema, registry: registry, count: 100, dialect: :postgresql)
+    #   sql = exporter.export
+    #
+    class SqlInsert < Base
+      # Supported SQL dialects
+      DIALECTS = %i[postgresql mysql sqlite].freeze
+
+      def export
+        count = options[:count] || 10
+        seed = options[:seed]
+        mode = options[:mode] || :random
+        dialect = options[:dialect] || :postgresql
+
+        records = schema.generate_many(count, seed: seed, mode: mode, registry: registry)
+
+        lines = []
+        lines << "-- Generated from Synthra schema: #{schema.name}"
+        lines << "-- Dialect: #{dialect.to_s.upcase}"
+        lines << "-- Records: #{count}"
+        lines << "-- Generated at: #{Time.now.iso8601}"
+        lines << ""
+
+        table_name = to_snake_case(schema.name)
+
+        if options[:batch_insert] && dialect != :sqlite
+          lines << build_batch_insert(table_name, records, dialect)
+        else
+          records.each do |record|
+            lines << build_single_insert(table_name, record, dialect)
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      private
+
+      def build_single_insert(table_name, record, dialect)
+        flat_record = flatten_record(record)
+        columns = flat_record.keys.map { |k| quote_identifier(k, dialect) }
+        values = flat_record.values.map { |v| format_value(v, dialect) }
+
+        "INSERT INTO #{quote_identifier(table_name, dialect)} (#{columns.join(', ')}) VALUES (#{values.join(', ')});"
+      end
+
+      def build_batch_insert(table_name, records, dialect)
+        return "" if records.empty?
+
+        flat_records = records.map { |r| flatten_record(r) }
+        columns = flat_records.first.keys.map { |k| quote_identifier(k, dialect) }
+
+        lines = []
+        lines << "INSERT INTO #{quote_identifier(table_name, dialect)} (#{columns.join(', ')}) VALUES"
+
+        values_lines = flat_records.map do |flat_record|
+          values = flat_record.values.map { |v| format_value(v, dialect) }
+          "  (#{values.join(', ')})"
+        end
+
+        lines << values_lines.join(",\n") + ";"
+        lines.join("\n")
+      end
+
+      def flatten_record(record, prefix = "")
+        result = {}
+
+        record.each do |key, value|
+          full_key = prefix.empty? ? key : "#{prefix}_#{key}"
+
+          case value
+          when Hash
+            # For nested objects, either flatten or serialize as JSON
+            if options[:flatten_nested]
+              result.merge!(flatten_record(value, full_key))
+            else
+              result[full_key] = JSON.generate(value)
+            end
+          when Array
+            # Arrays become JSON
+            result[full_key] = JSON.generate(value)
+          else
+            result[full_key] = value
+          end
+        end
+
+        result
+      end
+
+      def format_value(value, dialect)
+        case value
+        when nil
+          "NULL"
+        when true
+          dialect == :mysql ? "1" : "TRUE"
+        when false
+          dialect == :mysql ? "0" : "FALSE"
+        when Integer
+          value.to_s
+        when Float
+          value.to_s
+        when String
+          escape_string(value, dialect)
+        when Time, DateTime
+          escape_string(value.iso8601, dialect)
+        when Date
+          escape_string(value.to_s, dialect)
+        else
+          escape_string(value.to_s, dialect)
+        end
+      end
+
+      def escape_string(str, dialect)
+        escaped = str.gsub("'", "''")
+        case dialect
+        when :mysql
+          "'#{escaped.gsub('\\', '\\\\\\\\')}'"
+        else
+          "'#{escaped}'"
+        end
+      end
+
+      def quote_identifier(name, dialect)
+        snake_name = to_snake_case(name.to_s)
+        # SECURITY: escape the quote char inside the identifier (double it) so a field name
+        # containing a backtick / double-quote can't break out of the quoting into injected SQL.
+        case dialect
+        when :mysql
+          "`#{snake_name.gsub('`', '``')}`"
+        when :postgresql
+          "\"#{snake_name.gsub('"', '""')}\""
+        else
+          snake_name
+        end
+      end
+
+      def to_snake_case(str)
+        str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+    end
+    # :nocov:
+  end
+end