rooq 1.0.0

data/lib/rooq/generator/introspector.rb

@@ -0,0 +1,265 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rooq
+  module Generator
+    class Introspector
+      extend T::Sig
+
+      PG_TYPE_MAP = T.let({
+        "integer" => :integer,
+        "bigint" => :bigint,
+        "smallint" => :smallint,
+        "serial" => :integer,
+        "bigserial" => :bigint,
+        "real" => :float,
+        "double precision" => :double,
+        "numeric" => :decimal,
+        "decimal" => :decimal,
+        "character varying" => :string,
+        "varchar" => :string,
+        "character" => :string,
+        "char" => :string,
+        "text" => :text,
+        "boolean" => :boolean,
+        "date" => :date,
+        "timestamp without time zone" => :datetime,
+        "timestamp with time zone" => :datetime_tz,
+        "time without time zone" => :time,
+        "time with time zone" => :time_tz,
+        "uuid" => :uuid,
+        "json" => :json,
+        "jsonb" => :jsonb,
+        "bytea" => :binary,
+        "inet" => :inet,
+        "cidr" => :cidr,
+        "macaddr" => :macaddr
+      }.freeze, T::Hash[String, Symbol])
+
+      sig { params(connection: T.untyped).void }
+      def initialize(connection)
+        @connection = connection
+      end
+
+      sig { params(schema: String).returns(T::Array[String]) }
+      def introspect_tables(schema: "public")
+        tables_sql = <<~SQL
+          SELECT table_name
+          FROM information_schema.tables
+          WHERE table_schema = $1
+            AND table_type = 'BASE TABLE'
+          ORDER BY table_name
+        SQL
+
+        result = @connection.exec_params(tables_sql, [schema])
+        result.map { |row| row["table_name"] }
+      end
+
+      sig { params(table_name: String, schema: String).returns(T::Array[ColumnInfo]) }
+      def introspect_columns(table_name, schema: "public")
+        columns_sql = <<~SQL
+          SELECT
+            column_name,
+            data_type,
+            is_nullable,
+            column_default,
+            character_maximum_length,
+            numeric_precision,
+            numeric_scale
+          FROM information_schema.columns
+          WHERE table_schema = $1
+            AND table_name = $2
+          ORDER BY ordinal_position
+        SQL
+
+        result = @connection.exec_params(columns_sql, [schema, table_name])
+        result.map do |row|
+          ColumnInfo.new(
+            name: row["column_name"],
+            type: map_pg_type(row["data_type"]),
+            pg_type: row["data_type"],
+            nullable: row["is_nullable"] == "YES",
+            default: row["column_default"],
+            max_length: row["character_maximum_length"]&.to_i,
+            precision: row["numeric_precision"]&.to_i,
+            scale: row["numeric_scale"]&.to_i
+          )
+        end
+      end
+
+      sig { params(table_name: String, schema: String).returns(T::Array[String]) }
+      def introspect_primary_keys(table_name, schema: "public")
+        pk_sql = <<~SQL
+          SELECT kcu.column_name
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          WHERE tc.constraint_type = 'PRIMARY KEY'
+            AND tc.table_schema = $1
+            AND tc.table_name = $2
+          ORDER BY kcu.ordinal_position
+        SQL
+
+        result = @connection.exec_params(pk_sql, [schema, table_name])
+        result.map { |row| row["column_name"] }
+      end
+
+      sig { params(table_name: String, schema: String).returns(T::Array[ForeignKeyInfo]) }
+      def introspect_foreign_keys(table_name, schema: "public")
+        fk_sql = <<~SQL
+          SELECT
+            kcu.column_name,
+            ccu.table_name AS foreign_table_name,
+            ccu.column_name AS foreign_column_name
+          FROM information_schema.table_constraints tc
+          JOIN information_schema.key_column_usage kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage ccu
+            ON ccu.constraint_name = tc.constraint_name
+            AND ccu.table_schema = tc.table_schema
+          WHERE tc.constraint_type = 'FOREIGN KEY'
+            AND tc.table_schema = $1
+            AND tc.table_name = $2
+        SQL
+
+        result = @connection.exec_params(fk_sql, [schema, table_name])
+        result.map do |row|
+          ForeignKeyInfo.new(
+            column_name: row["column_name"],
+            foreign_table: row["foreign_table_name"],
+            foreign_column: row["foreign_column_name"]
+          )
+        end
+      end
+
+      sig { params(schema: String).returns(T::Array[TableInfo]) }
+      def introspect_schema(schema: "public")
+        tables = introspect_tables(schema: schema)
+        tables.map do |table_name|
+          TableInfo.new(
+            name: table_name,
+            columns: introspect_columns(table_name, schema: schema),
+            primary_keys: introspect_primary_keys(table_name, schema: schema),
+            foreign_keys: introspect_foreign_keys(table_name, schema: schema)
+          )
+        end
+      end
+
+      private
+
+      sig { params(pg_type: String).returns(Symbol) }
+      def map_pg_type(pg_type)
+        PG_TYPE_MAP.fetch(pg_type.downcase, :unknown)
+      end
+    end
+
+    class ColumnInfo
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { returns(Symbol) }
+      attr_reader :type
+
+      sig { returns(String) }
+      attr_reader :pg_type
+
+      sig { returns(T::Boolean) }
+      attr_reader :nullable
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :default
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :max_length
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :precision
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :scale
+
+      sig do
+        params(
+          name: String,
+          type: Symbol,
+          pg_type: String,
+          nullable: T::Boolean,
+          default: T.nilable(String),
+          max_length: T.nilable(Integer),
+          precision: T.nilable(Integer),
+          scale: T.nilable(Integer)
+        ).void
+      end
+      def initialize(name:, type:, pg_type:, nullable:, default:, max_length:, precision:, scale:)
+        @name = name
+        @type = type
+        @pg_type = pg_type
+        @nullable = nullable
+        @default = default
+        @max_length = max_length
+        @precision = precision
+        @scale = scale
+        freeze
+      end
+    end
+
+    class ForeignKeyInfo
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :column_name
+
+      sig { returns(String) }
+      attr_reader :foreign_table
+
+      sig { returns(String) }
+      attr_reader :foreign_column
+
+      sig { params(column_name: String, foreign_table: String, foreign_column: String).void }
+      def initialize(column_name:, foreign_table:, foreign_column:)
+        @column_name = column_name
+        @foreign_table = foreign_table
+        @foreign_column = foreign_column
+        freeze
+      end
+    end
+
+    class TableInfo
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { returns(T::Array[ColumnInfo]) }
+      attr_reader :columns
+
+      sig { returns(T::Array[String]) }
+      attr_reader :primary_keys
+
+      sig { returns(T::Array[ForeignKeyInfo]) }
+      attr_reader :foreign_keys
+
+      sig do
+        params(
+          name: String,
+          columns: T::Array[ColumnInfo],
+          primary_keys: T::Array[String],
+          foreign_keys: T::Array[ForeignKeyInfo]
+        ).void
+      end
+      def initialize(name:, columns:, primary_keys:, foreign_keys:)
+        @name = name
+        @columns = T.let(columns.freeze, T::Array[ColumnInfo])
+        @primary_keys = T.let(primary_keys.freeze, T::Array[String])
+        @foreign_keys = T.let(foreign_keys.freeze, T::Array[ForeignKeyInfo])
+        freeze
+      end
+    end
+  end
+end

