cdp-sdk 0.14.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 97a8b2da1a07af9656615dc77738e79594b7081079bc2f8a78d94b310306b3b2
+  data.tar.gz: 3ded4dda9290e4b64e3f7a0d0ea3c9a3cdf5ed100b88ab4b297a91304f0ae5ef
+SHA512:
+  metadata.gz: 8aecaabd802e0277a8ccb7191e32e37db63577e616f8e3ef29034495f0bb84ce3145f336608b696e7d301ded2e532d2ff1ec2002b81790b44c341a5c8ca386f2
+  data.tar.gz: 5a0baf5992476d3ab861b3758f02d64b8a04481c69c97622e348145fab9d9c514b41cd7f488981b525100040db77349b4cad0da32fea910fed1ecee81a75e923

data/lib/cdp/builder.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module CDP
+  class Builder
+    def initialize(tenant_id:, schema:)
+      @tenant_id = tenant_id
+
+      filtered_schema = schema.to_hash
+      filtered_schema[:entity_types].each do |entity_type|
+        entity_type[:field_types] = entity_type[:field_types].each_with_object({}) do |field_type, memo|
+           memo[field_type[:name]] = field_type.except(:custom_data)
+        end
+      end
+
+      filtered_schema[:event_types].each do |event_type|
+        event_type[:field_types] = event_type[:field_types].each_with_object({}) do |field_type, memo|
+          memo[field_type[:name]] = field_type.except(:custom_data)
+       end
+      end
+
+      @schema = filtered_schema
+      @builders = generate_builders_map
+    end
+
+    def if_created(source)
+      Builders::AfterCreated.new(self, source)
+    end
+
+    def create_transaction
+      CDP::Transaction.new(
+        tenant_id: @tenant_id,
+        commands: []
+      )
+    end
+
+    def method_missing(method_name, *_args)
+      method_name_str = method_name.to_s.upcase
+
+      return @builders[method_name_str] if @builders.key?(method_name_str)
+
+      super
+    end
+
+    private
+
+    # def get_schema!(tenant_id)
+    #   context = Microservice::Toolkit::Context.create(tenant_id)
+    #   response = CDP::SchemaClient::Client.get_schema(context, tenant_id)
+
+    #   raise "Failed to get schema from tenant_id: #{tenant_id}" unless response[:success]
+
+    #   response[:schema]
+    # end
+
+    def generate_builders_map
+      builders = {}
+
+      event_types = @schema[:event_types]
+      event_types.each do |event_schema|
+        builders[event_schema[:name]] = Builders::Event.new(event_schema: event_schema, tenant_id: @tenant_id)
+      end
+
+      entity_types = @schema[:entity_types]
+
+      entity_types.each do |entity_schema|
+        entity_relations = @schema[:relation_types].select do |relation|
+          relation[:source_entity_type_name] == entity_schema[:name]
+        end
+
+        builders[entity_schema[:name]] =
+          Builders::Entity.new(entity_schema: entity_schema, tenant_id: @tenant_id, entity_relations: entity_relations)
+      end
+
+      builders
+    end
+  end
+end

data/lib/cdp/builders/after_created.rb

@@ -0,0 +1,28 @@
+module CDP
+  module Builders
+    class AfterCreated
+      def initialize(builder, source)
+        raise ArgumentError, 'Unsupported multiple commands' if source.commands.size > 1
+        raise ArgumentError, 'Only supported on upsert' if source.commands.first&.upsert_entity.blank?
+        @builder = builder
+        @source = source
+      end
+
+      def relate_to(target)
+        raise ArgumentError, 'Unsupported multiple commands' if target.commands.size > 1
+        raise ArgumentError, 'Supported only create entity' unless target.commands.first&.create_entity.present?
+
+        @source.commands.first.upsert_entity.if_created_relate_with << target.commands.first
+        @source
+      end
+
+      def create_event(target)
+        raise ArgumentError, 'Unsupported multiple commands' if target.commands.size > 1
+        raise ArgumentError, 'Supported only create event' unless target.commands.first&.create_event.present?
+
+        @source.commands.first.upsert_entity.if_created_create_event << target.commands.first
+        @source
+      end
+    end
+  end
+end

