etna 0.1.14 → 0.1.20

data/lib/etna/clients/magma.rb

@@ -0,0 +1,4 @@
+require_relative './magma/client'
+require_relative './magma/models'
+require_relative './magma/workflows'
+require_relative './magma/formatting'

data/lib/etna/clients/magma/client.rb

@@ -0,0 +1,80 @@
+require 'net/http/persistent'
+require 'net/http/post/multipart'
+require 'singleton'
+require_relative '../../client'
+require_relative './models'
+
+module Etna
+  module Clients
+    class Magma
+      attr_reader :host, :token, :ignore_ssl
+      def initialize(host:, token:, persistent: true, ignore_ssl: false)
+        raise 'Magma client configuration is missing host.' unless host
+        raise 'Magma client configuration is missing token.' unless token
+        @etna_client = ::Etna::Client.new(
+          host,
+          token,
+          routes_available: false,
+          persistent: persistent,
+          ignore_ssl: ignore_ssl)
+        @host = host
+        @token = token
+        @ignore_ssl = ignore_ssl
+      end
+
+      # This endpoint returns models and records by name:
+      # e.g. params:
+      # {
+      #   model_name: "model_one", # or "all"
+      #   record_names: [ "rn1", "rn2" ], # or "all",
+      #   attribute_names:  "all"
+      # }
+      def retrieve(retrieval_request = RetrievalRequest.new)
+        json = nil
+        @etna_client.post('/retrieve', retrieval_request) do |res|
+          json = JSON.parse(res.body)
+        end
+
+        RetrievalResponse.new(json)
+      end
+
+      # This 'query' end point is used to fetch data by graph query
+      # See question.rb for more detail
+      def query(query_request = QueryRequest.new)
+        json = nil
+        @etna_client.post('/query', query_request) do |res|
+          json = JSON.parse(res.body)
+        end
+
+        QueryResponse.new(json)
+      end
+
+      def update(update_request = UpdateRequest.new)
+        json = nil
+        @etna_client.multipart_post('/update', update_request.encode_multipart_content) do |res|
+          json = JSON.parse(res.body)
+        end
+
+        UpdateResponse.new(json)
+      end
+
+      def update_json(update_request = UpdateRequest.new)
+        json = nil
+        @etna_client.post('/update', update_request) do |res|
+          json = JSON.parse(res.body)
+        end
+
+        UpdateResponse.new(json)
+      end
+
+      def update_model(update_model_request = UpdateModelRequest.new)
+        json = nil
+        @etna_client.post('/update_model', update_model_request) do |res|
+          json = JSON.parse(res.body)
+        end
+
+        UpdateModelResponse.new(json)
+      end
+    end
+  end
+end

data/lib/etna/clients/magma/formatting.rb

@@ -0,0 +1 @@
+require_relative 'formatting/models_csv'

data/lib/etna/clients/magma/formatting/models_csv.rb

