activerecord-beagle-turso 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bca0371351d06b733b45c110457870093af9b82db4df224d51940d2da3f67289
-  data.tar.gz: b80598ef59803b2380f55838cb05feb50c860c6df6e4628a5e646e1a98e19d74
+  metadata.gz: 954e05b945781cc01a630306c4cb5d9368ef5dcc54876269229afed57f3a56d1
+  data.tar.gz: e512726ed37adeeee5ce7fe6268d3ecda615c079a4b041cca7a1677cce9d55fd
 SHA512:
-  metadata.gz: '068d1f9559e9aa7996f6f3c834b087ceb294db2869c76501201a5ace60d64dc6706e6f46cd58c43026f2b423c72d83ed013172c049ce284bebbcc4ea805dc821'
-  data.tar.gz: 5c119de77b070ebd9270bb373cfcbc562ec0d3dd716d3b079622ecfdb8dc1c7303dbdd11b60f922672a8fdfd8f428d64c7c967098a73bd81d159545a0a162bfe
+  metadata.gz: e48728f8d4c61291db44090aab87067f31b76ef0503db34cdfcab18cb66e4d204a35b2ab7cdc3d6114ce555a49b347fdf88cc6406f5a08acb6cbc43e97d748e8
+  data.tar.gz: 70b9fb0e606a6e8e844a737d250016b800fdf21eb47e29ab3ead567821a5250ba95ff90a2e3dbaeb9283e1673624b3a8d31ed506bb0ce9e4217e5d5751e24965

data/lib/active_record/connection_adapters/beagle_turso_adapter.rb

@@ -126,7 +126,22 @@ module ActiveRecord
         # foreign_key_check) falls through to the real driver result instead
         # of a synthesized one -- failing loudly on a genuine future gap
         # rather than silently lying.
-        BARE_PRAGMA_READ_REGEX = /\A\s*PRAGMA\s+(defer_foreign_keys|read_uncommitted)\s*\z/i
+        #
+        # The SQL-comment allowances on both ends are load-bearing, not
+        # cosmetic: with `config.active_record.query_log_tags_enabled = true`
+        # (the Rails app-generator default for development since 7.0) every
+        # statement arrives tagged -- `PRAGMA defer_foreign_keys
+        # /*application='MyApp'*/`. An `\z`-anchored match misses that, the
+        # synthesized default never fires, and the very crash this constant
+        # exists to prevent comes back: `add_foreign_key` (and every other
+        # alter_table schema change) dies with "query failed: incomplete
+        # input" while loading db/schema.rb. Tags can be prepended as well as
+        # appended (query_log_tags_format / prepend_comment), so allow both.
+        SQL_COMMENTS = %r{(?:\s*/\*.*?\*/)*}m
+        private_constant :SQL_COMMENTS
+
+        BARE_PRAGMA_READ_REGEX =
+          /\A#{SQL_COMMENTS}\s*PRAGMA\s+(defer_foreign_keys|read_uncommitted)\s*#{SQL_COMMENTS}\s*\z/im
         private_constant :BARE_PRAGMA_READ_REGEX
 
         # --- execution surface used by BeagleTursoAdapter#perform_query ---
@@ -191,6 +206,82 @@ module ActiveRecord
       end
 
       private
+        # Every table-listing question Rails asks (`tables`, `views`,
+        # `data_sources`, `table_exists?`, and through them the schema cache and
+        # the schema dumper) is built from this one string in
+        # SQLite3::SchemaStatements.
+        #
+        # beagle_turso's engine keeps a `__turso_internal_seq___turso_internal_
+        # autoincrement_<table>` bookkeeping table for each AUTOINCREMENT table.
+        # They are engine internals of exactly the kind Rails already excludes
+        # by name (`sqlite_sequence`, `sqlite_schema`), but Rails cannot know
+        # about them -- so without this filter `db:schema:dump` emits one
+        # `create_table "__turso_internal_seq_..."` block per table into
+        # db/schema.rb, and the next `db:schema:load` tries to create them for
+        # real.
+        def data_source_sql(name = nil, type: nil)
+          "#{super} AND name NOT LIKE '\\_\\_turso\\_internal\\_%' ESCAPE '\\'"
+        end
+
+        # A column definition in the DDL that carries a parenthesised type
+        # argument: `"price" decimal (10, 2) NOT NULL`, `a varchar (50)`. The
+        # name may be bare or quoted with ", ` or []; the type may be several
+        # words ("double precision"); the argument is one or two integers.
+        DECLARED_TYPE_REGEX = /
+          \A\s*
+          (?:"(?<name>[^"]*)" | `(?<name>[^`]*)` | \[(?<name>[^\]]*)\] | (?<name>\w+))
+          \s+
+          (?<type>[A-Za-z_][A-Za-z0-9_\ ]*?)
+          \s*\(\s*(?<args>\d+\s*(?:,\s*\d+)?)\s*\)
+        /x
+        private_constant :DECLARED_TYPE_REGEX
+
+        # Restore type arguments that beagle_turso's `PRAGMA table_info` drops.
+        #
+        # turso reports a column's declared type as the bare type name: a
+        # `decimal(10,2)` column comes back as `decimal`, `varchar(50)` as
+        # `varchar`, `datetime(6)` as `datetime`. Rails derives precision,
+        # scale and limit by parsing exactly that string, so all three silently
+        # become nil. Real SQLite returns the full declared type here, and the
+        # information is not lost on disk -- the CREATE TABLE in sqlite_master
+        # still says `decimal (10, 2)` -- so recover it from there.
+        #
+        # Left alone this is worse than cosmetic schema.rb churn: a dump emits
+        # `t.decimal "price"` with no precision/scale, and loading that dump
+        # builds a column whose values are no longer rounded to 2 decimal
+        # places. `super` already splits the DDL into per-column strings to
+        # recover COLLATE, AUTOINCREMENT and GENERATED ALWAYS AS for the same
+        # reason; this is the same trick for the type itself.
+        #
+        # Only fills in a missing argument -- a type that already arrived with
+        # one is left untouched, so this becomes an automatic no-op if turso
+        # starts reporting declared types in full.
+        def table_structure_with_collation(table_name, basic_structure)
+          columns = super
+          return columns unless columns.any? { |column| !column["type"].to_s.include?("(") }
+
+          declared = declared_column_types(table_name, columns.filter_map { |c| c["name"] })
+          return columns if declared.empty?
+
+          columns.each do |column|
+            next if column["type"].to_s.include?("(")
+
+            full_type = declared[column["name"]]
+            column["type"] = full_type if full_type
+          end
+        end
+
+        # Maps column name -> declared type with its argument normalised back
+        # to Rails' own spelling (`decimal (10, 2)` -> `decimal(10,2)`), which
+        # is what Rails' precision/scale/limit extraction expects to see.
+        def declared_column_types(table_name, column_names)
+          table_structure_sql(table_name, column_names).each_with_object({}) do |column_string, declared|
+            next unless (match = DECLARED_TYPE_REGEX.match(column_string))
+
+            declared[match[:name]] = "#{match[:type]}(#{match[:args].gsub(/\s+/, '')})"
+          end
+        end
+
         # The single seam. AbstractAdapter#raw_execute funnels every statement
         # here and expects an ActiveRecord::Result back, with the notification
         # payload's affected_rows/row_count filled in. cast_result (inherited)

data/lib/activerecord/beagle_turso/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   module BeagleTurso
-    VERSION = "0.1.2"
+    VERSION = "0.1.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-beagle-turso
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - BeagleSoftwareUK
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-08 00:00:00.000000000 Z
+date: 2026-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord