exwiw 0.8.0 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9644b63d339ba01e55e57dd12274ea89af28eef67fda6bdb1201202d52e0f61
-  data.tar.gz: 40ce93cb0342d35d684119fb8f0c520f05b46fbcb8f486ceed2f1c8b9c8c354c
+  metadata.gz: eb6879b8efb94ef9a9a0bd37df32962257106df9eec4c3fc9de844a12c6360cd
+  data.tar.gz: b43b0bfde090111d7ce23083db7471f15974292ddb5886da682de9bc443febfa
 SHA512:
-  metadata.gz: c5cb48eb2c6757768621aaab607cf9bbe90de06f169b672be9f188a12d21f104a6c34e77c101bd0b06b50c4448422906772c56c205bb9f30e4dce14baafb664c
-  data.tar.gz: 45ec7c49d36c2316238d42ff13055d0183f11151579e20d7f15c4eab05ed40a34d2d3144737d1eaa38c4e2cc2c2abecf45c9eb77276f38c5a4aa38355f5ed68b
+  metadata.gz: e8cca59b376a369b9253d1482f3ee64ae8c542b00c1c3eddb192d273efe0e3c969e3aec1770f087977efe6b75fa52f375538e286d31a87d7f87a197739a4eeaf
+  data.tar.gz: 78a3ece09cd6ec9ecb6fd7b0a2f166bc41d51720ea36935ca4cd974bf766008f11688f0e0dc7bbd8a63ce29f4719806e1a4705b0390850a857a192fcfaa56976

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.8.2] - 2026-06-24
+
+### Added
+
+- **Multi-referencer reverse scoping (`reverse_scope`).** Reverse / "referenced_by" extraction previously narrowed only a table referenced by *exactly one* constrained child; a table referenced by two or more (most importantly a **global-identity table** like `users`, which carries no scope/tenant column and has no `belongs_to` of its own, yet many scoped tables point *at* it) fell back to dumping every row — dragging in every tenant's identities. A table can now opt into **multi-referencer** reverse scoping with a user-owned `reverse_scope: { via: [{ table, column }, …] }` key listing the referencers whose own (already scoped) extraction queries are `UNION`'d into the id set it is constrained to (`pk IN (SELECT ref1.col1 FROM ref1 <scope> UNION SELECT ref2.col2 FROM ref2 <scope> …)`). Each arm reuses that referencer's own scope, so a per-tenant run keeps only that tenant's ids; the named `column` is explicit, so a non-default foreign key (or a column with no declared `belongs_to`) is honored; NULLs are excluded per arm. Only **scoped** referencers belong in `via` — an unconstrained arm (e.g. a `scope_exempt` referencer) would union every row back, so it is skipped with a warning rather than silently widening the dump, and an unknown table is likewise skipped; if no arm survives, the table stays unscopable (so scope-column mode's `validate_scope!` still aborts rather than dumping it in full). Tables that `belongs_to` the reverse-scoped table tighten automatically through the existing cascade and need no config. `reverse_scope` is never emitted by `schema:generate` and is preserved across regeneration like `scope_exempt`/`scope_column`. SQL adapters only. See the [README](README.md#reverse-scope-for-multi-referencer-tables-reverse_scope).
+
+## [0.8.1] - 2026-06-24
+
+### Fixed
+
+- **`schema:generate` skips a `belongs_to` whose target is not an ActiveRecord model instead of crashing.** A `belongs_to` can point at a non-ActiveRecord class — most commonly an ActiveHash/ActiveYaml master (`belongs_to :equipment, class_name: "SomeActiveYamlModel"`). active_hash registers these as ordinary `belongs_to` reflections, but the target class has no database table, so resolving its `table_name` raised and aborted generation. Such a relation is not a DB edge exwiw can join or extract across, so it is now dropped from the generated belongs_tos; the underlying foreign-key column is still emitted as a plain column. A bare `belongs_to` to a plain non-AR class — which makes ActiveRecord raise while resolving the target — is treated the same way. Polymorphic associations are unaffected.
+
 ## [0.8.0] - 2026-06-24
 
 ### Added

data/README.md

@@ -579,6 +579,49 @@ ActiveStorage is handled automatically — no ActiveStorage-specific configurati
   `active_storage_variant_records` also references blobs, but since it has no path of its own to the dump target it doesn't constrain anything and is ignored as a referencer — blobs stays narrowed to the attachment-referenced ids. (A parent referenced by *multiple* constrained children currently falls back to dumping all of its rows.)
 - **`active_storage_variant_records`** holds derivative variant-tracking rows that ActiveStorage regenerates lazily, and it too has no path to the dump target — left alone it would land in the "no relation → dump all" branch and, worse, its `blob_id` could point at blobs outside the narrowed set above (a foreign-key violation on import). `exwiw:schema:generate` therefore emits it with **`ignore: true`** (and drops it from the attachments `record` polymorphic expansion so nothing carries a dangling reference to it), so its data is skipped while the DDL is still written. Remove `ignore` from the generated config if you really need to export it.
 
+### Reverse scope for multi-referencer tables (`reverse_scope`)
+
+The automatic reverse extraction above narrows a table referenced by **exactly one** constrained child. A table referenced by **two or more** constrained children falls back to dumping every row — fine for `active_storage_blobs`, but a problem for a **global-identity table** such as `users`: it carries no scope/tenant column and has no `belongs_to` of its own, yet dozens of scoped tables point *at* it. Dumping it (and everything that hangs off it) in full pulls in every tenant's identities.
+
+`reverse_scope` opts such a table into **multi-referencer** reverse scoping: you enumerate the referencers whose own (already scoped) extraction queries should be `UNION`'d into the id set the table is constrained to. It is a user-owned key (never emitted by `schema:generate`, preserved across regeneration like `scope_exempt`/`scope_column`):
+
+```json
+{
+  "name": "users",
+  "primary_key": "id",
+  "reverse_scope": {
+    "via": [
+      { "table": "customers", "column": "user_id" },
+      { "table": "staff", "column": "user_id" },
+      { "table": "business_entity_customers", "column": "kantan_yoyaku_user_id" }
+    ]
+  },
+  "columns": [{ "name": "id" }, { "name": "name" }]
+}
+```
+
+produces (each arm reuses that referencer's own scope, so a per-tenant run keeps only that tenant's ids):
+
+```sql
+SELECT users.* FROM users
+WHERE users.id IN (
+  SELECT customers.user_id FROM customers WHERE <customers' scope> AND customers.user_id IS NOT NULL
+  UNION
+  SELECT staff.user_id FROM staff WHERE <staff' scope> AND staff.user_id IS NOT NULL
+  UNION
+  SELECT business_entity_customers.kantan_yoyaku_user_id FROM business_entity_customers
+    WHERE <…' scope> AND business_entity_customers.kantan_yoyaku_user_id IS NOT NULL
+)
+```
+
+Notes:
+
+- **`column` is explicit**, so a *non-default* foreign key (e.g. `kantan_yoyaku_user_id`, or `organization_admins.id` which itself references `users.id`) is honored, and even a column with no declared `belongs_to` edge can be enumerated.
+- **Only scoped referencers belong in `via`.** Each arm's query must come out constrained; an unconstrained referencer (e.g. a `scope_exempt` table, or one with no path to a scope) would project *every* id and union the whole table back — so such an arm is **skipped with a warning** rather than silently widening the dump. An unknown table is likewise skipped with a warning. If no arm survives, the table stays unscopable and (in [scope-column mode](#scope-column-mode)) the run aborts via `validate_scope!`.
+- **NULLs are excluded** per arm (`IS NOT NULL`).
+- **Satellites need no config.** A table that `belongs_to` the reverse-scoped table (e.g. `end_users.id → users.id`, or `identities.user_id → users.id`) tightens to the kept ids automatically through the normal cascade — only the reverse-scoped table itself declares `reverse_scope`.
+- Works in both single-target and scope-column mode. Polymorphic foreign keys are not eligible as anchors (the named `column` is always a concrete column).
+
 ### Rails-managed tables (special `type` values)
 
 Some tables are owned by Rails itself rather than the application — they have no ActiveRecord model and Rails reserves the right to evolve their column shape between versions (e.g. `schema_migrations`, `ar_internal_metadata`). exwiw treats them as a distinct category via the `type` field on a table config:

data/lib/exwiw/adapter/mysql_adapter.rb

@@ -280,6 +280,8 @@ module Exwiw
           end
         elsif where_clause.operator == :in_subquery
           "#{key} IN (#{compile_subquery(where_clause.value)})"
+        elsif where_clause.operator == :not_null
+          "#{key} IS NOT NULL"
         else
           raise "Unsupported operator: #{where_clause.operator}"
         end
@@ -290,6 +292,12 @@ module Exwiw
         # extraction query, projected to a foreign key); compile it as-is.
         return compile_ast(subquery.query) if subquery.is_a?(Exwiw::QueryAst::SelectSubquery)
 
+        # A UnionSubquery wraps several such Selects; UNION their compiled forms
+        # into a single id set.
+        if subquery.is_a?(Exwiw::QueryAst::UnionSubquery)
+          return subquery.queries.map { |q| compile_ast(q) }.join(' UNION ')
+        end
+
         inner_values = subquery.where_values.map { |v| escape_value(v) }
         "SELECT #{subquery.table_name}.#{subquery.select_column} " \
           "FROM #{subquery.table_name} " \

data/lib/exwiw/adapter/postgresql_adapter.rb

@@ -364,6 +364,8 @@ module Exwiw
           cast_to = subquery_cast_to(where_clause.value, table_name, where_clause.column_name)
           outer_key = cast_to ? "#{key}::#{cast_to}" : key
           "#{outer_key} IN (#{subquery_sql})"
+        elsif where_clause.operator == :not_null
+          "#{key} IS NOT NULL"
         else
           raise "Unsupported operator: #{where_clause.operator}"
         end
@@ -376,6 +378,15 @@ module Exwiw
           return compile_ast(subquery.query, select_cast_to: cast_to)
         end
 
+        # A UnionSubquery wraps several projected Selects; UNION their compiled
+        # forms. cast_to is the union-wide decision (see union_cast_to): when any
+        # arm's column type would clash with the outer column or another arm,
+        # every arm's projected column and the outer key are cast to text so the
+        # UNION and the enclosing IN comparison resolve to one type.
+        if subquery.is_a?(Exwiw::QueryAst::UnionSubquery)
+          return subquery.queries.map { |q| compile_ast(q, select_cast_to: cast_to) }.join(' UNION ')
+        end
+
         inner_values = subquery.where_values.map { |v| escape_value(v) }
         select_expr = "#{subquery.table_name}.#{subquery.select_column}"
         select_expr = "#{select_expr}::#{cast_to}" if cast_to
@@ -400,6 +411,11 @@ module Exwiw
       private def subquery_cast_to(subquery, outer_table, outer_column)
         return nil if outer_table.nil? || outer_column.nil?
 
+        # A UNION's arms (and the enclosing IN comparison) must all resolve to
+        # one type, so the cast decision must weigh every arm — not just one, as
+        # a flat Subquery would.
+        return union_cast_to(subquery, outer_table, outer_column) if subquery.is_a?(Exwiw::QueryAst::UnionSubquery)
+
         inner_table, inner_column = subquery_select_target(subquery)
         return nil if inner_table.nil?
 
@@ -408,6 +424,23 @@ module Exwiw
         types_need_cast?(outer_type, inner_type) ? 'text' : nil
       end
 
+      # Postgres rejects a UNION (or an `IN`) that mixes incompatible types
+      # (e.g. uuid and varchar). Examining only the first arm is not enough: a
+      # heterogeneous later arm would go uncast and break at execution. So
+      # consider the outer column together with every arm's projected column and,
+      # if ANY pair needs reconciliation, cast them all to text.
+      private def union_cast_to(union, outer_table, outer_column)
+        types = [column_pg_type(outer_table, outer_column)]
+        union.queries.each do |q|
+          col = q.columns.first
+          types << column_pg_type(q.from_table_name, col.name) if col
+        end
+        types.compact!
+
+        needs_cast = types.combination(2).any? { |a, b| types_need_cast?(a, b) }
+        needs_cast ? 'text' : nil
+      end
+
       private def escape_value(value)
         case value
         when nil

data/lib/exwiw/adapter/sqlite_adapter.rb

@@ -249,6 +249,8 @@ module Exwiw
           end
         elsif where_clause.operator == :in_subquery
           "#{key} IN (#{compile_subquery(where_clause.value)})"
+        elsif where_clause.operator == :not_null
+          "#{key} IS NOT NULL"
         else
           raise "Unsupported operator: #{where_clause.operator}"
         end
@@ -259,6 +261,12 @@ module Exwiw
         # extraction query, projected to a foreign key); compile it as-is.
         return compile_ast(subquery.query) if subquery.is_a?(Exwiw::QueryAst::SelectSubquery)
 
+        # A UnionSubquery wraps several such Selects; UNION their compiled forms
+        # into a single id set.
+        if subquery.is_a?(Exwiw::QueryAst::UnionSubquery)
+          return subquery.queries.map { |q| compile_ast(q) }.join(' UNION ')
+        end
+
         inner_values = subquery.where_values.map { |v| escape_value(v) }
         "SELECT #{subquery.table_name}.#{subquery.select_column} " \
           "FROM #{subquery.table_name} " \

data/lib/exwiw/query_ast.rb

@@ -41,7 +41,7 @@ module Exwiw
         {
           column_name: column_name,
           operator: operator,
-          value: value.is_a?(Subquery) || value.is_a?(SelectSubquery) ? value.to_h : value,
+          value: value.is_a?(Subquery) || value.is_a?(SelectSubquery) || value.is_a?(UnionSubquery) ? value.to_h : value,
         }
       end
     end
@@ -83,6 +83,25 @@ module Exwiw
       end
     end
 
+    # A subquery that UNIONs several single-column `Select`s into one id set.
+    # Used by *multi-referencer* reverse / "referenced_by" extraction
+    # (TableConfig#reverse_scope): a parent table referenced by many scoped
+    # tables is constrained to the union of every referencer's projected foreign
+    # key, rather than falling back to dumping every row:
+    #
+    #   <parent>.<pk> IN (
+    #     SELECT <ref1>.<col1> FROM <ref1> WHERE <ref1 scope> AND <col1> IS NOT NULL
+    #     UNION SELECT <ref2>.<col2> FROM <ref2> WHERE <ref2 scope> AND <col2> IS NOT NULL
+    #   )
+    #
+    # Each `queries` element is a `Select` already projected to the foreign-key
+    # column that points at the parent (with a NULL-excluding filter).
+    UnionSubquery = Struct.new(:queries, keyword_init: true) do
+      def to_h
+        { union: queries.map(&:to_h) }
+      end
+    end
+
     module ColumnValue
       Base = Struct.new(:name, :value, keyword_init: true)
       Plain = Class.new(Base)

data/lib/exwiw/query_ast_builder.rb

@@ -168,6 +168,15 @@ module Exwiw
     # such (single, unambiguous) referencer, leaving the caller to fall back to
     # the dump-all behavior.
     private def build_referenced_by_clause(table)
+      # Opt-in multi-referencer reverse scope (TableConfig#reverse_scope): when
+      # the schema author has enumerated the referencers explicitly, constrain
+      # the table to the UNION of those referencers' scoped queries instead of
+      # the single-referencer auto-detection below (which bails to a full dump
+      # once two or more tables reference the table).
+      if table.reverse_scope && table.reverse_scope.via.any?
+        return build_reverse_scope_via_clause(table)
+      end
+
       candidates = table_by_name.each_value.filter_map do |other|
         next if other.name == table.name
 
@@ -219,6 +228,64 @@ module Exwiw
       )
     end
 