data/lib/cdp/builders/entity.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'cdp/builders/value'
+
+module CDP
+  module Builders
+    class Entity
+      include Value
+
+      ID_FIELD = 'entity_uuid'
+      private_constant :ID_FIELD
+
+      def initialize(tenant_id:, entity_schema:, entity_relations:)
+        @tenant_id = tenant_id
+        @entity_schema = entity_schema
+        @entity_relations = entity_relations
+      end
+
+      def create(attributes)
+        validate_attributes_type(attributes)
+
+        validation_result = Validator.new(field_schema: @entity_schema).create(attributes: attributes)
+
+        raise ::CDP::InvalidEntityError, validation_result.errors if validation_result.failed?
+
+        entity_uuid = attributes.delete :entity_uuid
+        create_entity = CDP::CreateEntity.new(
+          entity_type: @entity_schema[:name],
+          entity_uuid: entity_uuid,
+          timestamp: Time.now.utc,
+          payload: build_payload_with_ref(@entity_schema, attributes)
+        )
+        build_execute_request({ create_entity: create_entity })
+      end
+
+      def update(attributes, condition:)
+        validate_condition(condition)
+        validate_attributes_type(attributes)
+
+        validation_result = Validator.new(field_schema: @entity_schema).update(attributes: attributes)
+        raise ::CDP::InvalidEntityError, validation_result.errors if validation_result.failed?
+
+        update_entity = CDP::UpdateEntity.new(
+          entity_type: @entity_schema[:name],
+          timestamp: Time.now.utc,
+          field_condition: build_condition(condition),
+          payload: build_payload(attributes)
+        )
+        build_execute_request({ update_entity: update_entity })
+      end
+
+      def upsert(payload, unique_by:)
+        validate_attributes_type(payload)
+
+        validation_result = Validator.new(field_schema: @entity_schema).upsert(attributes: payload)
+        raise ::CDP::InvalidEntityError, validation_result.errors if validation_result.failed?
+
+        upsert_entity = CDP::UpsertEntity.new(
+          entity_type: @entity_schema[:name],
+          timestamp: Time.now.utc,
+          unique_by: normalize_unique_by(payload, unique_by),
+          payload: build_payload_with_ref(@entity_schema, payload)
+        )
+        build_execute_request({ upsert_entity: upsert_entity })
+      end
+
+      def create_if_not_exists(payload, unique_by:)
+        create_if_not_exists = CDP::CreateIfNotExistsEntity.new(
+          entity_type: @entity_schema[:name],
+          timestamp: Time.now.utc,
+          unique_by: normalize_unique_by(payload, unique_by),
+          payload: build_payload_with_ref(@entity_schema, payload)
+        )
+        build_execute_request({ create_if_not_exists_entity: create_if_not_exists })
+      end
+
+      def delete(condition:)
+        validate_condition(condition)
+
+        delete_entity = CDP::DeleteEntity.new(
+          entity_type: @entity_schema[:name],
+          timestamp: Time.now.utc,
+          field_condition: build_condition(condition)
+        )
+        build_execute_request({ delete_entity: delete_entity })
+      end
+
+      def append_set_values(condition:, field_name:, values:, timestamp: Time.now.utc)
+        validate_condition(condition)
+        validate_set_field(field_name)
+
+        append_values = CDP::AppendValuesToEntitySet.new(
+          entity_type: @entity_schema[:name],
+          timestamp: timestamp,
+          field_condition: build_condition(condition),
+          field_name: field_name,
+          values: build(@entity_schema, field_name, values).array_value
+        )
+        build_execute_request({ append_values_to_entity_set: append_values })
+      end
+
+      def delete_set_values(condition:, field_name:, values:, timestamp: Time.now.utc)
+        validate_condition(condition)
+        validate_set_field(field_name)
+
+        delete_values = CDP::DeleteValuesFromEntitySet.new(
+          entity_type: @entity_schema[:name],
+          timestamp: timestamp,
+          field_condition: build_condition(condition),
+          field_name: field_name,
+          values: build(@entity_schema, field_name, values).array_value
+        )
+        build_execute_request({ delete_values_from_entity_set: delete_values })
+      end
+
+      def method_missing(method_name, args)
+        method_name_str = method_name.to_s.downcase
+
+        builders = entity_relations_builders
+        if builders.include?(method_name_str)
+          source_id = args.fetch(:source_id)
+          target_id = args.fetch(:target_id)
+          return builders[method_name_str].call(source_id, target_id)
+        end
+
+        super
+      end
+
+      def exists?(_condition)
+        raise NoMethodError, "The 'exists?' for entities is not implemented"
+      end
+
+      private
+
+      def normalize_unique_by(payload, unnormalized_unique_by)
+        unique_by = Array(unnormalized_unique_by).compact.map(&:to_sym)
+        raise ArgumentError, 'Field unique by empty' if unique_by.empty?
+
+        payload_keys = payload.symbolize_keys.keys
+        raise ArgumentError, 'Field unique by is required in payload' unless unique_by.all? do |field|
+                                                                               payload_keys.include?(field)
+                                                                             end
+
+        unique_by
+      end
+
+      def validate_attributes_type(attributes)
+        raise ArgumentError, 'attributes should be a Hash' unless attributes.is_a?(Hash)
+      end
+
+      def validate_condition(condition)
+        raise ArgumentError, 'condition should be a Hash' unless condition.is_a?(Hash)
+
+        is_correlator = Validator.new(field_schema: @entity_schema).is_correlator?(field_name: condition[:field_name])
+        raise InvalidCorrelatorError, "Field: #{condition[:field_name]} is not a correlator." unless is_correlator
+      end
+
+      def validate_set_field(field_name)
+        field_type = @entity_schema[:field_types][field_name.to_s]
+        raise CDP::SchemaMissingFieldError, "invalid field #{field_name}, is not on schema" unless field_type
+
+        unless field_type[:data_type] == 'SET'
+          raise CDP::InvalidFieldTypeError,
+                "invalid field #{field_name} type, is not a SET"
+        end
+      end
+
+      def entity_relations_builders
+        @entity_relations.each_with_object({}) do |relation, memo|
+          target_type = relation[:target_entity_type_name]
+          memo["add_#{target_type.downcase}_relation"] = lambda { |source_id, target_id|
+            add_relation(target_type, source_id, target_id)
+          }
+
+          memo["remove_#{target_type.downcase}_relation"] = lambda { |source_id, target_id|
+            remove_relation(target_type, source_id, target_id)
+          }
+        end
+      end
+
+      def add_relation(target_entity_type, source_id, target_id)
+        create_entity_relation = CDP::CreateEntityRelation.new(
+          source_entity_type: @entity_schema[:name],
+          source_entity_id: source_id,
+          target_entity_type: target_entity_type,
+          target_entity_id: target_id,
+          timestamp: Time.now.utc
+        )
+        build_execute_request({ create_entity_relation: create_entity_relation })
+      end
+
+      def remove_relation(target_entity_type, source_id, target_id)
+        delete_entity_relation = CDP::DeleteEntityRelation.new(
+          source_entity_type: @entity_schema[:name],
+          source_entity_id: source_id,
+          target_entity_type: target_entity_type,
+          target_entity_id: target_id,
+          timestamp: Time.now.utc
+        )
+        build_execute_request({ delete_entity_relation: delete_entity_relation })
+      end
+
+      def build_execute_request(command_payload)
+        CDP::Transaction.new(
+          tenant_id: @tenant_id,
+          commands: [CDP::Command.new(command_payload.merge(id: SecureRandom.uuid))]
+        )
+      end
+
+      def build_condition(condition)
+        field_name, field_value = condition.values
+        field_value = if ID_FIELD == field_name
+                        CDP::Value.create_string(field_value)
+                      else
+                        build(@entity_schema, field_name, field_value)
+                      end
+
+        CDP::FieldCondition.new(
+          field_name: field_name,
+          field_value: field_value
+        )
+      end
+
+      def build_payload(attributes)
+        attributes.each_with_object({}) do |(name, value), memo|
+          memo[name] = build(@entity_schema, name, value)
+        end
+      end
+    end
+  end
+end

