forest_admin_agent 1.0.0.pre.beta.21

data/lib/forest_admin_agent/utils/query_string_parser.rb

@@ -0,0 +1,89 @@
+require 'jwt'
+require 'active_support/time'
+
+module ForestAdminAgent
+  module Utils
+    class QueryStringParser
+      include ForestAdminDatasourceToolkit::Exceptions
+      include ForestAdminDatasourceToolkit::Components
+      include ForestAdminDatasourceToolkit::Components::Query
+
+      DEFAULT_ITEMS_PER_PAGE = '15'.freeze
+      DEFAULT_PAGE_TO_SKIP = '1'.freeze
+
+      def self.parse_condition_tree(collection, args)
+        filters = begin
+          args.dig(:params, :data, :attributes, :all_records_subset_query, :filters) ||
+            args.dig(:params, :filters) || args.dig(:params, :filter)
+        rescue StandardError
+          nil
+        end
+
+        return if filters.nil?
+
+        filters = JSON.parse(filters) if filters.is_a? String
+        ConditionTreeParser.from_plain_object(collection, filters)
+        # TODO: ConditionTreeValidator::validate($conditionTree, $collection);
+      end
+
+      def self.parse_caller(args)
+        unless args.dig(:headers, 'HTTP_AUTHORIZATION')
+          # TODO: replace by http exception
+          raise ForestException, 'You must be logged in to access at this resource.'
+        end
+
+        timezone = args[:params]['timezone']
+        raise ForestException, 'Missing timezone' unless timezone
+
+        raise ForestException, "Invalid timezone: #{timezone}" unless Time.find_zone(timezone)
+
+        token = args[:headers]['HTTP_AUTHORIZATION'].split[1]
+        token_data = JWT.decode(
+          token,
+          Facades::Container.cache(:auth_secret),
+          true,
+          { algorithm: 'HS256' }
+        )[0]
+        token_data.delete('exp')
+        token_data[:timezone] = timezone
+
+        Caller.new(**token_data.transform_keys(&:to_sym))
+      end
+
+      def self.parse_projection(collection, args)
+        fields = args.dig(:params, :fields, collection.name) || ''
+
+        return ProjectionFactory.all(collection) unless fields != '' && !fields.nil?
+
+        fields = fields.split(',').map do |field_name|
+          column = collection.fields[field_name.strip]
+          column.type == 'Column' ? field_name.strip : "#{field_name.strip}:#{args[:params][:fields][field_name.strip]}"
+        end
+
+        Projection.new(fields)
+      end
+
+      def self.parse_projection_with_pks(collection, args)
+        projection = parse_projection(collection, args)
+
+        projection.with_pks(collection)
+      end
+
+      def self.parse_pagination(args)
+        items_per_pages = args.dig(:params, :data, :attributes, :all_records_subset_query, :size) ||
+                          args.dig(:params, :page, :size) || DEFAULT_ITEMS_PER_PAGE
+
+        page = args.dig(:params, :data, :attributes, :all_records_subset_query, :number) ||
+               args.dig(:params, :page, :number) || DEFAULT_PAGE_TO_SKIP
+
+        unless !items_per_pages.to_s.match(/\A[+]?\d+\z/).nil? || !page.to_s.match(/\A[+]?\d+\z/).nil?
+          raise ForestException, "Invalid pagination [limit: #{items_per_pages}, skip: #{page}]"
+        end
+
+        offset = (page.to_i - 1) * items_per_pages.to_i
+
+        Page.new(offset: offset, limit: items_per_pages.to_i)
+      end
+    end
+  end
+end

data/lib/forest_admin_agent/utils/schema/frontend_filterable.rb