+    # Multi-referencer reverse scope (TableConfig#reverse_scope). Builds a
+    # `pk IN (SELECT ref1.col1 FROM ref1 <scope> UNION SELECT ref2.col2 ...)`
+    # clause for a global-identity table referenced by many scoped tables. Each
+    # `via` arm reuses the referencer's own (already-scoped) extraction query —
+    # so a per-tenant run keeps only that tenant's ids — projected down to the
+    # foreign-key column that points at this table, with NULLs excluded.
+    #
+    # An arm whose referencer is unknown or comes out unconstrained is skipped
+    # with a warning rather than included: an unconstrained arm would project
+    # every row's id and union the whole table back, silently defeating the
+    # prune. Returns nil when no arm survives, leaving the caller to fall back to
+    # the dump-all behavior (which validate_scope! then rejects in scope mode).
+    private def build_reverse_scope_via_clause(table)
+      arms = table.reverse_scope.via.filter_map do |via|
+        referencer = table_by_name[via.table]
+        if referencer.nil?
+          @logger.warn("  #{table.name}.reverse_scope references unknown table '#{via.table}'; skipping arm.")
+          next
+        end
+
+        # Build the referencer's own scoped extraction query. allow_reverse /
+        # allow_forward are disabled to bound recursion exactly as the
+        # single-referencer path does (a referencer scopable only via its own
+        # reverse/forward rescue would loop or, worse, recurse back into this
+        # table).
+        ref_query = self.class.run(referencer.name, table_by_name, dump_target, @logger, allow_reverse: false, allow_forward: false)
+
+        unless ref_query.where_clauses.any? || ref_query.join_clauses.any?
+          @logger.warn(
+            "  #{table.name}.reverse_scope arm '#{via.table}.#{via.column}' is not scoped; " \
+            "skipping it (an unconstrained arm would union every row back). " \
+            "Make '#{via.table}' scopable or remove it from reverse_scope.via."
+          )
+          next
+        end
+
+        # Project the referencer's query to the foreign-key column that points
+        # at this table, excluding NULLs. Force a plain column so any masking /
+        # raw_sql configured on that column does not corrupt the id comparison.
+        fk_column = TableColumn.from_symbol_keys(name: via.column)
+        projected = QueryAst::Select.new
+        projected.from(ref_query.from_table_name)
+        projected.select([fk_column])
+        ref_query.join_clauses.each { |j| projected.join(j) }
+        ref_query.where_clauses.each { |w| projected.where(w) }
+        projected.where(QueryAst::WhereClause.new(column_name: via.column, operator: :not_null))
+        projected
+      end
+
+      return nil if arms.empty?
+
+      QueryAst::WhereClause.new(
+        column_name: table.primary_key,
+        operator: :in_subquery,
+        value: QueryAst::UnionSubquery.new(queries: arms)
+      )
+    end
+
     # Scope-column mode. Builds a `fk IN (SELECT parent.pk FROM <parent
     # extraction query>)` clause for a table whose belongs_to parent is itself
     # scopable but carries no scope column of its own — so find_path_to_scoped

