brightdata 0.1.0

data/lib/brightdata/linkedin/endpoint.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module BrightData
+  # Namespace for Bright Data LinkedIn scraper endpoints.
+  module LinkedIn
+    # Shared trigger/scrape helpers for LinkedIn endpoint classes.
+    #
+    # Including this module gives a class the {ClassMethods#endpoint} macro,
+    # which declares a whole endpoint mode (its `#initialize`, `#trigger`,
+    # `#scrape`, input validation, and result parsing) from a few keywords.
+    #
+    # @api private
+    module Endpoint
+      # @return [String] Bright Data trigger path
+      TRIGGER_PATH = "/datasets/v3/trigger"
+
+      # @return [String] Bright Data synchronous scrape path
+      SCRAPE_PATH = "/datasets/v3/scrape"
+
+      # @param base [Class] including class
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Declarative endpoint builder mixed into classes that include {Endpoint}.
+      module ClassMethods
+        # Declare an endpoint mode.
+        #
+        # Generates `#initialize(http:)`, `#trigger`/`#scrape` (with a real
+        # keyword argument named after `param`), input validation, and result
+        # parsing. Pass either `input` (each value is a URL string wrapped in
+        # that input class) or `input_type` (each value must already be an
+        # instance of that type).
+        #
+        # @param dataset_key [Symbol] key in {BrightData::Datasets::LINKEDIN}
+        # @param result [#from_api] typed result class for parsing responses
+        # @param param [Symbol] public keyword argument name, e.g. `:urls`
+        # @param input [Class, nil] URL-input class wrapping each string value
+        # @param input_type [Class, nil] required type for each pre-built value
+        # @param extra_query [Hash] extra Bright Data query params
+        # @return [void]
+        def endpoint(dataset_key:, result:, param:, input: nil, input_type: nil, extra_query: {}) # rubocop:disable Metrics/ParameterLists -- each keyword names one facet of the endpoint DSL
+          const_set(:DATASET_KEY, dataset_key)
+          const_set(:EXTRA_QUERY, extra_query.freeze)
+          define_initialize
+          define_result_parser(result)
+          input ? define_url_inputs(param, input) : define_object_inputs(param, input_type)
+          define_actions(param)
+        end
+
+        private
+
+        def define_initialize
+          define_method(:initialize) { |http:| @http = http }
+        end
+
+        def define_result_parser(result)
+          define_method(:result_parser) do
+            ->(raw) { result_items(raw).map { |hash| result.from_api(hash) } }
+          end
+          private :result_parser
+        end
+
+        def define_url_inputs(param, input)
+          label = param.to_s
+          define_method(:build_inputs) do |values|
+            raise ArgumentError, "#{label}: must be an Array, got #{values.class}" unless values.is_a?(Array)
+
+            values.map { |url| input.new(url:) }
+          end
+          private :build_inputs
+        end
+
+        def define_object_inputs(param, input_type)
+          label = param.to_s
+          type_name = input_type.name.split("::").last
+          define_method(:build_inputs) do |values|
+            raise ArgumentError, "#{label}: must be an Array, got #{values.class}" unless values.is_a?(Array)
+
+            values.each do |item|
+              raise ArgumentError, "#{label}[] must be #{type_name}, got #{item.class}" unless item.is_a?(input_type)
+            end
+            values
+          end
+          private :build_inputs
+        end
+
+        # `trigger`/`scrape` need a real keyword named after `param` so a wrong
+        # keyword raises Ruby's native ArgumentError; that requires class_eval.
+        def define_actions(param)
+          # For `param: :urls` this defines, e.g.:
+          #   def trigger(urls:)
+          #     trigger_with(dataset_key: DATASET_KEY, inputs: build_inputs(urls), extra_query: EXTRA_QUERY)
+          #   end
+          #
+          #   def scrape(urls:)
+          #     inputs = build_inputs(urls)
+          #     return [] if inputs.empty?
+          #
+          #     scrape_with(dataset_key: DATASET_KEY, inputs:, extra_query: EXTRA_QUERY)
+          #   end
+          class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition -- the generated methods are spelled out in the comment above
+            def trigger(#{param}:)
+              trigger_with(dataset_key: DATASET_KEY, inputs: build_inputs(#{param}), extra_query: EXTRA_QUERY)
+            end
+
+            def scrape(#{param}:)
+              inputs = build_inputs(#{param})
+              return [] if inputs.empty?
+
+              scrape_with(dataset_key: DATASET_KEY, inputs:, extra_query: EXTRA_QUERY)
+            end
+          RUBY
+        end
+      end
+
+      private
+
+      # Trigger an asynchronous Bright Data collection.
+      #
+      # @param dataset_key [Symbol] key in {BrightData::Datasets::LINKEDIN}
+      # @param inputs [Array<Data>] input objects
+      # @param extra_query [Hash] additional query params
+      # @return [BrightData::Snapshot]
+      def trigger_with(dataset_key:, inputs:, extra_query: {})
+        payload = @http.post(
+          path: TRIGGER_PATH,
+          query: query_for(dataset_key:, extra: extra_query),
+          body: { input: serialize_inputs(inputs) }
+        )
+        Snapshot.new(
+          id: payload.fetch(Snapshot::TRIGGER_RESPONSE_KEY),
+          http: @http,
+          result_parser: result_parser
+        )
+      end
+
+      # Run a synchronous Bright Data scrape.
+      #
+      # @param dataset_key [Symbol] key in {BrightData::Datasets::LINKEDIN}
+      # @param inputs [Array<Data>] input objects
+      # @param extra_query [Hash] additional query params
+      # @return [Array] parsed results
+      # @raise [BrightData::ScrapeTimeoutError] if Bright Data returns snapshot fallback
+      def scrape_with(dataset_key:, inputs:, extra_query: {}) # rubocop:disable Metrics/MethodLength -- the snapshot-fallback branch belongs with the scrape it recovers from
+        payload = @http.post(
+          path: SCRAPE_PATH,
+          query: query_for(dataset_key:, extra: extra_query),
+          body: { input: serialize_inputs(inputs) }
+        )
+        if payload.is_a?(Hash) && payload[:snapshot_id]
+          snapshot = Snapshot.new(
+            id: payload.fetch(Snapshot::TRIGGER_RESPONSE_KEY),
+            http: @http,
+            result_parser: result_parser
+          )
+          raise ScrapeTimeoutError.new(
+            "Bright Data /scrape exceeded its 60s cap. Use .trigger + Snapshot#wait, " \
+            "or recover via e.snapshot.wait",
+            snapshot_id: payload[:snapshot_id],
+            snapshot:
+          )
+        end
+
+        result_parser.call(payload)
+      end
+
+      # @return [#call] parser mapping raw API arrays to endpoint-specific values
+      def result_parser
+        ->(raw) { raw }
+      end
+
+      def query_for(dataset_key:, extra:)
+        { dataset_id: Datasets.id_for(dataset_key) }.merge(extra)
+      end
+
+      def serialize_inputs(inputs)
+        inputs.map do |input|
+          input.respond_to?(:to_api_hash) ? input.to_api_hash : input.to_h
+        end
+      end
+
+      def result_items(raw)
+        case raw
+        when Array
+          raw.flat_map { |item| item.is_a?(Array) ? item : [item] }
+        when Hash
+          [raw]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/brightdata/linkedin/jobs.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module BrightData
+  module LinkedIn
+    # `client.linkedin.jobs` endpoint family for LinkedIn jobs.
+    class Jobs
+      # @return [BrightData::LinkedIn::Jobs::CollectByUrl]
+      attr_reader :collect_by_url
+
+      # @return [BrightData::LinkedIn::Jobs::DiscoverByUrl]
+      attr_reader :discover_by_url
+
+      # @return [BrightData::LinkedIn::Jobs::DiscoverByKeyword]
+      attr_reader :discover_by_keyword
+
+      # @param http [BrightData::HTTP] shared HTTP wrapper
+      def initialize(http:)
+        @collect_by_url = CollectByUrl.new(http:)
+        @discover_by_url = DiscoverByUrl.new(http:)
+        @discover_by_keyword = DiscoverByKeyword.new(http:)
+      end
+
+      # @return [String] developer-friendly mode summary
+      def inspect
+        "#<BrightData::LinkedIn::Jobs modes=[:collect_by_url, :discover_by_url, :discover_by_keyword]>"
+      end
+
+      # Jobs collect-by-URL mode.
+      #
+      # @example
+      #   jobs = client.linkedin.jobs.collect_by_url.scrape(urls: ["https://www.linkedin.com/jobs/view/123/"])
+      class CollectByUrl
+        include Endpoint
+
+        endpoint(
+          dataset_key: :jobs_collect_by_url,
+          input: Types::JobUrlInput,
+          result: Types::Job,
+          param: :urls
+        )
+      end
+
+      # Jobs discover-by-URL mode.
+      #
+      # @example
+      #   jobs = client.linkedin.jobs.discover_by_url.scrape(urls: ["https://www.linkedin.com/jobs/search/?keywords=ruby"])
+      class DiscoverByUrl
+        include Endpoint
+
+        endpoint(
+          dataset_key: :jobs_discover_by_url,
+          input: Types::JobUrlInput,
+          result: Types::Job,
+          param: :urls,
+          extra_query: { type: "discover_new", discover_by: "url" }
+        )
+      end
+
+      # Jobs discover-by-keyword mode.
+      #
+      # @example
+      #   query = BrightData::LinkedIn::Types::JobKeywordInput.new(
+      #     location: "New York",
+      #     keyword: "ruby",
+      #     country: nil, time_range: nil, job_type: nil, experience_level: nil,
+      #     remote: nil, company: nil, selective_search: nil,
+      #     jobs_to_not_include: nil, location_radius: nil
+      #   )
+      #   jobs = client.linkedin.jobs.discover_by_keyword.scrape(queries: [query])
+      class DiscoverByKeyword
+        include Endpoint
+
+        endpoint(
+          dataset_key: :jobs_discover_by_keyword,
+          input_type: Types::JobKeywordInput,
+          result: Types::Job,
+          param: :queries,
+          extra_query: { type: "discover_new", discover_by: "keyword" }
+        )
+      end
+    end
+  end
+end

data/lib/brightdata/linkedin/namespace.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module BrightData
+  module LinkedIn
+    # Accessor for the LinkedIn endpoint families.
+    class Namespace
+      # @return [BrightData::LinkedIn::Profiles]
+      attr_reader :profiles
+
+      # @return [BrightData::LinkedIn::Companies]
+      attr_reader :companies
+
+      # @return [BrightData::LinkedIn::Jobs]
+      attr_reader :jobs
+
+      # @return [BrightData::LinkedIn::Posts]
+      attr_reader :posts
+
+      # @return [BrightData::LinkedIn::People]
+      attr_reader :people
+
+      # @param http [BrightData::HTTP] shared HTTP wrapper
+      def initialize(http:)
+        @profiles = Profiles.new(http:)
+        @companies = Companies.new(http:)
+        @jobs = Jobs.new(http:)
+        @posts = Posts.new(http:)
+        @people = People.new(http:)
+      end
+    end
+  end
+end

data/lib/brightdata/linkedin/people.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module BrightData
+  module LinkedIn
+    # `client.linkedin.people` endpoint family for LinkedIn people discovery.
+    class People
+      # @return [BrightData::LinkedIn::People::DiscoverNewProfiles]
+      attr_reader :discover_new_profiles
+
+      # @param http [BrightData::HTTP] shared HTTP wrapper
+      def initialize(http:)
+        @discover_new_profiles = DiscoverNewProfiles.new(http:)
+      end
+
+      # @return [String] developer-friendly mode summary
+      def inspect
+        "#<BrightData::LinkedIn::People modes=[:discover_new_profiles]>"
+      end
+
+      # People discover-new-profiles mode.
+      #
+      # @example
+      #   query = BrightData::LinkedIn::Types::PeopleDiscoverInput.new(
+      #     url: "https://www.linkedin.com", first_name: "Jane", last_name: "Smith"
+      #   )
+      #   profiles = client.linkedin.people.discover_new_profiles.scrape(queries: [query])
+      class DiscoverNewProfiles
+        include Endpoint
+
+        endpoint(
+          dataset_key: :people_discover_new_profiles,
+          input_type: Types::PeopleDiscoverInput,
+          result: Types::DiscoveredProfile,
+          param: :queries
+        )
+      end
+    end
+  end
+end

data/lib/brightdata/linkedin/posts.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module BrightData
+  module LinkedIn
+    # `client.linkedin.posts` endpoint family for LinkedIn posts.
+    class Posts
+      # @return [BrightData::LinkedIn::Posts::CollectByUrl]
+      attr_reader :collect_by_url
+
+      # @return [BrightData::LinkedIn::Posts::DiscoverByProfileUrl]
+      attr_reader :discover_by_profile_url
+
+      # @return [BrightData::LinkedIn::Posts::DiscoverByUrl]
+      attr_reader :discover_by_url
+
+      # @return [BrightData::LinkedIn::Posts::DiscoverByCompanyUrl]
+      attr_reader :discover_by_company_url
+
+      # @param http [BrightData::HTTP] shared HTTP wrapper
+      def initialize(http:)
+        @collect_by_url = CollectByUrl.new(http:)
+        @discover_by_profile_url = DiscoverByProfileUrl.new(http:)
+        @discover_by_url = DiscoverByUrl.new(http:)
+        @discover_by_company_url = DiscoverByCompanyUrl.new(http:)
+      end
+
+      # @return [String] developer-friendly mode summary
+      def inspect
+        modes = %i[collect_by_url discover_by_profile_url discover_by_url discover_by_company_url]
+        "#<BrightData::LinkedIn::Posts modes=#{modes}>"
+      end
+
+      # Posts collect-by-URL mode.
+      #
+      # @example
+      #   posts = client.linkedin.posts.collect_by_url.scrape(urls: ["https://www.linkedin.com/posts/example"])
+      class CollectByUrl
+        include Endpoint
+
+        endpoint(
+          dataset_key: :posts_collect_by_url,
+          input: Types::PostUrlInput,
+          result: Types::Post,
+          param: :urls
+        )
+      end
+
+      # Posts discover-by-profile-URL mode.
+      #
+      # @example
+      #   posts = client.linkedin.posts.discover_by_profile_url.scrape(profile_urls: ["https://www.linkedin.com/in/example/"])
+      class DiscoverByProfileUrl
+        include Endpoint
+
+        endpoint(
+          dataset_key: :posts_discover_by_profile_url,
+          input: Types::PostProfileUrlInput,
+          result: Types::Post,
+          param: :profile_urls,
+          extra_query: { type: "discover_new", discover_by: "profile_url" }
+        )
+      end
+
+      # Posts discover-by-URL mode.
+      #
+      # @example
+      #   posts = client.linkedin.posts.discover_by_url.scrape(urls: ["https://www.linkedin.com/feed/"])
+      class DiscoverByUrl
+        include Endpoint
+
+        endpoint(
+          dataset_key: :posts_discover_by_url,
+          input: Types::PostUrlInput,
+          result: Types::Post,
+          param: :urls,
+          extra_query: { type: "discover_new", discover_by: "url" }
+        )
+      end
+
+      # Posts discover-by-company-URL mode.
+      #
+      # @example
+      #   posts = client.linkedin.posts.discover_by_company_url.scrape(company_urls: ["https://www.linkedin.com/company/example/"])
+      class DiscoverByCompanyUrl
+        include Endpoint
+
+        endpoint(
+          dataset_key: :posts_discover_by_company_url,
+          input: Types::PostCompanyUrlInput,
+          result: Types::Post,
+          param: :company_urls,
+          extra_query: { type: "discover_new", discover_by: "company_url" }
+        )
+      end
+    end
+  end
+end

data/lib/brightdata/linkedin/profiles.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module BrightData
+  module LinkedIn
+    # `client.linkedin.profiles` endpoint family for LinkedIn profiles by URL.
+    #
+    # @example Trigger an async collection
+    #   snapshot = client.linkedin.profiles.trigger(urls: ["https://www.linkedin.com/in/example/"])
+    # @example Scrape synchronously
+    #   profiles = client.linkedin.profiles.scrape(urls: ["https://www.linkedin.com/in/example/"])
+    #
+    # @!method trigger(urls:)
+    #   @param urls [Array<String>] LinkedIn profile URLs
+    #   @return [BrightData::Snapshot]
+    #   @raise [BrightData::ArgumentError] if `urls` is not an Array
+    # @!method scrape(urls:)
+    #   @param urls [Array<String>] LinkedIn profile URLs
+    #   @return [Array<BrightData::LinkedIn::Types::Profile>]
+    #   @raise [BrightData::ArgumentError] if `urls` is not an Array
+    #   @raise [BrightData::ScrapeTimeoutError] when results exceed Bright Data's synchronous cap
+    class Profiles
+      include Endpoint
+
+      endpoint(
+        dataset_key: :profiles_collect_by_url,
+        input: Types::ProfileUrlInput,
+        result: Types::Profile,
+        param: :urls
+      )
+    end
+  end
+end

data/lib/brightdata/linkedin/types/company.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module BrightData
+  module LinkedIn
+    module Types
+      # Typed representation of a LinkedIn company response.
+      #
+      # @!attribute [r] id
+      #   @return [String, nil] company ID
+      # @!attribute [r] name
+      #   @return [String, nil] company name
+      # @!attribute [r] country_code
+      #   @return [String, nil] country code
+      # @!attribute [r] locations
+      #   @return [Array<Hash>, nil] company locations
+      # @!attribute [r] followers
+      #   @return [Integer, String, nil] follower count
+      # @!attribute [r] employees_in_linkedin
+      #   @return [Integer, String, nil] LinkedIn employee count
+      # @!attribute [r] company_size
+      #   @return [String, nil] company size
+      # @!attribute [r] industries
+      #   @return [Array<String>, nil] industries
+      # @!attribute [r] specialties
+      #   @return [Array<String>, nil] specialties
+      # @!attribute [r] website
+      #   @return [String, nil] company website
+      # @!attribute [r] founded
+      #   @return [String, Integer, nil] founded year
+      # @!attribute [r] company_id
+      #   @return [String, nil] LinkedIn company ID
+      # @!attribute [r] employees
+      #   @return [Array<Hash>, nil] employees
+      # @!attribute [r] similar
+      #   @return [Array<Hash>, nil] similar companies
+      # @!attribute [r] updates
+      #   @return [Array<Hash>, nil] updates
+      # @!attribute [r] logo
+      #   @return [String, nil] logo URL
+      # @!attribute [r] image
+      #   @return [String, nil] image URL
+      # @!attribute [r] headquarters
+      #   @return [Hash, nil] headquarters
+      # @!attribute [r] funding
+      #   @return [Hash, nil] funding details
+      # @!attribute [r] investors
+      #   @return [Array<Hash>, nil] investors
+      # @!attribute [r] affiliated
+      #   @return [Array<Hash>, nil] affiliated companies
+      # @!attribute [r] raw
+      #   @return [Hash] full parsed API response
+      # @note Use #raw to access fields not yet typed by this gem.
+      Company = Data.define(
+        :id, :name, :country_code, :locations, :followers,
+        :employees_in_linkedin, :company_size, :industries, :specialties,
+        :website, :founded, :company_id, :employees, :similar, :updates,
+        :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
+      ) do
+        # Build a company from a symbol-keyed API response.
+        #
+        # @param hash [Hash] symbolized-key API response object
+        # @return [BrightData::LinkedIn::Types::Company]
+        def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
+          new(
+            id: hash[:id],
+            name: hash[:name],
+            country_code: hash[:country_code],
+            locations: hash[:locations],
+            followers: hash[:followers],
+            employees_in_linkedin: hash[:employees_in_linkedin],
+            company_size: hash[:company_size],
+            industries: hash[:industries],
+            specialties: hash[:specialties],
+            website: hash[:website],
+            founded: hash[:founded],
+            company_id: hash[:company_id],
+            employees: hash[:employees],
+            similar: hash[:similar],
+            updates: hash[:updates],
+            logo: hash[:logo],
+            image: hash[:image],
+            headquarters: hash[:headquarters],
+            funding: hash[:funding],
+            investors: hash[:investors],
+            affiliated: hash[:affiliated],
+            raw: hash
+          )
+        end
+      end
+    end
+  end
+end

data/lib/brightdata/linkedin/types/company_url_input.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module BrightData
+  module LinkedIn
+    module Types
+      # Input shape for `linkedin.companies.{trigger,scrape}`.
+      #
+      # @!attribute [r] url
+      #   @return [String] LinkedIn company URL
+      CompanyUrlInput = Data.define(:url)
+    end
+  end
+end

data/lib/brightdata/linkedin/types/discovered_profile.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module BrightData
+  module LinkedIn
+    module Types
+      # Typed representation of a discovered LinkedIn profile response.
+      #
+      # @!attribute [r] url
+      #   @return [String, nil] profile URL
+      # @!attribute [r] name
+      #   @return [String, nil] profile name
+      # @!attribute [r] subtitle
+      #   @return [String, nil] profile subtitle
+      # @!attribute [r] location
+      #   @return [String, nil] profile location
+      # @!attribute [r] experience
+      #   @return [String, Hash, Array, nil] experience summary
+      # @!attribute [r] education
+      #   @return [String, Hash, Array, nil] education summary
+      # @!attribute [r] avatar
+      #   @return [String, nil] avatar URL
+      # @!attribute [r] raw
+      #   @return [Hash] full parsed API response
+      # @note Use #raw to access fields not yet typed by this gem.
+      DiscoveredProfile = Data.define(:url, :name, :subtitle, :location, :experience, :education, :avatar, :raw) do
+        # Build a discovered profile from a symbol-keyed API response.
+        #
+        # @param hash [Hash] symbolized-key API response object
+        # @return [BrightData::LinkedIn::Types::DiscoveredProfile]
+        def self.from_api(hash)
+          new(
+            url: hash[:url],
+            name: hash[:name],
+            subtitle: hash[:subtitle],
+            location: hash[:location],
+            experience: hash[:experience],
+            education: hash[:education],
+            avatar: hash[:avatar],
+            raw: hash
+          )
+        end
+      end
+    end
+  end
+end

data/lib/brightdata/linkedin/types/job.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module BrightData
+  module LinkedIn
+    module Types
+      # Typed representation of a LinkedIn job response.
+      #
+      # @!attribute [r] url
+      #   @return [String, nil] job URL
+      # @!attribute [r] job_posting_id
+      #   @return [String, nil] job posting ID
+      # @!attribute [r] job_title
+      #   @return [String, nil] job title
+      # @!attribute [r] company_name
+      #   @return [String, nil] company name
+      # @!attribute [r] job_location
+      #   @return [String, nil] job location
+      # @!attribute [r] job_summary
+      #   @return [String, nil] job summary
+      # @!attribute [r] job_base_pay_range
+      #   @return [String, nil] base pay range
+      # @!attribute [r] job_posted_time
+      #   @return [String, nil] posted time
+      # @!attribute [r] company_logo
+      #   @return [String, nil] company logo URL
+      # @!attribute [r] raw
+      #   @return [Hash] full parsed API response
+      # @note Use #raw to access fields not yet typed by this gem.
+      Job = Data.define(
+        :url, :job_posting_id, :job_title, :company_name, :job_location,
+        :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
+      ) do
+        # Build a job from a symbol-keyed API response.
+        #
+        # @param hash [Hash] symbolized-key API response object
+        # @return [BrightData::LinkedIn::Types::Job]
+        def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
+          new(
+            url: hash[:url],
+            job_posting_id: hash[:job_posting_id],
+            job_title: hash[:job_title],
+            company_name: hash[:company_name],
+            job_location: hash[:job_location],
+            job_summary: hash[:job_summary],
+            job_base_pay_range: hash[:job_base_pay_range],
+            job_posted_time: hash[:job_posted_time],
+            company_logo: hash[:company_logo],
+            raw: hash
+          )
+        end
+      end
+    end
+  end
+end