@@ -0,0 +1,73 @@
+require 'digest/sha1'
+require 'json'
+
+module ForestAdminAgent
+  module Utils
+    module Schema
+      class FrontendFilterable
+        include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+
+        BASE_OPERATORS = [
+          Operators::EQUAL, Operators::NOT_EQUAL, Operators::PRESENT, Operators::BLANK
+        ].freeze
+
+        BASE_DATEONLY_OPERATORS = [
+          Operators::TODAY,
+          Operators::YESTERDAY,
+          Operators::PREVIOUS_X_DAYS,
+          Operators::PREVIOUS_WEEK,
+          Operators::PREVIOUS_MONTH,
+          Operators::PREVIOUS_QUARTER,
+          Operators::PREVIOUS_YEAR,
+          Operators::PREVIOUS_X_DAYS_TO_DATE,
+          Operators::PREVIOUS_WEEK_TO_DATE,
+          Operators::PREVIOUS_MONTH_TO_DATE,
+          Operators::PREVIOUS_QUARTER_TO_DATE,
+          Operators::PREVIOUS_YEAR_TO_DATE,
+          Operators::PAST,
+          Operators::FUTURE,
+          Operators::BEFORE_X_HOURS_AGO,
+          Operators::AFTER_X_HOURS_AGO,
+          Operators::BEFORE,
+          Operators::AFTER
+        ].freeze
+
+        DATE_OPERATORS = BASE_OPERATORS + BASE_DATEONLY_OPERATORS
+
+        OPERATOR_BY_TYPE = {
+          'Binary' => BASE_OPERATORS,
+          'Boolean' => BASE_OPERATORS,
+          'Date' => DATE_OPERATORS,
+          'Dateonly' => DATE_OPERATORS,
+          'Uuid' => BASE_OPERATORS,
+          'Enum' => BASE_OPERATORS + [Operators::IN],
+          'Number' => BASE_OPERATORS + [Operators::IN, Operators::GREATER_THAN, Operators::LESS_THAN],
+          'Timeonly' => BASE_OPERATORS + [Operators::GREATER_THAN, Operators::LESS_THAN],
+          'String' => BASE_OPERATORS +
+                      [
+                        Operators::IN,
+                        Operators::STARTS_WITH,
+                        Operators::ENDS_WITH,
+                        Operators::CONTAINS,
+                        Operators::NOT_CONTAINS
+                      ],
+          'Json' => []
+        }.freeze
+
+        def self.filterable?(type, supported_operators = [])
+          needed_operators = get_required_operators(type)
+
+          !needed_operators.empty? && needed_operators.all? { |operator| supported_operators.include?(operator) }
+        end
+
+        def self.get_required_operators(type)
+          return OPERATOR_BY_TYPE[type] if type.is_a?(String) && OPERATOR_BY_TYPE.key?(type)
+
+          return ['Includes_All'] if type.is_a? Array
+
+          []
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_agent/utils/schema/generator_collection.rb

@@ -0,0 +1,35 @@
+module ForestAdminAgent
+  module Utils
+    module Schema
+      class GeneratorCollection
+        include ForestAdminDatasourceToolkit::Utils
+
+        def self.build_schema(collection)
+          {
+            actions: {},
+            fields: build_fields(collection),
+            icon: nil,
+            integration: nil,
+            isReadOnly: collection.fields.all? { |_k, field| field.type != 'Column' || field.is_read_only },
+            isSearchable: true,
+            isVirtual: false,
+            name: collection.name,
+            onlyForRelationships: false,
+            paginationType: 'page',
+            segments: {}
+          }
+        end
+
+        def self.build_fields(collection)
+          fields = collection.fields.select do |name, _field|
+            !ForestAdminDatasourceToolkit::Utils::Schema.foreign_key?(collection, name) ||
+              ForestAdminDatasourceToolkit::Utils::Schema.primary_key?(collection, name)
+          end
+
+          fields.map { |name, _field| GeneratorField.build_schema(collection, name) }
+                .sort_by { |v| v[:field] }
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_agent/utils/schema/generator_field.rb