data/lib/exwiw/reverse_scope.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Exwiw
+  # One referencer arm of a {ReverseScope}: the referencing table and the column
+  # on it that points at the reverse-scoped table's primary key.
+  #
+  # `column` is given explicitly so a *non-default* foreign key (e.g.
+  # `business_entity_customers.kantan_yoyaku_user_id`, or `organization_admins.id`
+  # which itself references `users.id`) can be projected — and even a column with
+  # no declared `belongs_to` edge can be enumerated.
+  class ReverseScopeVia
+    include Serdes
+
+    attribute :table, String
+    attribute :column, String
+  end
+
+  # Opt-in configuration for *multi-referencer* reverse scoping
+  # (see {QueryAstBuilder#build_referenced_by_clause}).
+  #
+  # A global-identity table such as `users` carries no scope/tenant column and
+  # has no `belongs_to` path of its own to the dump target; many tenant-owned
+  # tables instead point *at* it. The automatic single-referencer reverse
+  # extraction only narrows a table referenced by exactly one constrained child
+  # — with two or more referencers it falls back to a full dump. `reverse_scope`
+  # lets the schema author enumerate the referencers whose own (already-scoped)
+  # extraction queries should be UNION'd into the id set this table is
+  # constrained to:
+  #
+  #   <table>.<pk> IN (
+  #     SELECT <ref1>.<col1> FROM <ref1> <ref1 scope> WHERE <col1> IS NOT NULL
+  #     UNION SELECT <ref2>.<col2> FROM <ref2> <ref2 scope> WHERE <col2> IS NOT NULL
+  #     UNION ...
+  #   )
+  #
+  # It is deliberately explicit — never inferred or emitted by the schema
+  # generators, and preserved across regeneration like the other user-owned
+  # config (see {TableConfig#merge}). Only referencers that are themselves scoped
+  # belong in `via`: an unconstrained referencer would project every row's id and
+  # union the whole table back, defeating the prune (such an arm is skipped with
+  # a warning rather than silently widening the dump).
+  class ReverseScope
+    include Serdes
+
+    attribute :via, array(ReverseScopeVia), default: []
+  end
+end