data/lib/cdp/builders/event.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'cdp/builders/value'
+
+module CDP
+  module Builders
+    class Event
+      include Value
+
+      def initialize(tenant_id:, event_schema:)
+        @tenant_id = tenant_id
+        @event_schema = event_schema
+      end
+
+      def create(event)
+        event = event.symbolize_keys
+
+        raise ArgumentError, 'attribute event_identifier is missing' unless event.key?(:event_identifier)
+
+        raise ArgumentError, 'attribute event_identifier is empty' if event[:event_identifier].empty?
+
+        payload = event.except(:event_uuid, :event_identifier, :event_timestamp, :entity_uuid)
+
+        validation_result = Validator.new(field_schema: @event_schema).create(attributes: payload)
+
+        raise ::CDP::InvalidEntityError, validation_result.errors if validation_result.failed?
+
+        CDP::Transaction.new(
+          tenant_id: @tenant_id,
+          commands: [
+            CDP::Command.new(
+              id: SecureRandom.uuid,
+              create_event: CDP::CreateEvent.new(
+                event_type: @event_schema[:name],
+                event_uuid: event[:event_uuid] || SecureRandom.uuid,
+                event_identifier: event[:event_identifier],
+                event_timestamp: event[:event_timestamp] || Time.now.utc,
+                entity_uuid: event[:entity_uuid],
+                payload: build_payload_with_ref(@event_schema, payload)
+              )
+            )
+          ]
+        )
+      end
+    end
+  end
+end