data/lib/rooq/generator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "generator/introspector"
+require_relative "generator/code_generator"
+
+module Rooq
+  module Generator
+  end
+end

data/lib/rooq/parameter_converter.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+require "date"
+
+module Rooq
+  # ParameterConverter converts Ruby objects to PostgreSQL-compatible parameter values.
+  #
+  # Conversions:
+  # - Time/DateTime -> ISO 8601 string
+  # - Date -> ISO 8601 date string
+  # - Hash -> JSON string
+  # - Array of primitives -> PostgreSQL array literal
+  # - Array of hashes -> JSON array string
+  # - Symbol -> String
+  # - Other types pass through unchanged
+  #
+  # @example
+  #   converter = ParameterConverter.new
+  #   converter.convert(Time.now)           # => "2024-01-15T10:30:45+00:00"
+  #   converter.convert({ key: "value" })   # => '{"key":"value"}'
+  #   converter.convert([1, 2, 3])          # => "{1,2,3}"
+  class ParameterConverter
+    # Convert a single parameter value.
+    # @param value [Object] the value to convert
+    # @return [Object] the converted value
+    def convert(value)
+      case value
+      when nil, true, false, Integer, Float
+        value
+      when String
+        value
+      when Time, DateTime
+        value.iso8601
+      when Date
+        value.iso8601
+      when Hash
+        JSON.generate(value)
+      when Array
+        convert_array(value)
+      when Symbol
+        value.to_s
+      else
+        value
+      end
+    end
+
+    # Convert an array of parameter values.
+    # @param params [Array] the parameters to convert
+    # @return [Array] the converted parameters
+    def convert_all(params)
+      params.map { |p| convert(p) }
+    end
+
+    private
+
+    def convert_array(array)
+      return "{}" if array.empty?
+
+      # If array contains hashes, convert to JSON array
+      if array.any? { |el| el.is_a?(Hash) }
+        return JSON.generate(array)
+      end
+
+      # Otherwise convert to PostgreSQL array literal
+      elements = array.map { |el| format_pg_array_element(el) }
+      "{#{elements.join(',')}}"
+    end
+
+    def format_pg_array_element(value)
+      return "NULL" if value.nil?
+
+      str = convert(value).to_s
+
+      # Quote if contains special characters
+      if needs_quoting?(str)
+        "\"#{escape_pg_string(str)}\""
+      else
+        str
+      end
+    end
+
+    def needs_quoting?(str)
+      str.include?(",") ||
+        str.include?(" ") ||
+        str.include?('"') ||
+        str.include?("\\") ||
+        str.include?("{") ||
+        str.include?("}") ||
+        str.empty?
+    end
+
+    def escape_pg_string(str)
+      str.gsub('\\', '\\\\').gsub('"', '\\"')
+    end
+  end
+end

