elasticgraph-warehouse 1.0.3.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1c3e7a01b4bc1644e72c24ee57f20429918ecb3852a3bc9d6a6b304a7fb76349
+  data.tar.gz: e00d1206b3ab07a299160bbf21a1fb559ecdda4c315c949e22bae52c645a20ea
+SHA512:
+  metadata.gz: 7846c4170015d7dd8ccee7655a24855fe48ee52e5ebd30d1c0bebb59795e7e02d71a1af899db13c1d692ba0d6af8e2ce1a2ecab7b8f5870015a4cf5074e64085
+  data.tar.gz: 1eb9780eba947bc4cc5fa1a3fb588c52fd8bf0b4b11987ddae3a79f0b9c9f40595bb409a2c56f893d8990ef5547b98be419c6412024899578ce39158564e26d3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 - 2026 Block, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,132 @@
+# ElasticGraph::Warehouse
+
+An ElasticGraph extension that generates Data Warehouse table configurations from ElasticGraph schemas.
+
+This extension enables seamless integration with data warehouse systems like Apache Hive, AWS Athena,
+and similar SQL-based analytical platforms by automatically generating DDL and configuration files.
+
+## Dependency Diagram
+
+```mermaid
+graph LR;
+    classDef targetGemStyle fill:#FADBD8,stroke:#EC7063,color:#000,stroke-width:2px;
+    classDef otherEgGemStyle fill:#A9DFBF,stroke:#2ECC71,color:#000;
+    classDef externalGemStyle fill:#E0EFFF,stroke:#70A1D7,color:#2980B9;
+    elasticgraph-warehouse["elasticgraph-warehouse"];
+    class elasticgraph-warehouse targetGemStyle;
+    elasticgraph-support["elasticgraph-support"];
+    elasticgraph-warehouse --> elasticgraph-support;
+    class elasticgraph-support otherEgGemStyle;
+```
+
+## Usage
+
+First, add `elasticgraph-warehouse` to your `Gemfile`, alongside the other ElasticGraph gems:
+
+```diff
+diff --git a/Gemfile b/Gemfile
+index 4a5ef1e..5c16c2b 100644
+--- a/Gemfile
++++ b/Gemfile
+@@ -8,6 +8,7 @@ gem "elasticgraph-query_registry", *elasticgraph_details
+
+ # Can be elasticgraph-elasticsearch or elasticgraph-opensearch based on the datastore you want to use.
+ gem "elasticgraph-opensearch", *elasticgraph_details
++gem "elasticgraph-warehouse", *elasticgraph_details
+
+ gem "httpx", "~> 1.3"
+
+```
+
+Next, update your `Rakefile` so that `ElasticGraph::Warehouse::SchemaDefinition::APIExtension` is
+used as one of the `schema_definition_extension_modules`:
+
+```diff
+diff --git a/Rakefile b/Rakefile
+index 2943335..26633c3 100644
+--- a/Rakefile
++++ b/Rakefile
+@@ -1,5 +1,6 @@
+ project_root = File.expand_path(__dir__)
+
++require "elastic_graph/warehouse/schema_definition/api_extension"
+ require "elastic_graph/local/rake_tasks"
+ require "elastic_graph/query_registry/rake_tasks"
+ require "rspec/core/rake_task"
+@@ -12,6 +13,8 @@ ElasticGraph::Local::RakeTasks.new(
+   local_config_yaml: settings_file,
+   path_to_schema: "#{project_root}/config/schema.rb"
+ ) do |tasks|
++  tasks.schema_definition_extension_modules = [ElasticGraph::Warehouse::SchemaDefinition::APIExtension]
++
+   # Set this to true once you're beyond the prototyping stage.
+   tasks.enforce_json_schema_version = false
+
+```
+
+After running `bundle exec rake schema_artifacts:dump`, a `data_warehouse.yaml` file will be
+generated containing SQL `CREATE TABLE` statements for each indexed type.
+
+## Schema Definition Options
+
+### Custom Table Names
+
+By default, warehouse tables use the same name as the index. You can customize the table name
+using the `warehouse_table` method:
+
+```ruby
+# in config/schema/widget.rb
+
+ElasticGraph.define_schema do |schema|
+  schema.object_type "Widget" do |t|
+    t.field "id", "ID"
+    t.field "name", "String"
+
+    t.index "widgets" do |i|
+      i.warehouse_table "widget_records" # Customize the warehouse table name
+    end
+  end
+end
+```
+
+### Custom Scalar Types
+
+Built-in ElasticGraph scalar types are automatically mapped to appropriate warehouse column types.
+For custom scalar types, you must specify the warehouse column type:
+
+```ruby
+# in config/schema/money.rb
+
+ElasticGraph.define_schema do |schema|
+  schema.scalar_type "Money" do |t|
+    t.mapping type: "long"
+    t.json_schema type: "integer"
+    t.warehouse_column type: "BIGINT"
+  end
+end
+```
+
+## Type Mappings
+
+The extension automatically converts ElasticGraph types to warehouse column types:
+
+| ElasticGraph Type | Warehouse Type |
+|-------------------|----------------|
+| `Boolean`         | `BOOLEAN`      |
+| `Cursor`          | `STRING`       |
+| `Date`            | `DATE`         |
+| `DateTime`        | `TIMESTAMP`    |
+| `Float`           | `FLOAT`        |
+| `ID`              | `STRING`       |
+| `Int`             | `INT`          |
+| `JsonSafeLong`    | `BIGINT`       |
+| `LocalTime`       | `STRING`       |
+| `LongString`      | `BIGINT`       |
+| `String`          | `STRING`       |
+| `TimeZone`        | `STRING`       |
+| `Untyped`         | `STRING`       |
+
+Additionally:
+- List types become `ARRAY<type>` (e.g., `[String!]!` becomes `ARRAY<STRING>`)
+- Object types become `STRUCT<field1 type1, field2 type2, ...>`
+- Nested arrays are supported (e.g., `[[Int!]!]!` becomes `ARRAY<ARRAY<INT>>`)

