roseflow-proxycurl 0.5.0

data/lib/roseflow/linkedin/person/experience.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Types
+  DateOrNil = Date | Nil
+  StringOrNil = String | Nil
+end
+
+module Functions
+  extend Dry::Transformer::Registry
+
+  register :to_date, ->(v) { Date.parse("#{v.dig(:year)}-#{v.dig(:month)}-#{v.dig(:day)}") unless v.nil? }
+end
+
+module Roseflow
+  module LinkedIn
+    class Person
+      class ExperienceMapper < Dry::Transformer::Pipe
+        import Dry::Transformer::HashTransformations
+
+        def custom_t(*args)
+          Functions[*args]
+        end
+
+        define! do
+          deep_symbolize_keys
+          rename_keys company_linkedin_profile_url: :company_profile_url, starts_at: :started_on, ends_at: :ended_on
+
+          map_value :started_on, ->(v) { Date.parse("#{v.dig(:year)}-#{v.dig(:month)}-#{v.dig(:day)}") unless v.nil? }
+          map_value :ended_on, ->(v) { Date.parse("#{v.dig(:year)}-#{v.dig(:month)}-#{v.dig(:day)}") unless v.nil? }
+        end
+      end
+
+      class Experience < Dry::Struct
+        defines :contract_object
+
+        class ExperienceContract < Dry::Validation::Contract
+          params do
+            required(:title).filled(:string)
+            required(:company).filled(:string)
+            optional(:company_profile_url).filled(:string)
+            optional(:location)
+            optional(:description)
+            optional(:started_on).filled(:date)
+            optional(:ended_on)
+          end
+
+          def call(input)
+            transformed = ExperienceMapper.new.call(input)
+            super(transformed)
+          end
+        end
+
+        attribute :title, Types::String
+        attribute :company, Types::String
+        attribute? :company_profile_url, Types::StringOrNil
+        attribute? :location, Types::StringOrNil
+        attribute? :description, Types::StringOrNil
+        attribute :started_on, Types::Date
+        attribute? :ended_on, Types::DateOrNil
+
+        contract_object ExperienceContract
+
+        schema schema.strict
+
+        def self.new(input)
+          validation = self.contract_object.new.call(input)
+          raise ArgumentError, validation.errors.to_h unless validation.success?
+          super(validation.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/roseflow/linkedin/person/lookup_query.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+require "roseflow/proxycurl/object"
+require "roseflow/linkedin/person"
+require "roseflow/types"
+
+module Roseflow
+  module LinkedIn
+    class Person
+      class LookupQuery < Proxycurl::ProxycurlObject
+        class LookupQueryContract < Dry::Validation::Contract
+          params do
+            required(:domain).filled(:string)
+            required(:first_name).filled(:string)
+            optional(:last_name).filled(:string)
+            optional(:title).filled(:string)
+            optional(:location).filled(:string)
+            optional(:enrich).filled(:bool)
+          end
+        end
+
+        contract_object LookupQueryContract
+
+        schema schema.strict
+
+        attribute :domain, Types::String
+        attribute :first_name, Types::String
+        attribute? :last_name, Types::String
+        attribute? :title, Types::String
+        attribute? :location, Types::String
+        attribute? :enrich, Types::Bool.default(false)
+
+        def self.new(input)
+          validation = self.contract_object.new.call(input)
+          raise ArgumentError, validation.errors.to_h.inspect unless validation.success?
+          super(input)
+        end
+
+        def to_request_params
+          params = {
+            company_domain: domain,
+            first_name: first_name,
+            last_name: last_name,
+            title: title,
+            location: location,
+            enrich_profile: enrich == true ? "enrich" : "skip",
+          }
+
+          params.each_pair do |key, value|
+            params.delete(key) unless value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roseflow/linkedin/person/object.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "dry-transformer"
+
+require "roseflow/linkedin/person/experience"
+
+module Roseflow
+  module LinkedIn
+    class Person
+      class Object < Dry::Struct
+        defines :contract_object
+
+        class PersonMapper < Dry::Transformer::Pipe
+          import Dry::Transformer::HashTransformations
+
+          define! do
+            deep_symbolize_keys
+            rename_keys public_identifier: :id, profile_pic_url: :profile_picture_url, follower_count: :followers
+          end
+        end
+
+        class PersonContract < Dry::Validation::Contract
+          params do
+            required(:id).filled(:string)
+            required(:first_name).filled(:string)
+            required(:last_name).filled(:string)
+            required(:full_name).filled(:string)
+            required(:profile_url).filled(:string)
+            required(:profile_picture_url).filled(:string)
+            required(:headline).filled(:string)
+            optional(:followers)
+            optional(:connections)
+            optional(:occupation)
+            optional(:experiences).filled(:array)
+          end
+
+          def call(input)
+            transformed = PersonMapper.new.call(input)
+            super(transformed)
+          end
+        end
+
+        attribute :id, Types::String
+        attribute :first_name, Types::String
+        attribute :last_name, Types::String
+        attribute :full_name, Types::String
+        attribute :profile_url, Types::String
+        attribute :profile_picture_url, Types::String
+        attribute :headline, Types::String
+        attribute :followers, Types::Integer.optional
+        attribute :connections, Types::Integer.optional
+        attribute :occupation, Types::String
+        attribute :experiences, Types::Array.of(Experience).optional
+
+        contract_object PersonContract
+
+        schema schema.strict
+
+        def self.new(input)
+          experiences = input.delete("experiences")
+          input[:experiences] = experiences.map { |experience| Experience.new(experience) } if experiences
+          validation = self.contract_object.new.call(input)
+          raise ArgumentError, validation.errors.to_h.inspect unless validation.success?
+          super(validation.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/roseflow/linkedin/person/profile_query.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+require "roseflow/proxycurl/object"
+require "roseflow/linkedin/person"
+require "roseflow/types"
+
+module Roseflow
+  module LinkedIn
+    class Person
+    end
+
+    class Person::ProfileQuery < Proxycurl::ProxycurlObject
+      class ProfileQueryContract < Dry::Validation::Contract
+        params do
+          required(:url).filled(:string)
+        end
+
+        rule (:url) do
+          unless URI.parse(value).is_a?(URI::HTTP)
+            key.failure("must be a valid URL")
+          end
+
+          unless value.match?(/linkedin\.com\/in\/\w+/)
+            key.failure("must be a valid LinkedIn profile URL")
+          end
+        end
+      end
+
+      contract_object ProfileQueryContract
+
+      schema schema.strict
+
+      attribute :url, Types::String
+      attribute :fallback_to_cache, Types::String.default("on-error")
+      attribute :use_cache, Types::String.default("if-present")
+      attribute :skills, Types::String.default("exclude")
+      attribute :inferred_salary, Types::String.default("exclude")
+      attribute :personal_email, Types::String.default("exclude")
+      attribute :personal_contact_number, Types::String.default("exclude")
+      attribute :twitter_profile_id, Types::String.default("exclude")
+      attribute :facebook_profile_id, Types::String.default("exclude")
+      attribute :github_profile_id, Types::String.default("exclude")
+      attribute :extra, Types::String.default("exclude")
+
+      def self.new(input)
+        validation = self.contract_object.new.call(input)
+        raise ArgumentError, validation.errors.to_h.inspect unless validation.success?
+        super(input)
+      end
+    end
+  end
+end

data/lib/roseflow/linkedin/person/role_query.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "dry-validation"
+require "roseflow/proxycurl/object"
+require "roseflow/linkedin/person"
+require "roseflow/types"
+
+module Roseflow
+  module LinkedIn
+    class Person
+      class RoleQuery < Proxycurl::ProxycurlObject
+        class RoleQueryContract < Dry::Validation::Contract
+          params do
+            required(:role).filled(:string)
+            required(:company_name).filled(:string)
+            optional(:enrich).filled(:bool)
+          end
+        end
+
+        contract_object RoleQueryContract
+
+        schema schema.strict
+
+        attribute :role, Types::String
+        attribute :company_name, Types::String
+        attribute? :enrich, Types::Bool.default(false)
+
+        def self.new(input)
+          validation = self.contract_object.new.call(input)
+          raise ArgumentError, validation.errors.to_h.inspect unless validation.success?
+          super(input)
+        end
+
+        def to_request_params
+          params = {
+            company_name: company_name,
+            role: role,
+            enrich_profile: enrich == true ? "enrich" : "skip",
+          }
+
+          params.each_pair do |key, value|
+            params.delete(key) unless value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/roseflow/linkedin/person.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "roseflow/linkedin/person/lookup_query"
+require "roseflow/linkedin/person/profile_query"
+require "roseflow/linkedin/person/role_query"
+
+module Roseflow
+  module LinkedIn
+    class Person
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def find(url, **options)
+        query = ProfileQuery.new(url: url, **options)
+        response = @connection.get("v2/linkedin", query.to_h)
+        return Person::Object.new(JSON.parse(response.body).merge(profile_url: url)) if person_found?(response)
+        return nil if person_not_found?(response)
+      end
+
+      def lookup(query)
+        query = LookupQuery.new(query)
+        response = @connection.get("linkedin/profile/resolve", query.to_request_params)
+        return JSON.parse(response.body).dig("url") if person_found?(response)
+        return nil if person_not_found?(response)
+      end
+
+      def role(query)
+        query = RoleQuery.new(query)
+        response = @connection.get("find/company/role/", query.to_request_params)
+        if person_found?(response)
+          url = JSON.parse(response.body).dig("linkedin_profile_url")
+          return find(url)
+        end
+
+        return nil if person_not_found?(response)
+      end
+
+      private
+
+      def person_found?(response)
+        response.success? && response.status == 200
+      end
+
+      def person_not_found?(response)
+        response.success? && response.status == 404
+      end
+    end
+  end
+end

data/lib/roseflow/proxycurl/client.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Roseflow
+  module Proxycurl
+    class Client
+      def initialize(config = Config.new)
+        @config = config
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(
+          url: proxycurl_base_url,
+        ) do |faraday|
+          faraday.request :authorization, :Bearer, -> { config.api_key }
+          faraday.request :url_encoded
+          faraday.adapter Faraday.default_adapter
+        end
+      end
+
+      def proxycurl_base_url
+        @config.base_url || Config::DEFAULT_BASE_URL
+      end
+    end
+  end
+end

data/lib/roseflow/proxycurl/config.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "anyway_config"
+
+module Roseflow
+  module Proxycurl
+    class Config < Anyway::Config
+      DEFAULT_BASE_URL = "https://nubela.co/proxycurl/api/"
+
+      config_name :proxycurl
+
+      attr_config :api_key, :base_url
+
+      required :api_key
+    end
+  end
+end

data/lib/roseflow/proxycurl/object.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "dry-struct"
+
+module Roseflow
+  module Proxycurl
+    class ProxycurlObject < Dry::Struct
+      defines :contract_object
+    end
+  end
+end

data/lib/roseflow/proxycurl/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Roseflow
+  module Proxycurl
+    def self.gem_version
+      Gem::Version.new(VERSION::STRING)
+    end
+
+    module VERSION
+      MAJOR = 0
+      MINOR = 5
+      PATCH = 0
+      PRE = nil
+
+      STRING = [MAJOR, MINOR, PATCH, PRE].compact.join(".")
+    end
+  end
+end

data/lib/roseflow/proxycurl.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "proxycurl/version"
+
+module Roseflow
+  module Proxycurl
+    class Error < StandardError; end
+    # Your code goes here...
+  end
+end

data/roseflow-proxycurl.gemspec

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "lib/roseflow/proxycurl/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "roseflow-proxycurl"
+  spec.version = Roseflow::Proxycurl.gem_version
+  spec.authors = ["Lauri Jutila"]
+  spec.email = ["ljuti@roseflow.ai"]
+
+  spec.summary = "Proxycurl integration for Roseflow."
+  spec.description = "Proxycurl integration for Roseflow."
+  spec.homepage = "https://github.com/roseflow-ai/roseflow-proxycurl"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/roseflow-ai/roseflow-proxycurl"
+  spec.metadata["changelog_uri"] = "https://github.com/roseflow-ai/roseflow-proxycurl/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "activesupport", "~> 6.0"
+  spec.add_dependency "anyway_config", "~> 2.0"
+  spec.add_dependency "dry-struct", "~> 1.6"
+  spec.add_dependency "dry-transformer", "~> 1.0"
+  spec.add_dependency "dry-validation", "~> 1.10"
+  spec.add_dependency "faraday", "~> 2.0"
+  spec.add_dependency "faraday-retry", "~> 2.0"
+
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "roseflow"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/roseflow/proxycurl.rbs

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