@@ -0,0 +1,183 @@
+module ForestAdminAgent
+  module Utils
+    module Schema
+      class GeneratorField
+        RELATION_MAP = {
+          'ManyToMany' => 'BelongsToMany',
+          'ManyToOne' => 'BelongsTo',
+          'OneToMany' => 'HasMany',
+          'OneToOne' => 'HasOne'
+        }.freeze
+
+        def self.build_schema(collection, name)
+          type = collection.fields[name].type
+
+          case type
+          when 'Column'
+            schema = build_column_schema(collection, name)
+          when 'ManyToOne', 'OneToMany', 'ManyToMany', 'OneToOne'
+            schema = build_relation_schema(collection, name)
+          end
+
+          schema.sort_by { |k, _v| k }.to_h
+        end
+
+        class << self
+          private
+
+          def build_column_schema(collection, name)
+            column = collection.fields[name]
+            is_foreign_key = ForestAdminDatasourceToolkit::Utils::Schema.foreign_key?(collection, name)
+
+            {
+              defaultValue: column.default_value,
+              enums: column.enum_values.sort,
+              field: name,
+              integration: nil,
+              inverseOf: nil,
+              # isFilterable: FrontendFilterable.filterable?(column.column_type, column.filter_operators),
+              isFilterable: true, # TODO: remove when implementing operators decorators
+              isPrimaryKey: column.is_primary_key,
+
+              # When a column is a foreign key, it is readonly.
+              # This may sound counter-intuitive: it is so that the user don't have two fields which
+              # allow updating the same foreign key in the detail-view form (fk + many to one)
+              isReadOnly: is_foreign_key || column.is_read_only,
+              isRequired: column.validations.any? { |v| v[:operator] == 'Present' },
+              isSortable: column.is_sortable,
+              isVirtual: false,
+              reference: nil,
+              type: convert_column_type(column.column_type),
+              validations: [] # TODO: FrontendValidationUtils.convertValidationList(column),
+            }
+          end
+
+          def convert_column_type(type)
+            return type if type.instance_of? String
+
+            return [convert_column_type(type.first)] if type.instance_of? Array
+
+            {
+              fields: type.map do |key, sub_type|
+                {
+                  field: key,
+                  type: convert_column_type(sub_type)
+                }
+              end
+            }
+          end
+
+          def foreign_collection_filterable?
+            # TODO: implement FrontendFilterable before
+            true
+          end
+
+          def build_many_to_many_schema(relation, collection, foreign_collection, base_schema)
+            target_name = relation.foreign_key_target
+            target_field = foreign_collection.fields[target_name]
+            through_schema = collection.datasource.collection(relation.through_collection)
+            foreign_schema = through_schema.fields[relation.foreign_key]
+            origin_key = through_schema.fields[relation.origin_key]
+
+            base_schema.merge(
+              {
+                type: [target_field.column_type],
+                defaultValue: nil,
+                isFilterable: false,
+                isPrimaryKey: false,
+                isRequired: false,
+                isReadOnly: origin_key.is_read_only || foreign_schema.is_read_only,
+                isSortable: true,
+                validations: [],
+                reference: "#{foreign_collection.name}.#{target_name}"
+              }
+            )
+          end
+
+          def build_one_to_many_schema(relation, collection, foreign_collection, base_schema)
+            target_name = relation.origin_key_target
+            target_field = collection.fields[target_name]
+            origin_key = foreign_collection.fields[relation.origin_key]
+
+            base_schema.merge(
+              {
+                type: [target_field.column_type],
+                defaultValue: nil,
+                isFilterable: false,
+                isPrimaryKey: false,
+                isRequired: false,
+                isReadOnly: origin_key.is_read_only,
+                isSortable: true,
+                validations: [],
+                reference: "#{foreign_collection.name}.#{target_name}"
+              }
+            )
+          end
+
+          def build_one_to_one_schema(relation, collection, foreign_collection, base_schema)
+            target_field = collection.fields[relation.origin_key_target]
+            key_field = foreign_collection.fields[relation.origin_key]
+
+            base_schema.merge(
+              {
+                type: key_field.column_type,
+                defaultValue: nil,
+                isFilterable: foreign_collection_filterable?,
+                isPrimaryKey: false,
+                isRequired: false,
+                isReadOnly: key_field.is_read_only,
+                isSortable: target_field.is_sortable,
+                validations: [],
+                reference: "#{foreign_collection.name}.#{relation.origin_key_target}"
+              }
+            )
+          end
+
+          def build_many_to_one_schema(relation, collection, foreign_collection, base_schema)
+            key_field = collection.fields[relation.foreign_key]
+
+            base_schema.merge(
+              {
+                type: key_field.column_type,
+                defaultValue: key_field.default_value,
+                isFilterable: foreign_collection_filterable?,
+                isPrimaryKey: false,
+                isRequired: false, # TODO: check with validations
+                isReadOnly: key_field.is_read_only,
+                isSortable: key_field.is_sortable,
+                validations: [], # TODO: FrontendValidation::convertValidationList(foreignTargetColumn)
+                reference: "#{foreign_collection.name}.#{relation.foreign_key_target}"
+              }
+            )
+          end
+
+          def build_relation_schema(collection, name)
+            relation = collection.fields[name]
+            foreign_collection = collection.datasource.collection(relation.foreign_collection)
+
+            relation_schema = {
+              field: name,
+              enums: nil,
+              integration: nil,
+              isReadOnly: nil,
+              isVirtual: false,
+              inverseOf: nil, # TODO: CollectionUtils::getInverseRelation(collection, name)
+              relationship: RELATION_MAP[relation.type]
+            }
+
+            case relation.type
+            when 'ManyToMany'
+              build_many_to_many_schema(relation, collection, foreign_collection, relation_schema)
+            when 'OneToMany'
+              build_one_to_many_schema(relation, collection, foreign_collection, relation_schema)
+            when 'OneToOne'
+              build_one_to_one_schema(relation, collection, foreign_collection, relation_schema)
+            when 'ManyToOne'
+              build_many_to_one_schema(relation, collection, foreign_collection, relation_schema)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_agent/utils/schema/schema_emitter.rb