data/lib/elastic_graph/warehouse/schema_definition/api_extension.rb

@@ -0,0 +1,72 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/warehouse/schema_definition/factory_extension"
+require "elastic_graph/warehouse/schema_definition/scalar_type_extension"
+require "elastic_graph/warehouse/schema_definition/enum_type_extension"
+require "elastic_graph/warehouse/schema_definition/object_interface_and_union_extension"
+
+module ElasticGraph
+  module Warehouse
+    # Namespace for all Warehouse schema definition support.
+    #
+    # {SchemaDefinition::APIExtension} is the primary entry point and should be used as a schema definition extension module.
+    module SchemaDefinition
+      # Module designed to be extended onto an {ElasticGraph::SchemaDefinition::API} instance
+      # to add Data Warehouse configuration generation capabilities.
+      #
+      # To use this module, pass it in `schema_definition_extension_modules` when defining your {ElasticGraph::Local::RakeTasks}.
+      #
+      # @example Define local rake tasks with this extension module
+      #   require "elastic_graph/warehouse/schema_definition/api_extension"
+      #
+      #   ElasticGraph::Local::RakeTasks.new(
+      #     local_config_yaml: "config/settings/local.yaml",
+      #     path_to_schema: "config/schema.rb"
+      #   ) do |tasks|
+      #     tasks.schema_definition_extension_modules = [
+      #       ElasticGraph::Warehouse::SchemaDefinition::APIExtension
+      #     ]
+      #   end
+      module APIExtension
+        # Maps built-in ElasticGraph scalar types to their warehouse column types.
+        COLUMN_TYPES_BY_BUILT_IN_SCALAR_TYPE = {
+          "Boolean" => "BOOLEAN",
+          "Cursor" => "STRING",
+          "Date" => "DATE",
+          "DateTime" => "TIMESTAMP",
+          "Float" => "FLOAT",
+          "ID" => "STRING",
+          "Int" => "INT",
+          "JsonSafeLong" => "BIGINT",
+          "LocalTime" => "STRING",
+          "LongString" => "BIGINT",
+          "String" => "STRING",
+          "TimeZone" => "STRING",
+          "Untyped" => "STRING"
+        }.freeze
+
+        # Extends the API with warehouse functionality when this module is extended.
+        #
+        # @param api [ElasticGraph::SchemaDefinition::API] the API instance to extend
+        # @return [void]
+        # @api private
+        def self.extended(api)
+          api.factory.extend FactoryExtension
+
+          api.on_built_in_types do |type|
+            case type
+            when ScalarTypeExtension
+              type.warehouse_column type: COLUMN_TYPES_BY_BUILT_IN_SCALAR_TYPE.fetch(type.name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse/schema_definition/enum_type_extension.rb

@@ -0,0 +1,23 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+module ElasticGraph
+  module Warehouse
+    module SchemaDefinition
+      # Extends {ElasticGraph::SchemaDefinition::SchemaElements::EnumType} to add warehouse column type conversion.
+      module EnumTypeExtension
+        # Returns the warehouse column type representation for this enum type.
+        #
+        # @return [String] the SQL type string "STRING"
+        def to_warehouse_column_type
+          "STRING"
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse/schema_definition/factory_extension.rb

@@ -0,0 +1,130 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/warehouse/schema_definition/enum_type_extension"
+require "elastic_graph/warehouse/schema_definition/index_extension"
+require "elastic_graph/warehouse/schema_definition/object_interface_and_union_extension"
+require "elastic_graph/warehouse/schema_definition/results_extension"
+require "elastic_graph/warehouse/schema_definition/scalar_type_extension"
+require "elastic_graph/warehouse/schema_definition/schema_artifact_manager_extension"
+
+module ElasticGraph
+  module Warehouse
+    module SchemaDefinition
+      # Extension module applied to `ElasticGraph::SchemaDefinition::Factory` to add warehouse field type support.
+      #
+      # @api private
+      module FactoryExtension
+        # Creates a new enum type with warehouse extensions.
+        #
+        # @param name [String] the name of the enum type
+        # @yield [ElasticGraph::SchemaDefinition::SchemaElements::EnumType] the newly created enum type
+        # @return [ElasticGraph::SchemaDefinition::SchemaElements::EnumType] the created enum type
+        def new_enum_type(name)
+          super(name) do |type|
+            type.extend EnumTypeExtension
+            # :nocov: -- currently all invocations have a block
+            yield type if block_given?
+            # :nocov:
+          end
+        end
+
+        # Creates a new index with warehouse extensions.
+        # Automatically creates a warehouse table with the same name as the index
+        # unless one is explicitly defined or the index is excluded from the warehouse.
+        #
+        # @param name [String] the name of the index
+        # @param settings [Hash] additional settings for the index
+        # @param type [Object] the type this index is for
+        # @yield [ElasticGraph::SchemaDefinition::Indexing::Index] the newly created index (optional)
+        # @return [ElasticGraph::SchemaDefinition::Indexing::Index] the created index
+        def new_index(name, settings, type, &block)
+          super(name, settings, type) do |index|
+            extended_index = index.extend IndexExtension # : ::ElasticGraph::SchemaDefinition::Indexing::Index & IndexExtension
+            extended_index.warehouse_table(name)
+            block&.call(extended_index)
+          end
+        end
+
+        # Creates a new interface type with warehouse extensions.
+        #
+        # @param name [String] the name of the interface type
+        # @yield [ElasticGraph::SchemaDefinition::SchemaElements::InterfaceType] the newly created interface type
+        # @return [ElasticGraph::SchemaDefinition::SchemaElements::InterfaceType] the created interface type
+        def new_interface_type(name)
+          super(name) do |type|
+            type.extend ObjectInterfaceAndUnionExtension
+            # :nocov: -- currently all invocations have a block
+            yield type if block_given?
+            # :nocov:
+          end
+        end
+
+        # Creates a new object type with warehouse extensions.
+        #
+        # @param name [String] the name of the object type
+        # @yield [ElasticGraph::SchemaDefinition::SchemaElements::ObjectType] the newly created object type (optional)
+        # @return [ElasticGraph::SchemaDefinition::SchemaElements::ObjectType] the created object type
+        def new_object_type(name)
+          super(name) do |type|
+            type.extend ObjectInterfaceAndUnionExtension
+            # :nocov: -- currently all invocations have a block
+            yield type if block_given?
+            # :nocov:
+          end
+        end
+
+        # Creates a new scalar type with warehouse extensions.
+        #
+        # @param name [String] the name of the scalar type
+        # @yield [ElasticGraph::SchemaDefinition::SchemaElements::ScalarType] the newly created scalar type
+        # @return [ElasticGraph::SchemaDefinition::SchemaElements::ScalarType] the created scalar type
+        def new_scalar_type(name)
+          super(name) do |type|
+            type.extend ScalarTypeExtension
+            # :nocov: -- currently all invocations have a block
+            yield type if block_given?
+            # :nocov:
+          end
+        end
+
+        # Creates a new union type with warehouse extensions.
+        #
+        # @param name [String] the name of the union type
+        # @yield [ElasticGraph::SchemaDefinition::SchemaElements::UnionType] the newly created union type
+        # @return [ElasticGraph::SchemaDefinition::SchemaElements::UnionType] the created union type
+        def new_union_type(name)
+          super(name) do |type|
+            type.extend ObjectInterfaceAndUnionExtension
+            # :nocov: -- currently all invocations have a block
+            yield type if block_given?
+            # :nocov:
+          end
+        end
+
+        # Creates a new Results instance with warehouse extensions.
+        #
+        # @return [ElasticGraph::SchemaDefinition::Results] the created results instance
+        def new_results
+          super.tap do |results|
+            results.extend ResultsExtension
+          end
+        end
+
+        # Creates a new SchemaArtifactManager instance with warehouse extensions.
+        #
+        # @return [ElasticGraph::SchemaDefinition::SchemaArtifactManager] the created artifact manager
+        def new_schema_artifact_manager(...)
+          super.tap do |manager|
+            manager.extend SchemaArtifactManagerExtension
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse/schema_definition/field_type_converter.rb

@@ -0,0 +1,34 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+module ElasticGraph
+  module Warehouse
+    module SchemaDefinition
+      # Converts ElasticGraph field types to warehouse column types.
+      class FieldTypeConverter
+        # Converts a field type to a warehouse column type string.
+        #
+        # Handles both scalar and list types, unwrapping nullability and delegating to
+        # the resolved type's `to_warehouse_column_type` method. Supports
+        # nested arrays like `[[String!]]` which become `ARRAY<ARRAY<STRING>>`.
+        #
+        # @param field_type [Object] the field type to convert
+        # @return [String] the warehouse column type (e.g., "STRING", "ARRAY<INT>", "ARRAY<ARRAY<DOUBLE>>")
+        def self.convert(field_type)
+          unwrapped_type = field_type.unwrap_non_null
+
+          if unwrapped_type.list?
+            "ARRAY<#{convert(unwrapped_type.unwrap_list)}>"
+          else
+            unwrapped_type.resolved.to_warehouse_column_type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse/schema_definition/index_extension.rb

@@ -0,0 +1,69 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/warehouse/schema_definition/warehouse_table"
+
+module ElasticGraph
+  module Warehouse
+    module SchemaDefinition
+      # Extends {ElasticGraph::SchemaDefinition::Indexing::Index} to add warehouse table definition support.
+      module IndexExtension
+        # Returns the warehouse table definition for this index, if one has been defined via {#warehouse_table}.
+        #
+        # @return [WarehouseTable, nil] the warehouse table definition, or `nil` if none has been defined
+        # @dynamic warehouse_table_def
+        attr_reader :warehouse_table_def
+
+        # Defines a warehouse table for this index with a custom name.
+        #
+        # By default, a warehouse table is automatically created with the same name as the index.
+        # Use this method only when you need a different table name than the index name.
+        # To exclude an index from the warehouse entirely, use {#exclude_from_warehouse} instead.
+        #
+        # @param name [String] name of the warehouse table
+        # @return [void]
+        #
+        # @example Override the default warehouse table name
+        #   ElasticGraph.define_schema do |schema|
+        #     schema.object_type "Product" do |t|
+        #       t.field "id", "ID"
+        #       t.field "name", "String"
+        #
+        #       t.index "products" do |i|
+        #         # Override to use a different table name than "products"
+        #         i.warehouse_table "store_products"
+        #       end
+        #     end
+        #   end
+        def warehouse_table(name)
+          @warehouse_table_def = WarehouseTable.new(name: name, index: self)
+        end
+
+        # Excludes this index from the data warehouse configuration.
+        # This is useful when you have an index but don't want it to be included
+        # in the data warehouse.
+        #
+        # @return [void]
+        #
+        # @example Exclude an internal/test index from the warehouse
+        #   ElasticGraph.define_schema do |schema|
+        #     schema.object_type "InternalMetrics" do |t|
+        #       t.field "id", "ID"
+        #
+        #       t.index "internal_metrics" do |i|
+        #         i.exclude_from_warehouse # This index won't be in the data warehouse
+        #       end
+        #     end
+        #   end
+        def exclude_from_warehouse
+          @warehouse_table_def = nil
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse/schema_definition/object_interface_and_union_extension.rb

@@ -0,0 +1,36 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/warehouse/schema_definition/field_type_converter"
+
+module ElasticGraph
+  module Warehouse
+    module SchemaDefinition
+      # Extends {ElasticGraph::SchemaDefinition::SchemaElements::ObjectType},
+      # {ElasticGraph::SchemaDefinition::SchemaElements::InterfaceType}, and
+      # {ElasticGraph::SchemaDefinition::SchemaElements::UnionType} to add warehouse column type definition support.
+      module ObjectInterfaceAndUnionExtension
+        # Returns the warehouse column type representation for this object, interface, or union type.
+        #
+        # @return [String] a STRUCT SQL type containing all subfields
+        # @note For union types, the STRUCT includes all fields from all subtypes, following the same pattern used
+        #   in the datastore mapping (see {ElasticGraph::SchemaDefinition::Indexing::FieldType::Union#to_mapping}).
+        def to_warehouse_column_type
+          subfields = indexing_fields_by_name_in_index.values.filter_map(&:to_indexing_field)
+
+          struct_field_expressions = subfields.map do |subfield|
+            warehouse_type = FieldTypeConverter.convert(subfield.type)
+            "#{subfield.name_in_index} #{warehouse_type}"
+          end.join(", ")
+
+          "STRUCT<#{struct_field_expressions}>"
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse/schema_definition/results_extension.rb

@@ -0,0 +1,41 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/warehouse/schema_definition/warehouse_table"
+
+module ElasticGraph
+  module Warehouse
+    module SchemaDefinition
+      # Extension module for {ElasticGraph::SchemaDefinition::Results} that adds warehouse configuration support.
+      #
+      # @private
+      module ResultsExtension
+        # Returns the warehouse configuration generated from the schema definition.
+        #
+        # @return [Hash<String, Hash>] a hash mapping table names to their configuration
+        def warehouse_config
+          @warehouse_config ||= generate_warehouse_config
+        end
+
+        private
+
+        # Generates warehouse configuration from indices that have warehouse table definitions.
+        #
+        # @return [Hash<String, Hash>] a hash mapping table names to their configuration
+        def generate_warehouse_config
+          tables = all_types
+            .filter_map { |type| (_ = type).index_def if type.respond_to?(:index_def) }
+            .filter_map(&:warehouse_table_def)
+            .sort_by(&:name)
+
+          {"tables" => tables.to_h { |table| [table.name, table.to_config] }}
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse/schema_definition/scalar_type_extension.rb

@@ -0,0 +1,41 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/errors"
+
+module ElasticGraph
+  module Warehouse
+    module SchemaDefinition
+      # Extends {ElasticGraph::SchemaDefinition::SchemaElements::ScalarType} to add warehouse column type conversion.
+      module ScalarTypeExtension
+        # Warehouse column type configured on this scalar type.
+        # @dynamic warehouse_column_type
+        attr_reader :warehouse_column_type
+
+        # Configures warehouse column type for this scalar type.
+        #
+        # @param type [String] the warehouse column type (e.g., "TIMESTAMP", "BINARY")
+        # @return [String] the configured warehouse column type
+        def warehouse_column(type:)
+          @warehouse_column_type = type
+        end
+
+        # Returns the warehouse column type representation for this scalar type.
+        #
+        # @return [String] the SQL type string (e.g., "INT", "DOUBLE", "BOOLEAN", "STRING")
+        # @raise [RuntimeError] if warehouse_column_type has not been configured
+        # @note Built-in ElasticGraph scalar types are automatically configured with appropriate warehouse column types.
+        #   Custom scalar types must explicitly call `warehouse_column` to specify their warehouse type.
+        def to_warehouse_column_type
+          warehouse_column_type || raise(Errors::SchemaError, "Warehouse column type not configured for scalar type `#{name}`. " \
+            'To proceed, call `warehouse_column type: "TYPE"` on the scalar type definition.')
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse/schema_definition/schema_artifact_manager_extension.rb

@@ -0,0 +1,47 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/warehouse"
+
+module ElasticGraph
+  module Warehouse
+    module SchemaDefinition
+      # Extension module for {ElasticGraph::SchemaDefinition::SchemaArtifactManager} that adds
+      # warehouse artifact generation support.
+      #
+      # @private
+      module SchemaArtifactManagerExtension
+        private
+
+        # Overrides the base `artifacts_from_schema_def` method to add warehouse artifacts.
+        #
+        # This method is called when computing the list of schema artifacts. It calls super
+        # to get the base artifacts, then appends the warehouse artifact if any warehouse
+        # tables are defined.
+        #
+        # @return [Array<ElasticGraph::SchemaDefinition::SchemaArtifact>] the list of schema artifacts
+        def artifacts_from_schema_def
+          base_artifacts = super
+          results = schema_definition_results # : ElasticGraph::SchemaDefinition::Results & ResultsExtension
+          warehouse_config = results.warehouse_config
+
+          # Only add the artifact if there are warehouse tables defined.
+          return base_artifacts if warehouse_config["tables"].empty?
+
+          warehouse_artifact = new_yaml_artifact(
+            DATA_WAREHOUSE_FILE,
+            warehouse_config,
+            extra_comment_lines: ["This file contains Data Warehouse configuration generated from the ElasticGraph schema."]
+          )
+
+          base_artifacts + [warehouse_artifact]
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse/schema_definition/warehouse_table.rb

@@ -0,0 +1,53 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+require "elastic_graph/warehouse/schema_definition/field_type_converter"
+
+module ElasticGraph
+  module Warehouse
+    module SchemaDefinition
+      # Represents a warehouse table configuration.
+      class WarehouseTable < ::Data.define(:name, :index)
+        # Converts the warehouse table to a configuration hash.
+        #
+        # @return [Hash] configuration hash with table_schema
+        def to_config
+          {
+            "table_schema" => table_schema
+          }
+        end
+
+        private
+
+        # Generates the SQL CREATE TABLE statement for this warehouse table.
+        #
+        # @return [String] SQL CREATE TABLE statement with all fields
+        def table_schema
+          fields = index.indexed_type
+            .indexing_fields_by_name_in_index
+            .values
+            .filter_map(&:to_indexing_field)
+            .map { |field| table_field(field) }
+            .join(",\n  ")
+
+          <<~SQL.strip
+            CREATE TABLE IF NOT EXISTS #{name} (
+              #{fields}
+            )
+          SQL
+        end
+
+        def table_field(field)
+          field_name = field.name_in_index
+          warehouse_type = FieldTypeConverter.convert(field.type)
+          "#{field_name} #{warehouse_type}"
+        end
+      end
+    end
+  end
+end

