has_helpers 5.0.2

data/lib/has_helpers.rb

@@ -0,0 +1,63 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rails"
+require "zeitwerk"
+require "chronic"
+require "mustache"
+require "redcarpet"
+require "sorbet-runtime"
+require "has_utils"
+require "has_helpers/extensions"
+require "has_helpers/attributes"
+require "has_helpers/ui_attributes"
+require "has_helpers/app"
+require "has_helpers/aws"
+require "has_helpers/utils"
+require "has_helpers/constant"
+require "has_helpers/cursor"
+require "has_helpers/constraints"
+require "has_helpers/fixed_expiration_time_cache_session_store"
+require "has_helpers/hash_accessors"
+require "has_helpers/lazy_config"
+require "has_helpers/service_trust"
+require "has_helpers/cards"
+require "has_helpers/engine"
+require "has_helpers/helpers/application"
+require "has_helpers/resource_importer"
+require "has_helpers/active_record"
+require "has_helpers/flattener"
+require "has_helpers/resources"
+require "has_helpers/serializer"
+require "has_helpers/webhook"
+require "has_helpers/config"
+require "has_helpers/factory_api"
+require "has_helpers/factory_scenario"
+require "has_helpers/data_migration"
+require "has_helpers/web_socket_publisher"
+require "has_helpers/sentry/graphql_trace"
+require "has_helpers/concerns/hydrate_concern"
+require "has_helpers/concerns/importable_accessors"
+require "has_helpers/concerns/restrictions_parseable"
+require "hq/resource"
+require "hq/structure"
+require "hq-graphql"
+require "active_record/migration/active_migration_patch.rb"
+require_relative "../app/lib/has_helpers/index"
+require_relative "../spec/support/has_helpers/database_helpers"
+
+module HasHelpers
+  extend T::Sig
+
+  @config = T.let(::HasHelpers::Config.new, ::HasHelpers::Config)
+
+  sig { returns(::HasHelpers::Config) }
+  def self.config
+    @config
+  end
+
+  sig { params(block: T.proc.params(arg0: ::HasHelpers::Config).void).void }
+  def self.configure(&block)
+    block.call(config)
+  end
+end

data/lib/hq/resource.rb

@@ -0,0 +1,55 @@
+# typed: false
+# frozen_string_literal: true
+
+module HQ
+  class Resource
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def columns
+      @columns ||= klass.columns.map { |column| Column.new(klass: klass, name: column.name) }
+    end
+
+    def column_names
+      @column_names ||= columns.map(&:name)
+    end
+
+    def constant_associations
+      @constant_associations ||= klass.reflect_on_all_associations(:belongs_to).
+                                         select { |association| association.klass.include?(::HasHelpers::Constant) }
+    end
+
+    private
+
+    attr_reader :klass
+
+    def constant_foreign_keys
+      @constant_foreign_keys ||= constant_associations.map(&:foreign_key)
+    end
+
+    class Column
+      attr_reader :name
+
+      def initialize(klass:, name:)
+        @klass = klass
+        @name = name
+      end
+
+      delegate :table_name, to: :klass
+
+      def display_name
+        @display_name ||= begin
+                            display_name = name.dup
+                            display_name.tr("_", " ").titleize
+                          end
+      end
+
+      private
+
+      def ar_column
+        @ar_column ||= klass.columns.detect { |column| column.name == name }
+      end
+    end
+  end
+end

data/lib/hq/structure/inserts.rb