@@ -0,0 +1,103 @@
+require 'digest/sha1'
+require 'json'
+
+module ForestAdminAgent
+  module Utils
+    module Schema
+      class SchemaEmitter
+        LIANA_NAME = "forest-rails"
+
+        LIANA_VERSION = "1.0.0-beta.21"
+
+        def self.get_serialized_schema(datasource)
+          schema_path = Facades::Container.cache(:schema_path)
+          if Facades::Container.cache(:is_production)
+            schema = if schema_path && File.exist?(schema_path)
+                       JSON.parse(File.read(schema_path), { symbolize_names: true })
+                     else
+                       # TODO: Logger::log('Warn', 'The .forestadmin-schema.json file doesn\'t exist')
+                       {
+                         meta: meta(Digest::SHA1.hexdigest('')),
+                         collections: {}
+                       }
+                     end
+          else
+            schema = generate(datasource)
+            hash = Digest::SHA1.hexdigest(schema.to_json)
+            schema = {
+              meta: meta(hash),
+              collections: schema
+            }
+
+            File.write(schema_path, JSON.pretty_generate(schema))
+          end
+
+          serialize(schema)
+        end
+
+        class << self
+          private
+
+          def generate(datasource)
+            datasource.collections
+                      .map { |_name, collection| GeneratorCollection.build_schema(collection) }
+                      .sort_by { |collection| collection[:name] }
+          end
+
+          def meta(hash)
+            {
+              liana: LIANA_NAME,
+              liana_version: LIANA_VERSION,
+              stack: {
+                engine: 'ruby',
+                engine_version: RUBY_VERSION
+              },
+              schemaFileHash: hash
+            }
+          end
+
+          def serialize(schema)
+            data = []
+            included = []
+            schema[:collections].each do |collection|
+              collection_actions = collection[:actions]
+              collection_segments = collection[:segments]
+              collection.delete(:actions)
+              collection.delete(:segments)
+
+              included << get_smart_features_by_collection('actions', collection_actions, with_attributes: true)
+              included << get_smart_features_by_collection('segments', collection_segments, with_attributes: true)
+
+              data.push(
+                {
+                  id: collection[:name],
+                  type: 'collections',
+                  attributes: collection,
+                  relationships: {
+                    actions: { data: get_smart_features_by_collection('actions', collection_actions) },
+                    segments: { data: get_smart_features_by_collection('segments', collection_actions) }
+                  }
+                }
+              )
+            end
+
+            {
+              data: data,
+              included: included.reject!(&:empty?),
+              meta: schema[:meta]
+            }
+          end
+
+          def get_smart_features_by_collection(type, data, with_attributes: false)
+            smart_features = []
+            data.each do |value|
+              smart_feature = { id: value[:id], type: type }
+              smart_feature[:attributes] = value if with_attributes
+              smart_features << smart_feature
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_agent/version.rb

@@ -0,0 +1,3 @@
+module ForestAdminAgent
+  VERSION = "1.0.0-beta.21"
+end

data/lib/forest_admin_agent.rb

@@ -0,0 +1,11 @@
+require_relative 'forest_admin_agent/version'
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect('oauth2' => 'OAuth2')
+loader.setup
+
+module ForestAdminAgent
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/sig/forest_admin_agent/auth/auth_manager.rbs

@@ -0,0 +1,14 @@
+module ForestAdminAgent
+  module Auth
+    class AuthManager
+      @oidc: ForestAdminAgent::Auth::OidcClientManager
+
+      def initialize: -> void
+      def start: (untyped rendering_id) -> untyped
+      def verify_code_and_generate_token: (untyped params) -> untyped
+
+      private
+      def get_rendering_id_from_state: (untyped state) -> untyped
+    end
+  end
+end

data/sig/forest_admin_agent/auth/oauth2/forest_provider.rbs