data/lib/elastic_graph/warehouse.rb

@@ -0,0 +1,30 @@
+# Copyright 2024 - 2026 Block, Inc.
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+#
+# frozen_string_literal: true
+
+module ElasticGraph
+  # Warehouse extension: adds Data Warehouse config generation to ElasticGraph.
+  #
+  # This gem follows the same extension pattern as elasticgraph-apollo, using factory extensions
+  # to add warehouse capabilities to schema elements.
+  #
+  # @example Using the warehouse extension
+  #   require "elastic_graph/warehouse/schema_definition/api_extension"
+  #
+  #   ElasticGraph::Local::RakeTasks.new(
+  #     local_config_yaml: "config/settings/local.yaml",
+  #     path_to_schema: "config/schema.rb"
+  #   ) do |tasks|
+  #     tasks.schema_definition_extension_modules = [
+  #       ElasticGraph::Warehouse::SchemaDefinition::APIExtension
+  #     ]
+  #   end
+  module Warehouse
+    # The name of the generated data warehouse configuration file.
+    DATA_WAREHOUSE_FILE = "data_warehouse.yaml"
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: elasticgraph-warehouse
+version: !ruby/object:Gem::Version
+  version: 1.0.3.rc1
+platform: ruby
+authors:
+- Josh Wilson
+- Myron Marston
+- Block Engineering
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: elasticgraph-schema_definition
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+- !ruby/object:Gem::Dependency
+  name: elasticgraph-support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.3.rc1
+email:
+- joshuaw@squareup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/elastic_graph/warehouse.rb
+- lib/elastic_graph/warehouse/schema_definition/api_extension.rb
+- lib/elastic_graph/warehouse/schema_definition/enum_type_extension.rb
+- lib/elastic_graph/warehouse/schema_definition/factory_extension.rb
+- lib/elastic_graph/warehouse/schema_definition/field_type_converter.rb
+- lib/elastic_graph/warehouse/schema_definition/index_extension.rb
+- lib/elastic_graph/warehouse/schema_definition/object_interface_and_union_extension.rb
+- lib/elastic_graph/warehouse/schema_definition/results_extension.rb
+- lib/elastic_graph/warehouse/schema_definition/scalar_type_extension.rb
+- lib/elastic_graph/warehouse/schema_definition/schema_artifact_manager_extension.rb
+- lib/elastic_graph/warehouse/schema_definition/warehouse_table.rb
+homepage: https://block.github.io/elasticgraph/
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/block/elasticgraph/issues
+  changelog_uri: https://github.com/block/elasticgraph/releases/tag/v1.0.3.rc1
+  documentation_uri: https://block.github.io/elasticgraph/api-docs/v1.0.3.rc1/
+  homepage_uri: https://block.github.io/elasticgraph/
+  source_code_uri: https://github.com/block/elasticgraph/tree/v1.0.3.rc1/elasticgraph-warehouse
+  gem_category: extension
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Extends ElasticGraph to support ingestion into a data warehouse.
+test_files: []