@@ -0,0 +1,354 @@
+require 'ostruct'
+require_relative '../../../csvs'
+
+module Etna
+  module Clients
+    class Magma
+      module ModelsCsv
+        module Prettify
+          def prettify(name)
+            name.split('_').map(&:capitalize).join(' ')
+          end
+        end
+
+        class Exporter < Etna::CsvExporter
+          include Prettify
+
+          def initialize
+            super([
+                :comments,
+                :model_name, :identifier, :parent_model_name, :parent_link_type,
+                :attribute_name,
+                :new_attribute_name,
+                :attribute_type,
+                :link_model_name,
+                :description,
+                :display_name,
+                :format_hint,
+                :restricted,
+                :read_only,
+                :options,
+                :match,
+                :attribute_group,
+                :hidden,
+                :unique,
+                :matrix_constant,
+            ])
+          end
+
+          def write_models(models, model_keys = models.model_keys.sort, output_io: nil, filename: nil)
+            with_row_writeable(filename: filename, output_io: output_io) do |row_writeable|
+              write_model_rows(models, model_keys, row_writeable)
+            end
+          end
+
+          def write_model_rows(models, model_keys, row_writeable)
+            ensure_parents(models, model_keys, row_writeable)
+
+            matrix_constants = {}
+            model_keys.each { |model_name| each_model_row(models, model_name, matrix_constants, row_writeable) }
+
+            matrix_constants.each do |digest, options|
+              row_writeable.write
+              row_writeable.write(matrix_constant: COPY_OPTIONS_SENTINEL + digest)
+              options.each do |option|
+                row_writeable.write(matrix_constant: option)
+              end
+            end
+          end
+
+          def ensure_parents(models, model_keys, row_writeable)
+            q = model_keys.dup
+            seen = Set.new
+
+            until q.empty?
+              model_key = q.shift
+              next if model_key.nil?
+              next if seen.include?(model_key)
+              seen.add(model_key)
+
+              # For models that are only part of the trunk, but not of the tree of model_keys,
+              # we still need their basic information (identifier / parent) for validation and for
+              # potentially creating the required tree dependencies to connect it to a remote tree.
+              unless model_keys.include?(model_key)
+                each_model_trunk_row(models, model_key, row_writeable)
+              end
+
+              q.push(*models.model(model_key).template.all_linked_model_names)
+            end
+          end
+
+          def each_model_trunk_row(models, model_name, row_writeable)
+            return unless (model = models.model(model_name))
+
+            # Empty link for better visual separation
+            row_writeable.write
+            row_writeable.write(model_name: model_name)
+
+            if !model.template.parent.nil?
+              parent_model = models.model(model.template.parent)
+              reciprocal = models.find_reciprocal(model: model, link_model: parent_model)
+
+              row_writeable.write(
+                  identifier: model.template.identifier,
+                  parent_model_name: model.template.parent,
+                  parent_link_type: reciprocal.attribute_type.to_s
+              )
+            else
+              row_writeable.write(
+                  identifier: model.template.identifier,
+              )
+            end
+          end
+
+          def each_model_row(models, model_name, matrix_constants, row_writeable)
+            return unless (model = models.model(model_name))
+
+            each_model_trunk_row(models, model_name, row_writeable)
+            model.template.attributes.all.each do |attribute|
+              each_attribute_row(models, model, attribute, matrix_constants, row_writeable)
+            end
+          end
+
+          def each_attribute_row(models, model, attribute, matrix_constants, row_writeable)
+            if attribute.attribute_type == Etna::Clients::Magma::AttributeType::IDENTIFIER
+              # Identifiers for models whose parent link type ends up being a table are non configurable, so we don't
+              # want to include them in the CSV.
+              if models.find_reciprocal(model: model, link_attribute_name: model.template.parent)&.attribute_type == Etna::Clients::Magma::AttributeType::TABLE
+                return
+              end
+            else
+              return unless Etna::Clients::Magma::AttributeValidator.valid_add_row_attribute_types.include?(attribute.attribute_type)
+            end
+
+            options = attribute.options&.join(', ')
+            if attribute.attribute_type == Etna::Clients::Magma::AttributeType::MATRIX
+              # Matrix attribute validations are massive, and functional.  For now, we don't support showing and editing
+              # them inline with this spreadsheet.  In the future, I think we should possibly introduce the concept of
+              # CONSTANTS or Matrix Types that are managed separately.
+              options = options || ''
+              digest = Digest::MD5.hexdigest(options)
+              matrix_constants[digest] ||= options.split(',').map(&:strip)
+
+              options = COPY_OPTIONS_SENTINEL + digest
+            end
+
+            row_writeable.write(
+                attribute_name: attribute.name,
+                attribute_type: attribute.attribute_type,
+                link_model_name: attribute.link_model_name,
+                reciprocal_link_type: models.find_reciprocal(model: model, attribute: attribute)&.attribute_type,
+                description: attribute.desc,
+                display_name: attribute.display_name,
+                match: attribute.match,
+                format_hint: attribute.format_hint,
+                restricted: attribute.restricted,
+                read_only: attribute.read_only,
+                options: options,
+                attribute_group: attribute.attribute_group,
+                hidden: attribute.hidden,
+                unique: attribute.unique,
+            )
+          end
+        end
+
+        class ModelsChangeset < Struct.new(:models, :renames, :matrix_constants, keyword_init: true)
+          def initialize(*args)
+            super
+
+            self.models ||= Models.new
+            self.renames ||= {}
+            self.matrix_constants ||= {}
+          end
+
+          def build_renames(model_name)
+            renames[model_name] ||= {}
+          end
+        end
+
+        COPY_OPTIONS_SENTINEL = '$copy_from_original$'
+
+        class Importer < Etna::CsvImporter
+          include Prettify
+
+          # Columns of the row, _after format_row is called_, that should be applied to an attribute.
+          # This should line up with the attribute names _on the model itself_.
+          ATTRIBUTE_ROW_ENTRIES = [
+              :attribute_type,
+              :link_model_name, :desc,
+              :display_name, :format_hint,
+              :restricted, :read_only,
+              :validation, :attribute_group,
+              :hidden, :unique,
+          ]
+
+          def initialize
+            super(&method(:format_row))
+          end
+
+          def format_row(row)
+            replace_row_column(row, :attribute_type) { |s| AttributeType.new(s) }
+            replace_row_column(row, :desc) { row.delete(:description) }
+            replace_row_column(row, :restricted, &COLUMN_AS_BOOLEAN)
+            replace_row_column(row, :read_only, &COLUMN_AS_BOOLEAN)
+            replace_row_column(row, :options) { |s| {"type" => "Array", "value" => s.split(',').map(&:strip)} }
+            replace_row_column(row, :match) { |s| {"type" => "Regexp", "value" => Regexp.new(s).source} }
+            replace_row_column(row, :validation) { row[:options] || row[:match] }
+            replace_row_column(row, :hidden, &COLUMN_AS_BOOLEAN)
+            replace_row_column(row, :unique, &COLUMN_AS_BOOLEAN)
+          end
+
+          def process_row(row_processor, changeset)
+            models = changeset.models
+
+            process_matrix_constants(changeset, row_processor)
+            process_model_config(models, row_processor)
+            process_parent_config(models, row_processor)
+            process_attribute_properties(changeset, row_processor)
+          end
+
+          def prepare_changeset(filename: nil, input_io: nil, &validation_err_block)
+            ModelsChangeset.new.tap do |changeset|
+              context = {}
+              each_csv_row(filename: filename, input_io: input_io) do |row, lineno|
+                p = NestedRowProcessor.new(row, lineno, context)
+                process_row(p, changeset)
+              end
+
+              # After configuring attributes, set defaults for certain attribute properties.
+              changeset.models.all.each do |model|
+                model.template.attributes.all.each do |attribute|
+                  attribute.set_field_defaults!
+                end
+              end
+            end
+          rescue ImportError => e
+            validation_err_block.call(e.message)
+          end
+
+
+          private
+
+          def process_model_config(models, row_processor)
+            row_processor.process(:model_name) do |model_name|
+              models.build_model(model_name).build_template.tap { |t| t.name = model_name }
+            end
+            row_processor.process(:identifier, :model_name) do |identifier, template|
+              template.identifier = identifier
+            end
+          end
+
+          def process_parent_config(models, row_processor)
+            row_processor.process(:parent_model_name, :model_name) do |parent_model_name, template|
+              if template.parent && !template.parent.empty? && template.parent != parent_model_name
+                raise ImportError.new("Model #{template.name} was provided multiple parent_model_names: #{template.parent} and #{parent_model_name}")
+              end
+
+              template.parent = parent_model_name
+
+              template.build_attributes.build_attribute(template.parent).tap do |parent_att|
+                parent_att.name = parent_att.attribute_name = parent_model_name
+                parent_att.attribute_type = Etna::Clients::Magma::AttributeType::PARENT
+                parent_att.link_model_name = parent_model_name
+                parent_att.desc = prettify(parent_model_name)
+                parent_att.display_name = prettify(parent_model_name)
+              end
+            end
+
+            row_processor.process(:parent_link_type, :model_name, :parent_model_name) do |parent_link_type, template|
+              reciprocal = models.find_reciprocal(model_name: template.name, link_attribute_name: template.parent)
+              if reciprocal && reciprocal.attribute_type.to_s != parent_link_type
+                raise ImportError.new("Model #{template.name} was provided multiple parent_link_types: #{reciprocal.attribute_type} and #{parent_link_type}")
+              end
+
+              if reciprocal && reciprocal.attribute_name != template.name
+                raise ImportError.new("Model #{template.name} is linked to #{template.parent}, but the reciprocal link is misnamed as '#{reciprocal.attribute_name}'.")
+              end
+
+              models.build_model(template.parent).tap do |parent_model|
+                parent_model_attribute_by_model_name = parent_model.build_template.build_attributes.attribute(template.name)
+                if parent_model_attribute_by_model_name && !reciprocal
+                  raise ImportError.new("Model #{template.parent} is linked as a parent to #{template.name}, but it already has an attribute named #{template.name} #{parent_model_attribute_by_model_name.raw}.")
+                end
+
+                parent_model.build_template.build_attributes.build_attribute(template.name).tap do |attr|
+                  attr.attribute_name = attr.name = template.name
+                  attr.attribute_type = parent_link_type
+                  attr.link_model_name = template.name
+                  attr.desc = prettify(template.name)
+                  attr.display_name = prettify(template.name)
+                end
+              end
+            end
+          end
+
+          def process_matrix_constants(changeset, row_processor)
+            row_processor.process(:matrix_constant) do |matrix_constant|
+              # Lines that start with the sentinel are a distinct 'group'
+              if matrix_constant.start_with?(COPY_OPTIONS_SENTINEL)
+                matrix_constant = matrix_constant.slice((COPY_OPTIONS_SENTINEL.length)..-1)
+                changeset.matrix_constants[matrix_constant] = []
+              else
+                # Until the sentinel is seen again, all further entries belong to the set.
+                changeset.matrix_constants[changeset.matrix_constants.keys.last] << matrix_constant
+              end
+
+              matrix_constant
+            end
+          end
+
+          def process_attribute_properties(changeset, row_processor)
+            models = changeset.models
+
+            row_processor.process(:attribute_name, :model_name) do |attribute_name, template|
+              attributes = template.build_attributes
+
+              existing_attribute = attributes.attribute(attribute_name)
+              if existing_attribute
+                if existing_attribute.attribute_type != Etna::Clients::Magma::AttributeType::COLLECTION
+                  raise ImportError.new("Attribute #{attribute_name} of model #{template.name} has duplicate definitions!")
+                end
+
+                # Clear its definition; implicit attributes are overwritten by explicit definitions if they exist.
+                attributes.raw.delete(attribute_name)
+              end
+
+              attributes.build_attribute(attribute_name).tap { |att| att.name = att.attribute_name = attribute_name }
+            end
+
+            row_processor.process(:new_attribute_name, :attribute_name, :model_name) do |new_attribute_name, att, template|
+              renames = changeset.build_renames(template.name)
+              if renames.include?(att.name) && renames[att.name] != new_attribute_name
+                raise ImportError.new("Found multiple new_attribute_name values for #{template.name}'s #{att.name}': #{new_attribute_name} or #{renames[att.name]}?")
+              end
+
+              renames[att.attribute_name] = new_attribute_name
+            end
+
+            ATTRIBUTE_ROW_ENTRIES.each do |prop_name|
+              row_processor.process(prop_name, :model_name, :attribute_name) do |value, template, att|
+                if att.raw.include?(prop_name.to_s)
+                  raise ImportError.new("Value for #{prop_name} on attribute #{att.attribute_name} has duplicate definitions!")
+                end
+
+                att.send(:"#{prop_name}=", value)
+
+                if att.attribute_type && att.link_model_name
+                  if att.attribute_type == Etna::Clients::Magma::AttributeType::LINK && models.find_reciprocal(model_name: template.name, attribute: att).nil?
+                    models.build_model(att.link_model_name).build_template.build_attributes.build_attribute(template.name).tap do |rec_att|
+                      rec_att.attribute_name = rec_att.name = template.name
+                      rec_att.display_name = prettify(template.name)
+                      rec_att.desc = prettify(template.name)
+                      rec_att.attribute_type = Etna::Clients::Magma::AttributeType::COLLECTION
+                      rec_att.link_model_name = template.name
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/etna/clients/magma/models.rb

