pg_types 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e20908d841705a0d9aff62529d44d0b12d0490d51b254c49424601ddd01aa6ce
-  data.tar.gz: 0aef0b9dd97da00bd122395c039c3e82a6ad25606abaf76fe903c13dade199d5
+  metadata.gz: 1cd243d89a6bc0e672b5cd07d3aa1d2fe3d4227351cb0ee64720cf0126ed9538
+  data.tar.gz: b19af58bb2ba7b308dc7597d487d6914e5cdb044d762da86191103ae4a4512e0
 SHA512:
-  metadata.gz: b19210b13c1c77c22daf9a321be40e41ebbde543958d4c0cef1f8cebc1c109712744c26dae3b03de383a9945c2ffd5da7cdf4efcecec0573a6ede338d29aa2d0
-  data.tar.gz: a95652c5c2c07a3fb70314ad9dddd0d62f08716382fd403937daac15b71c242f8eee06cedcd481d66e7d74935272eb33a5dbebfc752b064eb5350686b8a9387e
+  metadata.gz: 9d14da9a0eafad1dded2f282521cb814b36581de7e2f0d3ae620bffddb3cd8c738fc8441d176ab745fb32965b92a28c55dfa97a4a4409698fcca0a2d9dbfed15
+  data.tar.gz: 06771fa123bd0bc8999ebe2e986f967c0361ff22f8f066eb068f6e353d68a3f6d7c2bb36acea28d7604188755c5ad23c8ae1d447aa5cbe66ee2d14bc1fccc5b8

data/lib/pg_types/railtie.rb

@@ -2,11 +2,9 @@
 
 module PgTypes
   class Railtie < Rails::Railtie
-    initializer "postgres_aggregates.load" do
+    initializer "pg_types.load", after: "pg_aggregates.load" do
       ActiveSupport.on_load(:active_record) do
-        ActiveRecord::ConnectionAdapters::AbstractAdapter.include PgTypes::SchemaStatements
-        ActiveRecord::Migration::CommandRecorder.include PgTypes::CommandRecorder
-        ActiveRecord::SchemaDumper.prepend PgTypes::SchemaDumper
+        PgTypes.load
       end
     end
   end

data/lib/pg_types/schema_dumper.rb

@@ -2,49 +2,82 @@
 
 module PgTypes
   module SchemaDumper
+    # Define a Struct for type information
+    TypeDefinition = Struct.new(:name, :definition)
+
+    # Override the types method from ActiveRecord's PostgreSQL schema dumper
+    # This will run at the right time in the schema dump process (after extensions, before tables)
     def tables(stream)
-      # First dump types
+      # Then add our custom composite types
       dump_custom_types(stream)
-      stream.puts
 
+      # Call the original types method first (for enum types)
       super
     end
 
     private
 
     def dump_custom_types(stream)
-      type_versions = {}
-      Dir.glob(File.join(Dir.pwd, "db/types/*_v*.sql")).each do |file|
-        file_version = FileVersion.new(file)
-        type_versions[file_version.name] ||= []
-        type_versions[file_version.name] << file_version
-      end
+      types = dumpable_types_in_database
 
-      return if type_versions.empty?
+      return if types.empty?
 
       stream.puts "  # These are custom PostgreSQL types that were defined"
 
-      latest_versions = type_versions.transform_values do |versions|
-        versions.max_by(&:version)
+      # Sort by name to ensure consistent ordering
+      types.sort_by(&:name).each do |type|
+        stream.puts <<-TYPE
+    create_type "#{type.name}", sql_definition: <<-SQL
+      #{type.definition}
+    SQL
+        TYPE
       end
+    end
 