data/lib/exwiw/schema_generator.rb

@@ -291,7 +291,9 @@ module Exwiw
     end
 
     private def aggregate_belongs_tos(models)
-      belongs_to_assocs = models.flat_map { |m| belongs_to_associations_for(m) }
+      belongs_to_assocs = models
+        .flat_map { |m| belongs_to_associations_for(m) }
+        .select { |assoc| assoc.polymorphic? || active_record_target?(assoc) }
       owner_db = database_name_for(models.first)
 
       non_polymorphic = belongs_to_assocs
@@ -376,6 +378,31 @@ module Exwiw
       assocs.reject { |assoc| assoc.equal?(left) }
     end
 
+    # Whether a (non-polymorphic) belongs_to points at an ActiveRecord model.
+    #
+    # A belongs_to can target a non-ActiveRecord class — most commonly an
+    # ActiveHash/ActiveYaml master (`belongs_to :equipment, class_name:
+    # "SomeActiveYamlModel"`). active_hash registers these as ordinary
+    # `belongs_to` reflections, yet the target class has no database table, so
+    # `assoc.table_name` (which delegates to `klass.table_name`) raises. Such a
+    # relation is not a DB edge exwiw can join or extract across, so it is
+    # dropped from the generated belongs_tos; the underlying foreign-key column
+    # is still emitted as a plain column. Polymorphic associations cannot be
+    # `klass`-resolved, so callers must screen those out before calling this.
+    #
+    # Resolving the target class behaves differently per non-AR shape: an
+    # ActiveHash reflection returns the class fine (the crash is later, at
+    # `table_name`), while a bare `belongs_to` to a plain class makes AR raise
+    # ArgumentError ("... is not an ActiveRecord::Base subclass") right here when
+    # the klass is computed. Both mean "not a DB relation", so rescue the lookup
+    # and treat either as a non-AR target to skip.
+    private def active_record_target?(assoc)
+      klass = assoc.klass
+      klass.is_a?(Class) && klass < ActiveRecord::Base ? true : false
+    rescue StandardError
+      false
+    end
+
     # Enumerate the concrete models that can be targets of the polymorphic
     # association `association_name`, by looking them up from every model's
     # `has_many` / `has_one` `as:` option. The order of `concrete_models` depends

data/lib/exwiw/table_config.rb

@@ -39,6 +39,14 @@ module Exwiw
     attribute :scope_exempt, Serdes::OptionalType.new(Serdes::ConcreteType.new(Boolean)), skip_serializing_if_nil: true
     attribute :scope_column, optional(String), skip_serializing_if_nil: true
 
+    # `reverse_scope` opts a table into multi-referencer reverse scoping (see
+    # Exwiw::ReverseScope and QueryAstBuilder#build_referenced_by_clause): a
+    # global-identity table (e.g. `users`) referenced by many scoped tables is
+    # constrained to the UNION of those referencers' projected foreign keys
+    # instead of being dumped in full. User-configured and never emitted by the
+    # schema generators.
+    attribute :reverse_scope, Serdes::OptionalType.new(ReverseScope), skip_serializing_if_nil: true
+
     def self.from(hash)
       config = super
       config.send(:validate_after_load!)
@@ -58,6 +66,7 @@ module Exwiw
       if rails_managed?
         hash.delete("belongs_tos")
         hash.delete("columns")
+        hash.delete("reverse_scope")
       end
       hash
     end
@@ -152,6 +161,7 @@ module Exwiw
         # User-owned, never regenerated: carry over from the existing config.
         merged_table.scope_exempt = scope_exempt
         merged_table.scope_column = scope_column
