terrier-engine 4.67.10 → 4.67.13

package/lib/terrier/frontend/badge_generator.rb

@@ -1,151 +0,0 @@
-# internal use only, access badge metadata with Badges.all
-RAW_BADGES = {
-  accounts_payable: {
-    roles: %w[handling]
-  },
-  accounts_receivable: {
-    roles: %w[handling]
-  },
-  applicator_license: {
-    roles: %w[admin]
-  },
-  autopay: {
-    roles: %w[admin handling]
-  },
-  bats: {
-    roles: %w[admin management ops sales]
-  },
-  clypboard_hardware: {
-    roles: %w[admin]
-  },
-  clypboard_project: {
-    roles: %w[admin]
-  },
-  clypmart: {
-    roles: %w[admin]
-  },
-  commercial: {
-    roles: %w[admin management ops sales]
-  },
-  compliance: {
-    roles: %w[admin]
-  },
-  contracts: {
-    roles: %w[admin reporting]
-  },
-  copesan: {
-    roles: %w[admin]
-  },
-  credit_card: {
-    roles: %w[admin]
-  },
-  customer_call: {
-    roles: %w[handling]
-  },
-  customer_text: {
-    roles: %w[handling]
-  },
-  employee_data: {
-    roles: %w[admin handling reporting]
-  },
-  finance: {
-    roles: %w[admin reporting]
-  },
-  fleet: {
-    roles: %w[admin]
-  },
-  fumigation: {
-    roles: %w[admin management ops]
-  },
-  information_technology: {
-    title: 'IT',
-    roles: %w[admin management]
-  },
-  irrigation: {
-    roles: %w[admin management ops sales]
-  },
-  landscape: {
-    roles: %w[admin management ops sales]
-  },
-  marketing: {
-    roles: %w[admin]
-  },
-  mergers_and_acquisitions: {
-    title: 'M&A',
-    roles: %w[admin reporting]
-  },
-  multi_housing: {
-    title: 'Multi-Housing',
-    roles: %w[admin management ops sales]
-  },
-  payroll: {
-    roles: %w[admin reporting]
-  },
-  pest: {
-    roles: %w[admin management ops sales]
-  },
-  pro: {
-    roles: %w[admin management ops sales]
-  },
-  program: {
-    roles: %w[admin]
-  },
-  proposals: {
-    roles: %w[handling]
-  },
-  residential: {
-    roles: %w[admin management ops sales]
-  },
-  sales: {
-    roles: %w[management reporting]
-  },
-  scripts: {
-    roles: %w[admin reporting]
-  },
-  termite: {
-    roles: %w[admin management ops sales]
-  },
-  wildlife: {
-    roles: %w[admin management ops sales]
-  }
-}
-
-require 'terrier/frontend/base_generator'
-
-# manage the generation of badge images and list of possible badges
-class BadgeGenerator < BaseGenerator
-
-  # @param options [Hash]
-  def run(options)
-    image_in_dir = options[:image_in_dir] || raise("Must provide :image_in_dir pointing to input image directory")
-    image_out_dir = options[:image_out_dir] || raise("Must provide :image_out_dir pointing to output image directory")
-    clear_directory image_out_dir
-
-    badge_titles = {}
-    RAW_BADGES.each do |base_key, raw_badge|
-      base_title = raw_badge[:title].presence || base_key.to_s.titleize
-      roles = raw_badge[:roles] || raise("No roles specified for badge #{base_key.bold}")
-      roles.each do |role|
-        key = "#{base_key}-#{role}"
-        title = "#{base_title} #{role.titleize}"
-        badge_titles[key] = title
-
-        # generate the image
-        combine_svgs %W[#{image_in_dir}/badge-#{base_key}.svg #{image_in_dir}/badge_role-#{role}.svg],
-                     "#{image_out_dir}/badge-#{key}.svg"
-      end
-    end
-    info "#{badge_titles.count.to_s.bold} badges from #{RAW_BADGES.count.to_s.italic} base badge names"
-    all_badges = badge_titles.keys.sort
-
-    # make typescript-acceptable variable names for the badge image imports
-    badge_vars = {}
-    all_badges.each do |badge|
-      badge_vars[badge] = badge.camelize.gsub('-', '')
-    end
-
-    render_template 'badges.rb', binding
-    render_template 'badges.ts', binding
-  end
-
-end

package/lib/terrier/frontend/base_generator.rb

@@ -1,132 +0,0 @@
-# base for classes that generate code and/or images
-class BaseGenerator
-  include Loggable
-
-  # @option typescript_dir [String?] the output directory for typescript files
-  # @option ruby_dir [String?] the output directory for ruby files
-  # @option template_dir [String?] the directory for templates that aren't absolute paths
-  def initialize(options={})
-    @typescript_dir = options[:typescript_dir].presence || Rails.root.join("app/frontend/gen").to_s
-    @ruby_dir = options[:ruby_dir].presence || Rails.root.join("config/initializers").to_s
-    @template_dirs = ["#{Terrier::Engine.root}/lib/terrier/frontend"]
-    if options[:template_dir].present?
-      @template_dirs.unshift options[:template_dir]
-    end
-  end
-
-  # render the named template in lib/templates using the given context
-  # @param name [String] can be either the full path to a template or the name of a template in terrier/frontend
-  # @param context [Binding] the binding context which which to render the ERB template
-  def render_template(name, context)
-    # read the template
-    name = name.to_s # in case it's a Pathname
-    template_name = name
-    template_name += '.erb' unless template_name.end_with?('.erb')
-    if name.start_with? '/'
-      template_path = name
-      name = File.basename name
-      raise "Could not find template at #{template_path}" unless File.exist?(template_path)
-    else
-      template_path = nil
-      @template_dirs.each do |dir|
-        path = "#{dir}/#{template_name}"
-        if File.exist?(path)
-          template_path = path
-          break
-        end
-      end
-      raise "Could not find template named #{template_name}, looked in #{@template_dirs.to_sentence}" unless template_path.present?
-    end
-    template = ERB.new File.read(template_path), trim_mode: '%-'
-
-    # determine the output path
-    case name.split('.').last
-    when 'ts'
-      abs_path = "#{@typescript_dir}/#{name}"
-      comment_prefix = '//'
-    when 'rb'
-      abs_path = "#{@ruby_dir}/#{name}"
-      comment_prefix = '#'
-    else
-      raise "Don't know how to handle template #{name}"
-    end
-    abs_dir = File.dirname abs_path
-    unless File.exist?(abs_dir)
-      info "Creating output directory #{abs_dir.bold}"
-      FileUtils.mkdir_p abs_dir
-    end
-
-    # render the template
-    info "Rendering template #{name.bold} to #{abs_path.blue}"
-    File.open abs_path, 'wt' do |f|
-      raw = template.result context
-      lines = raw.split("\n")[1..-1] # remove the noinspection line at the top
-      lines.prepend "#{comment_prefix} This file was automatically generated on #{Time.now}, DO NOT EDIT IT MANUALLY!"
-      f.write lines.join("\n")
-    end
-    abs_path
-  end
-
-  # Uses Prettier to format a file
-  # @param path [String] the absolute path to the file
-  def prettier_file(path)
-    cmd = "npx --no-install prettier --print-width 200 --write --no-semi #{path}"
-    info "Formatting file with #{cmd.bold}"
-    system cmd
-  end
-
-  def svgo_path
-    Terrier::Engine.root.join('node_modules/svgo/bin/svgo')
-  end
-
-  # optimize all SVG files in in_dir using SVGO
-  def optimize_svgs(in_dir, out_dir)
-    info "Optimizing images in #{in_dir.green} and storing them in #{out_dir.blue}"
-    clear_directory out_dir
-    system "#{svgo_path} -f #{in_dir} --config #{Terrier::Engine.root.join('lib/terrier/icons/svgo-config.cjs')} -o #{out_dir}", exception: true
-  end
-
-  # ensures that the directory exists and is empty
-  def clear_directory(dir)
-    info "Clearing directory #{dir.yellow}"
-    Dir.mkdir dir unless File.exist? dir
-    FileUtils.rm_rf Dir.glob("#{dir}/*")
-  end
-
-  # combine the contents of two or more SVG files
-  # @param in_paths [Array<String>] the paths of the files to combine
-  # @param out_path [String] the path of the combined file
-  def combine_svgs(in_paths, out_path)
-    info "Combining #{in_paths.join(" & ").italic} into #{out_path.blue}"
-    count = 0
-    in_docs = in_paths.map do |path|
-      count += 1
-      namespace = path.scan(/(\w+).svg/)[0].first + count.to_s
-      Nokogiri::XML namespace_svg_ids(File.read(path), namespace)
-    end
-    out_doc = in_docs.first.dup
-    out_content = out_doc.at_css('svg')
-    in_docs[1..-1].each do |in_doc|
-      content = in_doc.at_css('svg')
-      content.children.each do |child|
-        out_content << child
-      end
-    end
-    File.open out_path, 'wt' do |out_file|
-      out_file << out_doc.to_xml
-    end
-  end
-
-  # appends a namespace to all ids in the raw svg string
-  # @param svg [String]
-  # @return [String]
-  def namespace_svg_ids(svg, namespace)
-    svg.scan(/id="(\w+)"/).each do |m|
-      id = m.first
-      svg.gsub!("id=\"#{id}\"", "id=\"#{id}#{namespace}\"")
-      svg.gsub!("##{id}", "##{id}#{namespace}")
-    end
-    svg
-  end
-
-end

package/lib/terrier/frontend/model_generator.rb

@@ -1,403 +0,0 @@
-require 'terrier/frontend/base_generator'
-
-# Generates the models.ts and schema.ts files from the database schema.
-class ModelGenerator < BaseGenerator
-  VirtualAttrColumn = Struct.new(:name, :type, :null) do
-    def sql_type_metadata = nil
-  end
-
-  # @param options [Hash] a hash of options for generating the model
-  # @option options [Hash{String => Array<String>}] :imports a hash of import paths to a list of symbols
-  # @option options [Hash{String => String}] :type_map a hash of type names to map to other names
-  # @option options [String, Array<String>] :prefix model name prefix(s) used to select the included models
-  # @option options [String, Array<String>] :exclude_prefix model name prefix(s) used to reject out the excluded models
-  def initialize(options={})
-    super
-    @has_shrine = defined?(Shrine)
-
-    @imports = options[:imports] || {}
-    @type_map = options[:type_map] || {}
-    @prefix = Array.wrap(options[:prefix])
-    @exclude_prefix = Array.wrap(options[:exclude_prefix])
-
-    # add the default imports
-    @imports['tuff-core/types'] ||= []
-    @imports['tuff-core/types'] << 'OptionalProps'
-  end
-
-  def each_model
-    ApplicationRecord.descendants.each do |model|
-      next unless model.base_class? # exclude STI child classes
-      next if model.respond_to?(:exclude_from_frontend?) && model.exclude_from_frontend? # we don't need these on the frontend
-      next if @prefix.present? && !@prefix.any? { |prefix| model.name.start_with?(prefix) } # filter by prefix
-      next if @exclude_prefix.present? && @exclude_prefix.any? { |prefix| model.name.start_with?(prefix) } # filter by exclude prefix
-      yield model
-    end
-  end
-
-  def run
-    # load all model metadata
-    Rails.application.eager_load!
-    models = {}
-    each_model do |model|
-      reflections = model.reflections
-      if (reflections_to_exclude = model.try(:exclude_reflections_from_frontend).presence)
-        reflections = reflections.except *reflections_to_exclude
-      end
-
-      columns = model.columns
-      if (columns_to_exclude = model.try(:exclude_columns_from_frontend).presence)
-        columns = columns.reject { _1.name.in? columns_to_exclude }
-      end
-
-      column_names = Set.new columns.map(&:name)
-      enum_fields = {}.with_indifferent_access
-      model.validators.each do |validator|
-        column, *other_columns = validator.attributes
-        values = validator.options[:in]
-        if !other_columns.present? && column.to_s.in?(column_names) && values.present? && !values.is_a?(Proc)
-          # if values is a proc, the values aren't known at compile time and shouldn't be included in the typescript type
-          enum_fields[column] = values
-        end
-      end
-
-      if model.has_attribute?(model.inheritance_column) && !enum_fields.has_key?(model.inheritance_column)
-        # this model uses single table inheritance; add descendants as enum values for the inheritance column
-        descendant_names = model.descendants.map(&:name).sort
-        descendant_names.map!(&:demodulize) unless model.store_full_sti_class
-        enum_fields[model.inheritance_column] = descendant_names
-      end
-
-      models[model.name] = {
-        columns:,
-        virtual_attributes: model.virtual_attributes_list,
-        reflections:,
-        belongs_tos: reflections.select { |_, ref| model.column_names.include?("#{ref.name}_id") },
-        has_manies: reflections.select { |_, ref| ref.class_name.classify.constantize.column_names.include?("#{model.model_name.singular}_id") },
-        enum_fields:,
-        attachments: @has_shrine ? model.ancestors.grep(Shrine::Attachment).map(&:attachment_name) : [],
-        model_class: model,
-        table_name: model.table_name
-      }
-    end
-
-    #noinspection RubyUnusedLocalVariable
-    unpersisted_columns = %w[id created_at created_by_name updated_at _state]
-
-    # generate and format the models file
-    out_path = render_template 'models.ts', binding
-    info "Wrote #{models.count.to_s.bold} models to #{out_path.blue}"
-    prettier_file out_path
-  end
-
-  def process_raw_model(model)
-    # remove the columns metadata so that they can be placed in the relevant column definitions
-    model_meta = model[:metadata] || {}
-    columns_meta = model_meta.delete(:columns).presence || {}
-
-    # split out the reflections
-    refs = model.delete :reflections
-    belongs_to = {}
-    has_many = {}
-    refs.each do |ref_name, ref|
-      ref_type = ref.options[:class_name].presence || ref.name.to_s.classify
-      next if ref_type.constantize.exclude_from_frontend?
-      raw_ref = {
-        name: ref_name,
-        model: ref_type
-      }
-      if model[:columns].map(&:name).include?("#{ref.name}_id")
-        raw_ref[:optional] = ref.options[:optional] || false
-        belongs_to[ref_name] = raw_ref
-      elsif ref_type.constantize.column_names.include?("#{model[:table_name].singularize}_id")
-        has_many[ref_name] = raw_ref
-      end
-    end
-    model[:belongs_to] = belongs_to
-    model[:has_many] = has_many
-
-    columns_to_exclude = model[:excluded_columns] || Set.new
-    info "Excluding #{columns_to_exclude.count} #{model[:name]} columns: #{columns_to_exclude.to_a.join(', ')}"
-
-    # make the columns into a map
-    raw_cols = {}
-    model[:columns].each do |col|
-      next if col.name.in?(columns_to_exclude)
-
-      enum_field = model[:enum_fields][col.name.to_sym]
-      type = enum_field ? 'enum' : model[:type_map][col.name.to_sym] || col.type
-      raw_col = {
-        name: col.name,
-        nullable: col.null,
-        type: type
-      }
-
-      # get column metadata
-      col_meta = columns_meta[col.name.to_sym]
-      if col_meta
-        raw_col[:metadata] = col_meta
-      end
-
-      # is it an array?
-      if col.sql_type_metadata.sql_type.ends_with?('[]')
-        raw_col[:array] = true
-      end
-
-      # is it an enum?
-      if enum_field
-        raw_col[:possible_values] = enum_field.is_a?(Proc) ? enum_field.call : enum_field
-      end
-      raw_cols[col.name] = raw_col
-    end
-    model[:columns] = raw_cols
-  end
-
-  # @return [Hash] a raw representation of the schema
-  def raw_schema
-    models = load_models
-    models.each do |_, model|
-      process_raw_model model
-    end
-    {
-      models: models
-    }
-  end
-
-  # Load all model metadata
-  # @return [Hash] a hash mapping model name to its metadata
-  def load_models
-    Rails.application.eager_load!
-    models = {}
-    each_model do |model|
-      enum_fields = {}
-      model.validators.each do |v|
-        if v.options[:in].present? && v.attributes.length == 1
-          enum_fields[v.attributes.first] = v.options[:in]
-        end
-      end
-      attachments = @has_shrine ? model.ancestors.grep(Shrine::Attachment).map(&:attachment_name) : []
-      models[model.name] = {
-        columns: model.columns,
-        virtual_attributes: model.virtual_attributes_list,
-        reflections: model.reflections,
-        enum_fields: enum_fields,
-        attachments: attachments,
-        name: model.name,
-        table_name: model.table_name,
-        type_map: model.type_map || {},
-        excluded_columns: model.exclude_columns_from_frontend,
-        metadata: model.respond_to?(:metadata) ? model.metadata : nil
-      }
-    end
-    models
-  end
-
-  def build_typescript_model_type(model_name, model, is_unpersisted = false)
-    unnamespaced_model_name = model_name.split('::').last
-    type_str = "#{unnamespaced_model_name} = { "
-    model_class = model[:model_class]
-
-    fields = []
-    columns = model[:columns]
-
-    enum_dependency_strings = []
-    if model_class.enum_dependencies
-      model_class.enum_dependencies.each do |dep_field, deps|
-        used_enum_values = []
-        deps.each do |enum_val, required_field|
-          enum_type_str = <<~TS
-            ({#{dep_field}: '#{enum_val}'; #{required_field}: #{typescript_type(model_class.columns_hash[required_field.to_s], model_class)}} 
-          TS
-
-          remaining_enum_values = model[:enum_fields][dep_field] - [enum_val.to_s]
-
-          enum_type_str += <<~TS 
-            | {#{dep_field}: #{remaining_enum_values.map { |v| "'#{v}'" }.join(' | ')}; #{typescript_field(model_class.columns_hash[required_field.to_s], model_class)}})
-          TS
-
-          enum_dependency_strings.push enum_type_str.strip
-
-          columns.delete dep_field
-          columns.delete required_field
-        end
-      end
-    end
-
-    # columns
-    columns.each do |col|
-      next if model[:attachments].include?(col.name.to_sym)
-      fields.push typescript_field(col, model_class, model[:enum_fields][col.name.to_sym], is_unpersisted)
-    end
-
-    virtual_attributes = model[:virtual_attributes]
-    virtual_attributes.each do |name, type|
-      col = VirtualAttrColumn.new(name: name.to_s, type: type, null: true)
-      fields.push typescript_field(col, model_class, nil, true)
-    end
-
-    # reflections (associations)
-    model[:reflections].each do |ref_name, ref|
-      ref_type = compute_ref_type(ref)
-      next unless ref_type
-      if is_unpersisted && ref_type.include?('[]')
-        fk = ref.options[:foreign_key].presence || "#{model_name.tableize.singularize}_id"
-        if ref.class_name.classify.constantize.column_names.include?(fk)
-          ref_type = "OptionalProps<Unpersisted#{ref_type.gsub('[]', '')},'#{fk}'>[]"
-        end
-      end
-      fields.push "#{ref_name}?: #{ref_type}"
-    end
-
-    # attachments
-    model[:attachments].each do |attachment|
-      fields.push "#{attachment}?: File"
-    end
-
-    type_str += fields.join(', ') + " }"
-    if enum_dependency_strings.present?
-      type_str += " & #{enum_dependency_strings.join(' & ')}"
-    end
-    type_str
-  end
-
-  def typescript_field(col, model_class, enum_fields = nil, is_unpersisted = false)
-    str = col.name
-
-    if is_unpersisted
-      str += col.null || %w[id created_at created_by_name updated_at _state].include?(col.name) ? '?' : ''
-    else
-      str += col.null ? '?' : ''
-    end
-    str += ': ' + typescript_type(col, model_class, enum_fields)
-    str
-  end
-
-  # @return [String] the typescript type associated with the given column type
-  def typescript_type(col, model_class, enum_fields = nil)
-    unless col.is_a?(VirtualAttrColumn)
-      if model_class.respond_to?(:embedded_fields)
-        embedded = model_class.embedded_fields[col.name.to_sym]
-        if embedded.present?
-          embedded_type = embedded_schema_type(embedded[:type])
-          return case embedded[:kind].to_sym
-            when nil, :one then embedded_type
-            when :many then "#{embedded_type}[]"
-            else raise "Unknown embedded kind: #{embedded[:kind].inspect}"
-            end
-        end
-      end
-
-      schema_method = "#{col.name}_schema"
-      if model_class.respond_to?(schema_method)
-        schema = model_class.send(schema_method)
-        if schema.present?
-          return typescript_schema_type(schema)
-        end
-      end
-    end
-
-    case col.type
-    when :boolean, :bool
-      'boolean'
-    when :integer, :float
-      'number'
-    when :json, :jsonb
-      if @has_shrine && model_class && model_class.ancestors.grep(Shrine::Attachment).map { |anc| "#{anc.attachment_name}_data" }.include?(col.name)
-        'Attachment | { path: string }'
-      else
-        'object'
-      end
-    else
-      if enum_fields.present?
-        enum_fields.map { |f| "'#{f}'" }.join(' | ')
-      elsif col.sql_type_metadata&.sql_type == 'text[]'
-        'string[]'
-      else
-        'string'
-      end
-    end
-  end
-
-  # @return [String] the typescript type associated with the given
-  # schema literal returned from a `*_schema` method on a model
-  def typescript_schema_type(type)
-    case type
-    when Hash
-      type_str = StringIO.new
-      type_str << '{ '
-      last_key = type.keys.count - 1
-      type.keys.each_with_index do |key, i|
-        type_str << key
-        type_str << ': '
-        type_str << typescript_schema_type(type[key])
-        if i < last_key
-          type_str << ', '
-        end
-      end
-      type_str << ' }'
-      type_str.string
-    when :integer, :float
-      'number'
-    when :json, :jsonb
-      'object'
-    else
-      type
-    end
-  end
-
-  # returns a schema string for the embedded model type
-  # @param embedded_type [Terrier::Embedded]
-  # @return [String]
-  def embedded_schema_type(embedded_type)
-    type_hash = {}
-    embedded_type.field_defs.each do |name, opts|
-      next if opts.type.nil?
-
-      type_hash[name] = ruby_type_to_typescript(opts.type, opts)
-    end
-
-    typescript_schema_type(type_hash)
-  end
-
-  def ruby_type_to_typescript(type, opts = nil)
-    if type < Terrier::Embedded
-      embedded_schema_type(type)
-    elsif type < Numeric
-      'number'
-    elsif type < Hash
-      'Record<unknown, unknown>'
-    elsif [String, Time].include?(type)
-      'string'
-    elsif type == Array
-      if opts.nil? || opts.element_type.nil?
-        'unknown[]'
-      else
-        "#{ruby_type_to_typescript(opts.element_type)}[]"
-      end
-    else
-      type
-    end
-  end
-
-  # @param ref [ActiveRecord::Reflection] a HasMany or BelongsTo reflection
-  # @return [String] the typescript type of the given reflection
-  def compute_ref_type(ref)
-    t = ref.options[:class_name].presence || ref.name.to_s.classify
-    begin
-      if t.constantize.exclude_from_frontend?
-        return nil
-      end
-    end
-    if @type_map[t]
-      t = @type_map[t]
-    else
-      t
-    end
-    is_array_type = !(ref.is_a?(ActiveRecord::Reflection::ThroughReflection) && ref.through_reflection.is_a?(ActiveRecord::Reflection::BelongsToReflection)) &&
-                    (ref.is_a?(ActiveRecord::Reflection::HasManyReflection) || ref.is_a?(ActiveRecord::Reflection::ThroughReflection))
-
-    t += "[]" if is_array_type
-    t
-  end
-
-end