data/lib/rooq/query_validator.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Rooq
+  class QueryValidator
+    def initialize(tables)
+      @tables = tables.each_with_object({}) do |table, hash|
+        hash[table.name] = table
+      end
+    end
+
+    def validate_select(query)
+      errors = []
+
+      # Validate FROM table
+      if query.from_table
+        table_error = validate_table(query.from_table)
+        errors << table_error if table_error
+      end
+
+      # Validate selected fields
+      query.selected_fields.each do |field|
+        next unless field.is_a?(Field)
+
+        field_error = validate_field(field)
+        errors << field_error if field_error
+      end
+
+      # Validate conditions
+      if query.conditions
+        condition_errors = validate_condition(query.conditions)
+        errors.concat(condition_errors)
+      end
+
+      # Validate order specs
+      query.order_specs.each do |spec|
+        field_error = validate_field(spec.field)
+        errors << field_error if field_error
+      end
+
+      # Validate joins
+      query.joins.each do |join|
+        table_error = validate_table(join.table)
+        errors << table_error if table_error
+
+        condition_errors = validate_condition(join.condition)
+        errors.concat(condition_errors)
+      end
+
+      raise QueryValidationError.new(errors) unless errors.empty?
+
+      true
+    end
+
+    def validate_insert(query)
+      errors = []
+
+      table_error = validate_table(query.table)
+      errors << table_error if table_error
+
+      query.column_list.each do |field|
+        next unless field.is_a?(Field)
+
+        field_error = validate_field(field)
+        errors << field_error if field_error
+      end
+
+      raise QueryValidationError.new(errors) unless errors.empty?
+
+      true
+    end
+
+    def validate_update(query)
+      errors = []
+
+      table_error = validate_table(query.table)
+      errors << table_error if table_error
+
+      query.set_values.each_key do |field|
+        next unless field.is_a?(Field)
+
+        field_error = validate_field(field)
+        errors << field_error if field_error
+      end
+
+      if query.conditions
+        condition_errors = validate_condition(query.conditions)
+        errors.concat(condition_errors)
+      end
+
+      raise QueryValidationError.new(errors) unless errors.empty?
+
+      true
+    end
+
+    def validate_delete(query)
+      errors = []
+
+      table_error = validate_table(query.table)
+      errors << table_error if table_error
+
+      if query.conditions
+        condition_errors = validate_condition(query.conditions)
+        errors.concat(condition_errors)
+      end
+
+      raise QueryValidationError.new(errors) unless errors.empty?
+
+      true
+    end
+
+    private
+
+    def validate_table(table)
+      return nil unless table.is_a?(Table)
+      return nil if @tables.key?(table.name)
+
+      "Unknown table '#{table.name}'. Known tables: #{@tables.keys.join(', ')}"
+    end
+
+    def validate_field(field)
+      table = @tables[field.table_name]
+      return "Unknown table '#{field.table_name}' for field '#{field.name}'" unless table
+      return nil if table.fields.key?(field.name)
+
+      "Unknown field '#{field.name}' on table '#{field.table_name}'. Available: #{table.fields.keys.join(', ')}"
+    end
+
+    def validate_condition(condition)
+      case condition
+      when Condition
+        error = validate_field(condition.field)
+        error ? [error] : []
+      when CombinedCondition
+        condition.conditions.flat_map { |c| validate_condition(c) }
+      else
+        []
+      end
+    end
+  end
+
+  class QueryValidationError < Error
+    attr_reader :validation_errors
+
+    def initialize(errors)
+      @validation_errors = errors
+      super("Query validation failed:\n  - #{errors.join("\n  - ")}")
+    end
+  end
+
+  class ValidatingExecutor < Executor
+    def initialize(connection, tables, dialect: Dialect::PostgreSQL.new)
+      super(connection, dialect: dialect)
+      @validator = QueryValidator.new(tables)
+    end
+
+    def execute(query)
+      validate_query(query)
+      super
+    end
+
+    private
+
+    def validate_query(query)
+      case query
+      when DSL::SelectQuery
+        @validator.validate_select(query)
+      when DSL::InsertQuery
+        @validator.validate_insert(query)
+      when DSL::UpdateQuery
+        @validator.validate_update(query)
+      when DSL::DeleteQuery
+        @validator.validate_delete(query)
+      end
+    end
+  end
+end