data/lib/cdp/builders/value.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module CDP
+  module Builders
+    module Value
+      module_function
+
+      VALID_COMMAND_TYPE = %i[upsert_entity create_entity update_entity create_if_not_exists_entity].freeze
+
+      def build_payload_with_ref(schema, attributes, unsupported_types=[])
+        attributes.each_with_object({}) do |(name, value), memo|
+          if value.class == CDP::Transaction
+            raise ArgumentError, 'Unsupported multiple commands' if value.commands.size > 1
+            raise ArgumentError, 'Unsupported command' unless supported_command(value.commands.first)
+
+            memo[name] = CDP::Value.new(
+              reference: CDP::CommandReference.new(id: value.commands.first.id)
+            )
+            next
+          end
+          memo[name] = Value.build(schema, name, value, unsupported_types)          
+        end
+      end
+
+      def supported_command(command)
+        VALID_COMMAND_TYPE.include?(command.command_type)
+      end
+
+      def build(schema, field_name, field_value, unsupported_types=[])
+        field_type = schema[:field_types][field_name.to_s]
+
+        raise CDP::SchemaMissingFieldError, "invalid field #{field_name}, is not on schema" unless field_type
+        raise ArgumentError, "unsupported type #{field_type[:data_type]} (#{field_type[:name]})" if unsupported_types.include?(field_type[:data_type])
+
+        case field_type[:data_type]
+        when 'STRING'
+          CDP::Value.create_string(field_value)
+        when 'TEXT'
+          CDP::Value.create_text(field_value)
+        when 'BOOLEAN'
+          CDP::Value.create_bool(field_value)
+        when 'INTEGER'
+          CDP::Value.create_int(field_value)
+        when 'FLOAT'
+          CDP::Value.create_float(field_value)
+        when 'TIMESTAMP'
+          CDP::Value.create_timestamp(field_value)
+        when 'SET'
+          CDP::Value.create_set_values(field_value)
+        else
+          raise "invalid value type: #{field_type[:name]} (#{field_type[:data_type]}) = '#{field_value}'"
+        end
+      end
+    end
+  end
+end

data/lib/cdp/client.rb

@@ -0,0 +1,64 @@
+require_relative '../cdp/retryable'
+require_relative '../configuration'
+
+module CDP
+  class Client
+    include CDP::Retryable
+    include Configuration
+    attr_reader :legacy
+
+    AVAILABLE_PRIORITIES = %i[low normal high]
+
+    def initialize(service_name:, priority: :normal, url: CDP_CORE_SERVICE_URL, secure: :this_channel_is_insecure, retries: 3)
+      validate_priorities(priority)
+      @service_name = service_name
+      @priority = priority
+      @retries = retries
+      @service = CDP::Service::Stub.new(url, secure)
+      @search_service = CDP::SearchService::Stub.new(url, secure)
+      @legacy = CDP::Legacy::Service::Stub.new(url, secure)
+    end
+
+    def execute_sync(transaction, priority: @priority)
+      validate_priorities(priority)
+      response = retry_block(limit: @retries) {
+        @service.execute_sync(transaction, metadata(priority: priority))
+      }
+      response
+    end
+
+    def execute_async(transaction, priority: @priority)
+      validate_priorities(priority)
+      response = retry_block(limit: @retries) {
+        @service.execute_async(transaction, metadata(priority: priority))
+      }
+      response
+    end
+
+    def search(request:)
+      retry_block(limit: @retries) {
+        @search_service.execute(request)
+      }
+    end
+
+    def method_missing(method_name, *_args)
+      Query::Actions.new(self, method_name)
+    end
+
+    private
+
+    def validate_priorities(priority)
+      raise ArgumentError, 'invalid priority' unless AVAILABLE_PRIORITIES.include?(priority)
+    end
+
+    def metadata(priority:)
+      {
+        metadata: {
+          service_name: @service_name,
+          priority: priority.to_s,
+          version: CDP::VERSION
+        }
+      }
+    end
+  end
+end