+        merged_table.reverse_scope = reverse_scope
 
         # Structural facts of each belongs_to come from the freshly generated
         # config, but the user-owned `comment`/`ignore`/`ignore_type`/`references`
@@ -199,6 +209,10 @@ module Exwiw
           raise ArgumentError,
                 "Table '#{name}' has type=#{type}; columns must not be defined."
         end
+        if reverse_scope
+          raise ArgumentError,
+                "Table '#{name}' has type=#{type}; reverse_scope must not be defined."
+        end
       else
         # An ignore:true table is not extracted, so primary_key is not required
         # (e.g. a composite-primary-key table that exwiw does not support).

data/lib/exwiw/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Exwiw
-  VERSION = "0.8.0"
+  VERSION = "0.8.2"
 end

data/lib/exwiw.rb

@@ -9,6 +9,7 @@ require_relative "exwiw/ext_json"
 require_relative "exwiw/config_file"
 require_relative "exwiw/belongs_to"
 require_relative "exwiw/table_column"
+require_relative "exwiw/reverse_scope"
 require_relative "exwiw/table_config"
 require_relative "exwiw/embedded_in"
 require_relative "exwiw/mongodb_field"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exwiw
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.2
 platform: ruby
 authors:
 - Shia
@@ -76,6 +76,7 @@ files:
 - lib/exwiw/query_ast.rb
 - lib/exwiw/query_ast_builder.rb
 - lib/exwiw/railtie.rb
+- lib/exwiw/reverse_scope.rb
 - lib/exwiw/runner.rb
 - lib/exwiw/schema_generator.rb
 - lib/exwiw/table_column.rb