-      latest_versions.keys.sort.each do |type_name|
-        file_version = latest_versions[type_name]
-        all_versions = type_versions[type_name].map(&:version).sort
-        version_comment = all_versions.size > 1 ? " -- versions: #{all_versions.join(", ")}" : ""
-
-        # Remove any leading/trailing whitespace from SQL definition
-        sql_def = file_version.sql_definition.strip
+    # Fetches all custom types from the database
+    def dumpable_types_in_database
+      @dumpable_types_in_database ||= begin
+        # SQL query to fetch custom types from PostgreSQL
+        sql = <<~SQL
+          SELECT#{" "}
+            t.typname AS name,
+            format(
+              'CREATE TYPE %s AS (%s);',
+              t.typname,
+              array_to_string(
+                array_agg(
+                  format(
+                    '%s %s',
+                    a.attname,
+                    pg_catalog.format_type(a.atttypid, a.atttypmod)
+                  ) ORDER BY a.attnum
+                ),
+                E',\n        '
+              )
+            ) AS definition
+          FROM pg_type t
+          JOIN pg_class c ON (c.relname = t.typname)
+          JOIN pg_attribute a ON (a.attrelid = c.oid)
+          JOIN pg_namespace n ON (n.oid = t.typnamespace)
+          WHERE n.nspname = 'public'
+            AND c.relkind = 'c'
+            AND a.attnum > 0
+            AND NOT a.attisdropped
+          GROUP BY t.typname, n.nspname
+          ORDER BY t.typname;
+        SQL
 
-        stream.puts <<-TYPE
-  create_type "#{type_name}", sql_definition: <<-SQL#{version_comment}
-    #{sql_def}
-  SQL
+        # Get the appropriate connection
+        connection = ActiveRecord::Base.connection
 
-        TYPE
+        # Execute the query and transform results into type objects
+        connection.execute(sql).map do |result|
+          TypeDefinition.new(
+            result["name"],
+            result["definition"].strip
+          )
+        end
       end
-
-      stream.puts
     end
   end
 end

data/lib/pg_types/schema_statements.rb

@@ -5,6 +5,9 @@ module PgTypes
     def create_type(name, version: nil, sql_definition: nil)
       raise ArgumentError, "Must provide either sql_definition or version" if sql_definition.nil? && version.nil?
 
+      # First, check if the type already exists to avoid duplicate creation attempts
+      return if type_exists?(name)
+
       if sql_definition
         execute sql_definition
       else
@@ -21,6 +24,10 @@ module PgTypes
 
         execute File.read(sql_file)
       end
+    rescue ActiveRecord::StatementInvalid => e
+      puts "WARNING: Failed to create type #{name}."
+      puts "         Error: #{e.message}"
+      raise
     end
 
     def drop_type(name, force: false)
@@ -39,5 +46,22 @@ module PgTypes
           $$;
       SQL
     end
+
+    private
+
+    def type_exists?(name)
+      sql = <<-SQL
+        SELECT 1
+        FROM pg_catalog.pg_type t
+        JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+        WHERE t.typname = '#{name}'
+        AND n.nspname = 'public'
+      SQL
+
+      result = execute(sql)
+      result.any?
+    rescue StandardError
+      false
+    end
   end
 end

data/lib/pg_types/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgTypes
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 end

data/lib/pg_types.rb

@@ -10,11 +10,20 @@ require_relative "pg_types/schema_dumper"
 require_relative "pg_types/railtie"
 
 module PgTypes
+  module_function
+
   class Error < StandardError; end
 
-  class << self
-    def database
-      ActiveRecord::Base.connection
-    end
+  def load
+    # Add schema statements and command recorder
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.include PgTypes::SchemaStatements
+    ActiveRecord::Migration::CommandRecorder.include PgTypes::CommandRecorder
+
+    # Hook into the schema dumper
+    ActiveRecord::SchemaDumper.prepend PgTypes::SchemaDumper
+  end
+
+  def database
+    ActiveRecord::Base.connection
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: pg_types
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - mhenrixon
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-05 00:00:00.000000000 Z
+date: 2025-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -97,7 +96,6 @@ metadata:
   rubygems_mfa_required: 'true'
   github_repo: ssh://github.com/mhenrixon/pg_types
   funding_uri: https://github.com/sponsors/mhenrixon
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -112,8 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Rails integration for PostgreSQL custom types
 test_files: []