data/lib/cdp/persistency.rb

@@ -0,0 +1,48 @@
+require_relative '../cdp/retryable'
+require_relative '../configuration'
+
+module CDP
+  class Persistency
+    class << self
+      include CDP::Retryable
+      include Configuration
+
+      def new(tenant_id:)
+        schema = get_schema(tenant_id)
+        CDP::Builder.new(tenant_id: tenant_id, schema: schema)
+      end
+
+      def execute(requests:, retries: 3)
+        raise ArgumentError, 'requests should be an Array' unless requests.is_a?(Array)
+
+        response = retry_block(limit: retries) {
+          client.execute(requests)
+        }
+      end
+
+      def client
+        @client ||= default_client
+      end
+
+      def client=(client)
+        @client = client
+      end
+
+      private
+
+      def default_client
+        CDP::PersistencyService::Stub.new(CDP_CORE_SERVICE_URL, :this_channel_is_insecure)
+      end
+
+      def get_schema(tenant_id)
+        ctx = Mstk::Context.create(tenant_id)
+        response = CDP::SchemaClient::Client.get_schema(ctx, tenant_id)
+        success, error, schema = response.values_at(:success, :error, :schema)
+
+        raise "Could not get schema for tenant '#{@tenant_id}': '#{error}'" unless success
+
+        schema
+      end
+    end
+  end
+end

data/lib/cdp/query/actions.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CDP
+  module Query
+    class Actions
+      def initialize(service, object_type)
+        @service = service
+        @object_type = object_type.to_s.upcase
+      end
+
+      def exists?(tenant_id:, condition:)
+        request = CDP::SearchRequest.new(
+          tenant_id: tenant_id,
+          exists: CDP::Exists.new(
+            type: @object_type,
+            field_condition: build_condition(condition)
+          )
+        )
+
+        @service.search(request: request)
+      end
+
+
+      def distinct(tenant_id:, fields:, condition:)
+        request = CDP::SearchRequest.new(
+          tenant_id: tenant_id,
+          distinct: CDP::Distinct.new(
+            type: @object_type,
+            fields: Array(fields),
+            field_condition: build_condition(condition)
+          )
+        )
+
+        @service.search(request: request)
+      end
+
+      private
+
+      def build_condition(condition)
+        raise ArgumentError, 'condition should be a Hash' unless condition.is_a?(Hash)
+
+        raise ArgumentError, 'condition should has one value' unless condition.length != 0
+
+        field_name, field_value = condition.first
+
+        field_value = Array(field_value)
+
+        CDP::FieldCondition.new(
+          field_name: field_name,
+          field_value: CDP::Value.create_set_values(field_value)
+        )
+      end
+    end
+  end
+end

data/lib/cdp/retryable.rb

@@ -0,0 +1,27 @@
+require 'grpc'
+
+module CDP
+  module Retryable
+    DEFAULT_CDP_CLIENT_RETRYABLE_ERRORS = 'Errno::ECONNRESET,Errno::ECONNREFUSED,GRPC::ResourceExhausted,GRPC::Unavailable'
+
+    CDP_CLIENT_RETRYABLE_ERRORS = [
+      ENV.fetch('CDP_CLIENT_RETRYABLE_ERRORS', DEFAULT_CDP_CLIENT_RETRYABLE_ERRORS).split(',')
+    ].flatten
+
+    def retry_block(limit: 3, backoff: 1)
+      tries = 0
+
+      begin
+        yield
+      rescue => e
+        if CDP_CLIENT_RETRYABLE_ERRORS.include?(e.class.to_s) && tries < limit
+          sleep backoff * tries
+          tries += 1
+          retry
+        end
+
+        raise
+      end
+    end
+  end
+end