@@ -0,0 +1,16 @@
+module ForestAdminAgent
+  module Auth
+    module OAuth2
+      class ForestProvider
+        attr_reader rendering_id: Integer
+
+        def initialize: (Integer , Array[String]) -> void
+        def get_resource_owner: -> ForestResourceOwner
+
+        private
+        def create_resource_owner: -> ForestResourceOwner
+        def check_response: -> Array[String]
+      end
+    end
+  end
+end

data/sig/forest_admin_agent/auth/oauth2/forest_resource_owner.rbs

@@ -0,0 +1,15 @@
+module ForestAdminAgent
+  module Auth
+    module OAuth2
+      class ForestResourceOwner
+        @data: Array[String]
+        @rendering_id: Integer
+
+        def initialize: (Array[String] data, Integer rendering_id) -> void
+        def id: -> Integer
+        def expiration_in_seconds: -> Integer
+        def make_jwt: -> String
+      end
+    end
+  end
+end

data/sig/forest_admin_agent/auth/oidc_client_manager.rbs

@@ -0,0 +1,15 @@
+module ForestAdminAgent
+  module Auth
+    class OidcClientManager
+      TTL_CONFIG: Integer
+
+      def make_forest_provider: -> untyped
+
+      private
+
+      def setup_cache: -> { client_id: String, issuer: String, redirect_uri: String }
+      def register: -> Array[String]
+      def render_provider: -> untyped
+    end
+  end
+end

data/sig/forest_admin_agent/builder/agent_factory.rbs

@@ -0,0 +1,21 @@
+module ForestAdminAgent
+  module Builder
+    class AgentFactory
+      TTL_CONFIG: Integer
+      TTL_SCHEMA: Integer
+      @options: untyped
+
+      attr_reader customizer: untyped
+      attr_reader container: untyped
+      attr_reader has_env_secret: untyped
+      def setup: (Array[string] options) -> untyped
+      def build: -> nil
+
+      private
+      def send_schema: (?force: false) -> nil
+      def build_container: -> untyped
+      def build_cache: -> nil
+      def build_logger: -> untyped
+    end
+  end
+end

data/sig/forest_admin_agent/facades/container.rbs

@@ -0,0 +1,9 @@
+module ForestAdminAgent
+  module Facades
+    class Container
+      def self.instance: -> untyped
+      def self.config_from_cache: -> untyped
+      def self.get: (untyped key) -> untyped
+    end
+  end
+end

data/sig/forest_admin_agent/http/router.rbs

@@ -0,0 +1,9 @@
+module ForestAdminAgent
+  module Http
+    class Router
+      def self.routes: -> Array[String]
+      def self.actions_routes: -> Array[String]
+      def self.api_charts_routes: -> Array[String]
+    end
+  end
+end

data/sig/forest_admin_agent/routes/abstract_route.rbs

@@ -0,0 +1,12 @@
+module ForestAdminAgent
+  module Routes
+    class AbstractRoute
+      def initialize :  -> void
+      def routes: -> {}
+      def add_route: (String, String,String, String) -> void
+      def setup: -> AbstractRoute
+
+      def setup_routes: -> void
+    end
+  end
+end

data/sig/forest_admin_agent/routes/security/authentication.rbs

@@ -0,0 +1,14 @@
+module ForestAdminAgent
+  module Routes
+    module Security
+      class Authentication
+        def setup_routes: -> Authentication
+        def handle_authentication: (?Hash[untyped, untyped] args) -> {content: {authorizationUrl: String}}
+        def handle_authentication_callback: (?Hash[untyped, untyped] args) -> {content: {token: String, tokenData: String}}
+        def handle_authentication_logout: (?Hash[untyped, untyped] _args) -> {content: nil, status: Integer}
+        def auth: -> ForestAdminAgent::Auth::AuthManager
+        def get_and_check_rendering_id: (Hash[untyped, untyped] params) -> Integer
+      end
+    end
+  end
+end

data/sig/forest_admin_agent/routes/system/health_check.rbs

@@ -0,0 +1,10 @@
+module ForestAdminAgent
+  module Routes
+    module System
+      class HealthCheck
+        def setup_routes: -> HealthCheck
+        def handle_request: (?Hash[untyped, untyped] _args) -> {content: nil, status: Integer}
+      end
+    end
+  end
+end

data/sig/forest_admin_agent.rbs

@@ -0,0 +1,4 @@
+module ForestAdminAgent
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end