@@ -0,0 +1,630 @@
+require 'ostruct'
+require_relative '../../json_serializable_struct'
+require_relative '../../multipart_serializable_nested_hash'
+require_relative '../../directed_graph'
+require_relative '../enum'
+
+# TODO:  In the near future, I'd like to transition to specifying apis via SWAGGER and generating model stubs from the
+# common definitions.  For nowe I've written them out by hand here.
+module Etna
+  module Clients
+    class Magma
+      class RetrievalRequest < Struct.new(:model_name, :attribute_names, :record_names, :project_name, :page, :page_size, :order, :filter, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({model_name: 'all', attribute_names: 'all', record_names: []}.update(params))
+        end
+      end
+
+      class QueryRequest < Struct.new(:query, :project_name, keyword_init: true)
+        include JsonSerializableStruct
+      end
+
+      class UpdateRequest < Struct.new(:revisions, :project_name, keyword_init: true)
+        include JsonSerializableStruct
+        include MultipartSerializableNestedHash
+
+        def initialize(**params)
+          super({revisions: {}}.update(params))
+        end
+
+        def update_revision(model_name, record_name, attrs)
+          revision = revisions[model_name] ||= {}
+          record = revision[record_name] ||= {}
+          record.update(attrs)
+        end
+
+        def append_table(parent_model_name, parent_record_name, model_name, attrs, attribute_name = model_name)
+          parent_revision = update_revision(parent_model_name, parent_record_name, {})
+          table = parent_revision[attribute_name] ||= []
+          id = "::#{model_name}#{(revisions[model_name] || {}).length + 1}"
+          table << id
+          update_revision(model_name, id, attrs)
+          id
+        end
+      end
+
+      class UpdateModelRequest < Struct.new(:project_name, :actions, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**params)
+          super({actions: []}.update(params))
+        end
+
+        def add_action(action)
+          actions << action
+        end
+      end
+
+      class AddModelAction < Struct.new(:action_name, :model_name, :parent_model_name, :parent_link_type, :identifier, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**args)
+          super({action_name: 'add_model'}.update(args))
+        end
+      end
+
+      class AddAttributeAction < Struct.new(:action_name, :model_name, :attribute_name, :type, :description, :display_name, :format_hint, :hidden, :index, :link_model_name, :read_only, :attribute_group, :restricted, :unique, :validation, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**args)
+          super({action_name: 'add_attribute'}.update(args))
+        end
+
+        def attribute_type=(val)
+          self.type = val
+        end
+
+        def attribute_type
+          self.type
+        end
+
+        def desc=(val)
+          self.description = val
+        end
+
+        def desc
+          self.description
+        end
+      end
+
+      class AddLinkAction < Struct.new(:action_name, :links, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**args)
+          super({action_name: 'add_link', links: []}.update(args))
+        end
+      end
+
+      class AddLinkDefinition < Struct.new(:type, :model_name, :attribute_name, keyword_init: true)
+        include JsonSerializableStruct
+      end
+
+      class AddProjectAction < Struct.new(:action_name, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**args)
+          super({action_name: 'add_project'}.update(args))
+        end
+      end
+
+      class UpdateAttributeAction < Struct.new(:action_name, :model_name, :attribute_name, :description, :display_name, :format_hint, :hidden, :index, :link_model_name, :read_only, :attribute_group, :restricted, :unique, :validation, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**args)
+          super({action_name: 'update_attribute'}.update(args))
+        end
+
+        def desc=(val)
+          self.description = val
+        end
+
+        def desc
+          self.description
+        end
+
+        def as_json
+          super(keep_nils: true)
+        end
+      end
+
+      class RenameAttributeAction < Struct.new(:action_name, :model_name, :attribute_name, :new_attribute_name, keyword_init: true)
+        include JsonSerializableStruct
+
+        def initialize(**args)
+          super({action_name: 'rename_attribute'}.update(args))
+        end
+      end
+
+      class AttributeValidation < Struct.new(:type, :value, :begin, :end, keyword_init: true)
+        include JsonSerializableStruct
+      end
+
+      class AttributeValidationType < String
+        include Enum
+        REGEXP = AttributeValidationType.new("Regexp")
+        ARRAY = AttributeValidationType.new("Array")
+        RANGE = AttributeValidationType.new("Range")
+      end
+
+      class RetrievalResponse
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def models
+          Models.new(raw['models'])
+        end
+      end
+
+      class UpdateModelResponse < RetrievalResponse
+      end
+
+      class QueryResponse
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def answer
+          raw['answer']
+        end
+
+        def format
+          raw['format']
+        end
+
+        def type
+          raw['type']
+        end
+      end
+
+      class UpdateResponse < RetrievalResponse
+      end
+
+      class Project
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def models
+          Models.new(raw['models'])
+        end
+      end
+
+      class Models
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def model_keys
+          raw.keys
+        end
+
+        def build_model(model_key)
+          Model.new(raw[model_key] ||= {})
+        end
+
+        def model(model_key)
+          return nil unless raw.include?(model_key)
+          Model.new(raw[model_key])
+        end
+
+        def all
+          raw.values.map { |r| Model.new(r) }
+        end
+
+        def +(other)
+          raw_update = {}
+          raw_update[other.name] = other.raw
+          Models.new({}.update(raw).update(raw_update))
+        end
+
+        # Can look up reciprocal links by many means.  At minimum, a source model or model name must be provided,
+        # and either a link_attribute_name, attribute, or link_model.
+        def find_reciprocal(
+            model_name: nil,
+            model: self.model(model_name),
+            link_attribute_name: nil,
+            attribute: model&.template&.attributes&.attribute(link_attribute_name),
+            link_model: self.model(attribute&.link_model_name)
+        )
+          return nil if model.nil? || model.name.nil?
+          link_model&.template&.attributes&.all&.find { |a| a.link_model_name == model.name }
+        end
+
+        def to_directed_graph(include_casual_links = false)
+          graph = ::DirectedGraph.new
+
+          model_keys.sort.each do |model_name|
+            graph.add_connection(model(model_name).template.parent, model_name)
+
+            if include_casual_links
+              attributes = model(model_name).template.attributes
+              attributes.attribute_keys.each do |attribute_name|
+                attribute = attributes.attribute(attribute_name)
+
+                linked_model_name = attribute.link_model_name
+                if linked_model_name
+                  if attribute.attribute_type == AttributeType::PARENT
+                    graph.add_connection(linked_model_name, model_name)
+                  elsif attribute.attribute_type == AttributeType::COLLECTION
+                    graph.add_connection(model_name, linked_model_name)
+                  elsif attribute.attribute_type == AttributeType::CHILD
+                    graph.add_connection(model_name, linked_model_name)
+                  elsif attribute.attribute_type == AttributeType::LINK
+                    graph.add_connection(model_name, linked_model_name)
+                  end
+                end
+              end
+            end
+          end
+
+          graph
+        end
+      end
+
+      class Model
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def build_template
+          Template.new(raw['template'] ||= {})
+        end
+
+        def documents
+          Documents.new(raw['documents'])
+        end
+
+        def template
+          Template.new(raw['template'])
+        end
+
+        def name
+          @raw.dig('template', 'name')
+        end
+
+        def count
+          raw['count'] || 0
+        end
+      end
+
+      class Documents
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def document_keys
+          raw.keys
+        end
+
+        def +(other)
+          Documents.new({}.update(raw).update(other.raw))
+        end
+
+        def document(document_key)
+          return nil unless raw.include?(document_key)
+          raw[document_key]
+        end
+      end
+
+      class Template
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def name
+          raw['name'] || ""
+        end
+
+        def name=(val)
+          raw['name'] = val.to_s
+        end
+
+        def identifier
+          raw['identifier'] || ""
+        end
+
+        def version
+          raw['version'] || 0
+        end
+
+        def version=(val)
+          raw['version'] = val
+        end
+
+        def identifier=(val)
+          raw['identifier'] = val
+        end
+
+        def parent
+          raw['parent']
+        end
+
+        def parent=(val)
+          raw['parent'] = val
+        end
+
+        def attributes
+          Attributes.new(raw['attributes'] ||= {})
+        end
+
+        def build_attributes
+          Attributes.new(raw['attributes'] ||= {})
+        end
+
+        def dictionary
+          Dictionary.new(raw['dictionary'] ||= {})
+        end
+
+        def build_dictionary
+          Dictionary.new(raw['dictionary'] ||= {})
+        end
+
+        def all_linked_model_names
+          models = [ self.parent, ] + build_attributes.all.map { |v| v.link_model_name }
+          models.select { |m| !m.nil? }.uniq
+        end
+      end
+
+      class Dictionary
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def dictionary_keys
+          raw.keys
+        end
+
+        def dictionary_model
+          raw['dictionary_model']
+        end
+
+        def dictionary_model=(val)
+          @raw['dictionary_model'] = val
+        end
+
+        def model_name
+          raw['model_name']
+        end
+
+        def model_name=(val)
+          @raw['model_name'] = val
+        end
+
+        def attributes
+          raw['attributes']
+        end
+
+        def attributes=(val)
+          @raw['attributes'] = val
+        end
+      end
+
+      class Attributes
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        def attribute_keys
+          raw.keys
+        end
+
+        def attribute(attribute_key)
+          return nil unless raw.include?(attribute_key)
+          Attribute.new(raw[attribute_key])
+        end
+
+        def build_attribute(key)
+          Attribute.new(raw[key] ||= {})
+        end
+
+        def all
+          raw.values.map { |r| Attribute.new(r) }
+        end
+      end
+
+      class Attribute
+        attr_reader :raw
+
+        def initialize(raw = {})
+          @raw = raw
+        end
+
+        # Sets certain attribute fields which are implicit, even when not set, to match server behavior.
+        def set_field_defaults!
+          @raw.replace({
+              'hidden' => false,
+              'read_only' => false,
+              'restricted' => false,
+              'validation' => nil,
+          }.merge(@raw))
+        end
+
+        def name
+          @raw['name'] || ""
+        end
+
+        def name=(val)
+          @raw['name'] = val
+        end
+
+        def attribute_name
+          @raw['attribute_name'] || ""
+        end
+
+        def attribute_name=(val)
+          @raw['attribute_name'] = val
+        end
+
+        def attribute_type
+          @raw['attribute_type'] && AttributeType.new(@raw['attribute_type'])
+        end
+
+        def is_project_name_reference?(model_name)
+          return true if model_name == 'project' && attribute_type == AttributeType::IDENTIFIER
+          return true if link_model_name == 'project'
+          false
+        end
+
+        def attribute_type=(val)
+          val = val.to_s if val
+          @raw['attribute_type'] = val
+        end
+
+        def link_model_name
+          @raw['link_model_name']
+        end
+
+        def link_model_name=(val)
+          @raw['link_model_name'] = val
+        end
+
+        def unique
+          raw['unique']
+        end
+
+        def unique=(val)
+          raw['unique'] = val
+        end
+
+        def desc
+          raw['desc']
+        end
+
+        def desc=(val)
+          @raw['desc'] = val
+        end
+
+        def display_name
+          raw['display_name']
+        end
+
+        def display_name=(val)
+          raw['display_name'] = val
+        end
+
+        def match
+          raw['match']
+        end
+
+        def restricted
+          raw['restricted']
+        end
+
+        def restricted=(val)
+          raw['restricted'] = val
+        end
+
+        def format_hint
+          raw['format_hint']
+        end
+
+        def format_hint=(val)
+          raw['format_hint'] = val
+        end
+
+        def read_only
+          raw['read_only']
+        end
+
+        def read_only=(val)
+          raw['read_only'] = val
+        end
+
+        def attribute_group
+          raw['attribute_group']
+        end
+
+        def attribute_group=(val)
+          raw['attribute_group'] = val
+        end
+
+        def hidden
+          raw['hidden']
+        end
+
+        def hidden=(val)
+          raw['hidden'] = val
+        end
+
+        def validation
+          raw['validation']
+        end
+
+        def validation=(val)
+          raw['validation'] = val
+        end
+
+        def options
+          raw['options']
+        end
+
+        # NOTE!  The Attribute class returns description as desc, where as actions take it in as description.
+        # There are shortcut methods that try to handle this on the action class side of things.  Ideally we would
+        # make this more consistent in the near future.
+        COPYABLE_ATTRIBUTE_ATTRIBUTES = [
+            :attribute_name, :attribute_type, :desc, :display_name, :format_hint,
+            :hidden, :link_model_name, :read_only, :attribute_group, :unique, :validation,
+            :restricted
+        ]
+
+        EDITABLE_ATTRIBUTE_ATTRIBUTES = UpdateAttributeAction.members & COPYABLE_ATTRIBUTE_ATTRIBUTES
+
+        def self.copy(source, dest, attributes: COPYABLE_ATTRIBUTE_ATTRIBUTES)
+          attributes.each do |attr_name|
+            next unless dest.respond_to?(:"#{attr_name}=")
+            source_v = source.send(attr_name)
+            dest.send(:"#{attr_name}=", source_v)
+          end
+        end
+      end
+
+      class AttributeType < String
+        include Enum
+        STRING = AttributeType.new("string")
+        DATE_TIME = AttributeType.new("date_time")
+        BOOLEAN = AttributeType.new("boolean")
+        CHILD = AttributeType.new("child")
+        COLLECTION = AttributeType.new("collection")
+        FILE = AttributeType.new("file")
+        FILE_COLLECTION = AttributeType.new("file_collection")
+        FLOAT = AttributeType.new("float")
+        IDENTIFIER = AttributeType.new("identifier")
+        IMAGE = AttributeType.new("image")
+        INTEGER = AttributeType.new("integer")
+        LINK = AttributeType.new("link")
+        MATCH = AttributeType.new("match")
+        MATRIX = AttributeType.new("matrix")
+        PARENT = AttributeType.new("parent")
+        TABLE = AttributeType.new("table")
+      end
+
+      class ParentLinkType < String
+        include Enum
+        CHILD = ParentLinkType.new("child")
+        COLLECTION = ParentLinkType.new("collection")
+        TABLE = ParentLinkType.new("table")
+      end
+    end
+  end
+end