@@ -0,0 +1,176 @@
+# typed: false
+# frozen_string_literal: true
+
+module HQ
+  class Structure
+    class Inserts
+      include TSort
+
+      attr_reader :connection_pool, :dependencies, :tables
+
+      def initialize(connection_pool:, tables:)
+        @connection_pool = connection_pool
+        @dependencies = {}
+        @tables = Set.new
+
+        tables.select { |table_name| connection_pool.with_connection { |c| c.table_exists?(table_name) } }.each do |t|
+          build_dependencies!(t)
+        end
+      end
+
+      def build
+        tsort.lazy.map do |table_name|
+          sql = build_sql(table_name)
+          sequence = sequence_sql(table_name) if sql
+
+          [
+            *sql,
+            *sequence
+          ].join("\n").presence
+        end.reject(&:nil?)
+      end
+
+      private
+
+      #### TSort ####
+
+      def tsort_each_node(&block)
+        dependencies.each_key(&block)
+      end
+
+      def tsort_each_child(node, &block)
+        dependencies.fetch(node).each(&block)
+      end
+
+      #### Insert Logic ####
+
+      def build_sql(table_name)
+        klass = klass_for(table_name)
+        table = connection_pool.with_connection do |connection|
+          connection.quote_table_name(table_name)
+        end
+        columns = klass.columns.map(&:name)
+        values = klass.pluck(*columns)
+
+        return if values.empty?
+
+        sql = +"INSERT INTO #{table} (#{columns.join(",")}) VALUES\n"
+        sql << values.map { |v| row_values(Array(v)) }.join(",\n")
+        sql << ";\n\n"
+        sql
+      end
+
+      def sequence_sql(table_name)
+        sequence = default_value(table_name, :id)
+        sequence &&= extract_sequence(sequence)
+        return unless sequence
+        next_val = connection_pool.with_connection do |connection|
+          connection.select_value(<<~SQL, "FIND SEQUENCE")
+            SELECT nextval(#{sequence})
+          SQL
+        end
+
+        "SELECT setval(#{sequence}, #{quote(next_val)}, #{quote(false)});\n\n"
+      end
+
+      def row_values(values)
+        quoted_values = values.map { |v| quote(v) }.join(",")
+        "(#{quoted_values})"
+      end
+
+      def klass_for(table_name)
+        @klass_for ||= Hash.new do |hash, table|
+          scoped_connection_pool = connection_pool
+          hash[table] = Class.new(ActiveRecord::Base) do
+            self.table_name = table
+
+            define_singleton_method(:connection_pool) do
+              scoped_connection_pool
+            end
+
+            delegate :connection, to: :connection_pool
+          end
+        end
+        @klass_for[table_name]
+      end
+
+      #### Dependencies ####
+
+      def build_dependencies!(table_name)
+        tables << table_name
+        return if dependencies[table_name]
+        to_tables = dependencies[table_name] = foreign_keys(table_name).uniq.reject { |t| t == table_name }
+        deps = to_tables.reject { |to_table| tables.include?(to_table) }
+
+        if deps.any?
+          deps.each do |d|
+            build_dependencies!(d)
+          end
+        end
+      end
+
+      # NOTE ::ActiveRecord::Base.connection.foreign_keys doesn't work on tables with a schema other than public.
+      # I believe that this is fixed in Rails 5
+      def foreign_keys(table_name)
+        schema, table = schema_and_table(table_name)
+        quoted_schema = quote(schema)
+        quoted_table = quote(table)
+
+        results = connection_pool.with_connection do |connection|
+          connection.exec_query(<<-SQL, "FOREIGN KEYS")
+            SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid
+            FROM pg_constraint c
+            JOIN pg_class t1 ON c.conrelid = t1.oid
+            JOIN pg_class t2 ON c.confrelid = t2.oid
+            JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+            JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+            JOIN pg_namespace t3 ON c.connamespace = t3.oid
+            WHERE c.contype = 'f'
+              AND t1.relname = #{quoted_table}
+              AND t3.nspname = #{quoted_schema}
+            ORDER BY c.conname
+          SQL
+        end
+
+        results.map do |row|
+          row["to_table"]
+        end
+      end
+
+      def default_value(table_name, column_name)
+        schema, table = schema_and_table(table_name)
+        quoted_schema = quote(schema)
+        quoted_table = quote(table)
+        quoted_column_name = quote(column_name)
+
+        connection_pool.with_connection do |connection|
+          connection.select_value(<<-SQL, "DEFAULT VALUES")
+            SELECT column_default
+            FROM information_schema.columns
+            WHERE (table_schema, table_name) = (#{quoted_schema}, #{quoted_table})
+              AND column_name = #{quoted_column_name}
+            LIMIT 1
+          SQL
+        end
+      end
+
+      def extract_sequence(default_value)
+        /\Anextval\((.+)\)\z/.match(default_value)&.captures&.first
+      end
+
+      def quote(val)
+        connection_pool.with_connection do |connection|
+          connection.quote val
+        end
+      end
+
+      def schema_and_table(table_name, default_schema: :public)
+        /\A(?:(?<schema>\w+)\.)?(?<table>.+?)\z/ =~ table_name
+        schema ||= default_schema
+        table ||= table_name
+
+        [schema, table]
+      end
+    end
+  end
+end

data/lib/hq/structure.rb

@@ -0,0 +1,115 @@
+# typed: false
+# frozen_string_literal: true
+
+require "hq/structure/inserts"
+
+module HQ
+  class Structure
+    class Error < StandardError
+      UNSUPPORTED_TYPE = "`::HQ::Structure#dump` unsupported for %{filename}"
+    end
+
+    ON_ERROR_STOP_1 = "ON_ERROR_STOP=1"
+    SQL_COMMENT_BEGIN = "--"
+
+    #### Class Methods ####
+
+    def self.path(filename)
+      Rails.root.join("db", filename).to_s
+    end
+
+    def self.dump(filename, connection_pool:, **options)
+      structure = new(connection_pool: connection_pool)
+      structure.dump(filename, **options)
+    end
+
+    def self.restore(filename, connection_pool:, **options)
+      structure = new(connection_pool: connection_pool)
+      structure.restore(filename, **options)
+    end
+
+    #### Instance Methods ####
+
+    attr_reader :connection_pool
+
+    def initialize(connection_pool:)
+      @connection_pool = connection_pool
+    end
+
+    def dump(filename, args: nil, table_inserts: [])
+      validate_filename!(filename)
+      file_path = self.class.path(filename)
+
+      dump_args = ["-s", "-x", "-O", "--no-subscriptions", "-f", file_path, *Array(args), configuration.configuration_hash[:database]]
+      run_psql_cmd("pg_dump", dump_args)
+      remove_sql_header_comments(file_path)
+      inserts = [*default_inserts, *table_inserts]
+      inserts_sql = ::HQ::Structure::Inserts.new(connection_pool: connection_pool, tables: inserts).build
+      schema_search_path = connection_pool.with_connection(&:schema_search_path)
+      File.open(file_path, "a") do |f|
+        f << "SET search_path TO #{schema_search_path};\n\n"
+
+        inserts_sql.each do |sql|
+          f.puts sql, "\n"
+        end
+      end
+    end
+
+    def restore(filename, args: nil)
+      validate_filename!(filename)
+      file_path = self.class.path(filename)
+      restore_args = ["-v", ON_ERROR_STOP_1, "-q", "-X", "-f", file_path, *Array(args), configuration.configuration_hash[:database]]
+      run_psql_cmd("psql", restore_args)
+    end
+
+    private
+
+    def configuration
+      connection_pool.pool_config.db_config
+    end
+
+    def default_inserts
+      [
+        :schema_migrations
+      ]
+    end
+
+    def psql_env
+      {
+        "PGHOST" => configuration.configuration_hash[:host],
+        "PGPORT" => configuration.configuration_hash[:port],
+        "PGPASSWORD" => configuration.configuration_hash[:password],
+        "PGUSER" => configuration.configuration_hash[:username]
+      }.compact.transform_values(&:to_s)
+    end
+
+    def run_psql_cmd(cmd, args)
+      fail run_psql_cmd_error(cmd, args) unless Kernel.system(psql_env, cmd, *args)
+    end
+
+    def run_psql_cmd_error(cmd, args)
+      msg = +"failed to execute:\n"
+      msg << "#{cmd} #{args.join(' ')}\n\n"
+      msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
+      msg
+    end
+
+    def remove_sql_header_comments(filename)
+      tempfile = Tempfile.open("uncommented_structure.sql")
+      begin
+        File.foreach(filename) do |line|
+          unless line.start_with?(SQL_COMMENT_BEGIN) || line.blank?
+            tempfile << line
+          end
+        end
+      ensure
+        tempfile.close
+      end
+      FileUtils.cp(tempfile.path, filename)
+    end
+
+    def validate_filename!(filename)
+      raise Error, Error::UNSUPPORTED_TYPE % { filename: filename } unless filename.ends_with?(".sql")
+    end
+  end
+end

data/lib/tasks/has_helpers/service_trust.rake

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+namespace :service_trust do
+  namespace :keys do
+    desc "Generate the first ServiceTrust key for the current environment"
+    task generate: :environment do
+      key = HasHelpers::ServiceTrust::KeyManager.generate_first_key!
+      puts "kid=#{key.kid} env=#{key.environment} active=#{key.active}"
+    end
+
+    desc "Rotate ServiceTrust keys"
+    task rotate: :environment do
+      key = HasHelpers::ServiceTrust::KeyManager.rotate!
+      puts "kid=#{key.kid} env=#{key.environment} active=#{key.active}"
+    end
+
+    desc "List ServiceTrust keys"
+    task list: :environment do
+      HasHelpers::ServiceTrust::Key.for_env(HasHelpers::ServiceTrust.config.environment).order(created_at: :desc).find_each do |key|
+        puts "kid=#{key.kid} env=#{key.environment} active=#{key.active} retired_at=#{key.retired_at}"
+      end
+    end
+
+    desc "Force-retire a ServiceTrust key"
+    task :retire, [:kid] => :environment do |_task, args|
+      abort "kid is required" if args[:kid].blank?
+
+      HasHelpers::ServiceTrust::KeyManager.retire!(args[:kid])
+      puts "retired kid=#{args[:kid]}"
+    end
+  end
+
+  namespace :audit do
+    desc "Delete ServiceTrust audit logs older than retention"
+    task cleanup: :environment do
+      HasHelpers::ServiceTrust::AuditLogCleanupWorker.perform_now
+    end
+  end
+end

data/script/rails

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path("../..", __FILE__)
+ENGINE_PATH = File.expand_path("../../lib/has_helpers/engine", __FILE__)
+
+require "rails/all"
+require "rails/engine/commands"

data/sorbet/config

@@ -0,0 +1,5 @@
+--dir
+.
+
+--ignore=/spec
+--ignore=/vendor