notion-client-ruby 0.1.0

data/lib/notion/objects/list.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../middleware/instrumentation"
+
+module Notion
+  module Objects
+    class List < Base
+      include Enumerable
+
+      def results
+        @results ||= Array(raw["results"]).map { |result| ObjectFactory.build(result) }
+      end
+
+      def next_cursor = raw["next_cursor"]
+      def has_more? = !!raw["has_more"]
+
+      def each(&block)
+        return enum_for(__method__) unless block
+
+        results.each(&block)
+      end
+
+      def each_page
+        return enum_for(__method__) unless block_given?
+
+        page = self
+        pages = 0
+        results = 0
+        loop do
+          pages += 1
+          results += page.results.length
+          yield page
+          break unless page.has_more? && page.fetcher
+
+          page = page.fetcher.call(page.next_cursor)
+        end
+        Middleware::Instrumentation.publish("pagination.notion", pages: pages, results: results)
+      end
+
+      def each_result(&block)
+        return enum_for(__method__) unless block
+
+        each_page { |page| page.results.each(&block) }
+      end
+
+      def with_fetcher(&fetcher)
+        @fetcher = fetcher
+        self
+      end
+
+      protected
+
+      attr_reader :fetcher
+    end
+  end
+end

data/lib/notion/objects/property_schema.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Notion
+  module Objects
+    module PropertySchema
+      READ_ONLY = %w[created_by created_time formula last_edited_by last_edited_time rollup unique_id].freeze
+      DIRECT = %w[number checkbox url email phone_number].freeze
+
+      module_function
+
+      def convert(properties, schema, strict: false)
+        properties.to_h do |name, value|
+          definition = schema[name.to_s] || schema[name.to_sym]
+          raise Query::UnknownPropertyError, "unknown property: #{name}" if strict && !definition
+
+          [name, definition ? encode(definition.fetch("type", definition[:type]).to_s, value) : value]
+        end
+      end
+
+      def encode(type, value)
+        return value if value.is_a?(Hash)
+
+        validate_writable!(type)
+        return { type => value } if DIRECT.include?(type)
+
+        case type
+        when "title", "rich_text" then { type => rich_text(value) }
+        when "date" then { "date" => { "start" => iso8601(value) } }
+        when "select", "status" then { type => value.nil? ? nil : { "name" => value.to_s } }
+        when "multi_select" then { type => Array(value).map { |item| { "name" => item.to_s } } }
+        when "people", "relation" then { type => references(value) }
+        else { type => value }
+        end
+      end
+
+      def validate_writable!(type)
+        raise ValidationError, "#{type} is read-only" if READ_ONLY.include?(type)
+      end
+
+      def references(value)
+        Array(value).map { |item| { "id" => item.respond_to?(:id) ? item.id : item } }
+      end
+
+      def rich_text(value)
+        Array(value).map do |item|
+          item.is_a?(Hash) ? item : { "type" => "text", "text" => { "content" => item.to_s } }
+        end
+      end
+
+      def iso8601(value)
+        value.respond_to?(:iso8601) ? value.iso8601 : value.to_s
+      end
+    end
+  end
+end

data/lib/notion/objects/property_value.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Notion
+  module Objects
+    class PropertyValue < Base
+      TYPES = %w[
+        button checkbox created_by created_time date email files formula last_edited_by
+        last_edited_time multi_select number people phone_number place relation rich_text
+        rollup select status title unique_id url verification
+      ].freeze
+
+      def value
+        raw[raw["type"]]
+      end
+
+      def to_s
+        case raw["type"]
+        when "title", "rich_text"
+          Array(value).map { |item| item["plain_text"] || item.dig("text", "content") }.join
+        when "select", "status" then value&.fetch("name", "").to_s
+        when "multi_select" then Array(value).filter_map { |item| item["name"] }.join(", ")
+        else value.to_s
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        (value.is_a?(Hash) && value.key?(attribute_name(name))) || super
+      end
+
+      def method_missing(name, *args)
+        key = attribute_name(name)
+        return super unless args.empty? && value.is_a?(Hash) && value.key?(key)
+
+        name.end_with?("?") ? !!value[key] : ObjectFactory.wrap_value(value[key])
+      end
+
+      def attribute_name(name)
+        name.to_s.delete_suffix("?")
+      end
+
+      def self.build(raw)
+        type = raw["type"].to_s
+        klass = const_defined?(class_name(type), false) ? const_get(class_name(type), false) : self
+        klass.new(raw)
+      end
+
+      def self.class_name(type)
+        type.split("_").map(&:capitalize).join
+      end
+
+      TYPES.each { |type| const_set(class_name(type), Class.new(self)) }
+
+      private :attribute_name
+    end
+  end
+end

data/lib/notion/objects/types.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Notion
+  module Objects
+    class Page < Base
+      def [](key)
+        property = raw.fetch("properties", {})[key.to_s]
+        property ? PropertyValue.build(property) : super
+      end
+
+      def title
+        title_property = raw.fetch("properties", {}).values.find { |property| property["type"] == "title" }
+        title_property && PropertyValue.build(title_property).to_s
+      end
+
+      def parent = Parent.new(raw.fetch("parent", {}))
+      def icon = raw["icon"] && Icon.new(raw["icon"])
+    end
+
+    class Database < Base; end
+    class DataSource < Base; end
+
+    class Block < Base
+      TYPES = %w[
+        audio bookmark breadcrumb bulleted_list_item callout child_database child_page code
+        column column_list divider embed equation file heading_1 heading_2 heading_3 image
+        link_preview link_to_page meeting_notes numbered_list_item paragraph pdf quote
+        synced_block table table_of_contents table_row template todo toggle transcription video
+      ].freeze
+
+      def self.build(raw)
+        name = raw["type"].to_s.split("_").map(&:capitalize).join
+        return new(raw) if name.empty?
+
+        klass = const_defined?(name, false) ? const_get(name, false) : self
+        klass.new(raw)
+      end
+
+      TYPES.each { |type| const_set(type.split("_").map(&:capitalize).join, Class.new(self)) }
+    end
+
+    class User < Base; end
+    class Comment < Base; end
+    class View < Base; end
+    class File < Base; end
+    class Parent < Base; end
+    class Icon < Base; end
+    class AsyncTask < Base; end
+
+    class RichText < Base
+      def to_s
+        raw["plain_text"] || raw.dig("text", "content").to_s
+      end
+    end
+  end
+end

data/lib/notion/objects.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "objects/base"
+require_relative "objects/property_value"
+require_relative "objects/property_schema"
+require_relative "objects/types"
+require_relative "objects/list"
+require_relative "object_factory"

data/lib/notion/pagination/cursor_paginator.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Notion
+  module Pagination
+    class CursorPaginator
+      include Enumerable
+
+      def initialize(list)
+        @list = list
+      end
+
+      def each(&block)
+        return enum_for(__method__) unless block
+
+        @list.each_result(&block)
+      end
+
+      alias each_result each
+
+      def each_page(&)
+        @list.each_page(&)
+      end
+    end
+  end
+end

data/lib/notion/query/builder.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Notion
+  module Query
+    class UnknownPropertyError < Error; end
+
+    class Builder
+      DEFAULT_VALUE = Object.new.freeze
+      OPERATORS = %i[
+        equals does_not_equal contains does_not_contain starts_with ends_with greater_than
+        less_than greater_than_or_equal_to less_than_or_equal_to before after on_or_before
+        on_or_after is_empty is_not_empty past_week past_month past_year next_week next_month next_year
+      ].freeze
+      EMPTY_OBJECT_OPERATORS = %i[past_week past_month past_year next_week next_month next_year].freeze
+
+      def initialize(schema: nil, strict: false)
+        @filters = []
+        @sorts = []
+        @schema = schema || {}
+        @strict = strict
+      end
+
+      def where(property, type: nil)
+        Filter.new(self, property, type)
+      end
+
+      def add(property, operator, value, type = nil)
+        raise ArgumentError, "property is required" if property.nil? || property.to_s.empty?
+
+        definition = @schema[property.to_s] || @schema[property.to_sym]
+        raise UnknownPropertyError, "unknown property: #{property}" if @strict && !definition
+
+        property_type = type || schema_type(definition) || :rich_text
+        condition = { property: property.to_s, property_type.to_sym => { operator => value } }
+        @filters << condition
+        self
+      end
+
+      def all_of(*filters)
+        raise ArgumentError, "all_of requires a filter" if filters.empty?
+
+        @filters << { and: filters.map { |filter| filter_value(filter) } }
+        self
+      end
+
+      def any_of(*filters)
+        raise ArgumentError, "any_of requires a filter" if filters.empty?
+
+        @filters << { or: filters.map { |filter| filter_value(filter) } }
+        self
+      end
+
+      define_method(:and) do |filter|
+        @filters << filter_value(filter) unless filter.equal?(self)
+        self
+      end
+
+      define_method(:or) do |filter|
+        right = filter.equal?(self) ? @filters.pop : filter_value(filter)
+        left = @filters.pop || raise(ArgumentError, "or requires a left filter")
+        @filters << { or: [left, right] }
+        self
+      end
+
+      def order(property = nil, timestamp: nil, direction: :ascending)
+        raise ArgumentError, "provide either property or timestamp" if property.nil? == timestamp.nil?
+        unless %i[ascending descending].include?(direction)
+          raise ArgumentError, "direction must be ascending or descending"
+        end
+
+        @sorts << { direction: direction }.merge(property ? { property: property.to_s } : { timestamp: timestamp })
+        self
+      end
+
+      def order_by_timestamp(timestamp, direction = :ascending)
+        order(timestamp: timestamp, direction: direction)
+      end
+
+      def raw(filter)
+        @filters << filter
+        self
+      end
+
+      def to_h
+        result = {}
+        result[:filter] = @filters.one? ? @filters.first : { and: @filters } unless @filters.empty?
+        result[:sorts] = @sorts unless @sorts.empty?
+        result
+      end
+
+      private
+
+      def filter_value(filter)
+        filter.is_a?(Builder) ? filter.to_h.fetch(:filter) : filter
+      end
+
+      def schema_type(definition)
+        definition && (definition["type"] || definition[:type])
+      end
+
+      class Filter
+        def initialize(builder, property, type)
+          @builder = builder
+          @property = property
+          @type = type
+        end
+
+        OPERATORS.each do |operator|
+          define_method(operator) do |value = DEFAULT_VALUE|
+            value = EMPTY_OBJECT_OPERATORS.include?(operator) ? {} : true if value.equal?(DEFAULT_VALUE)
+            @builder.add(@property, operator, value, @type)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/notion/query.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "query/builder"

data/lib/notion/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Notion
+  if defined?(Rails::Railtie)
+    class Railtie < Rails::Railtie
+      initializer "notion-client-ruby.configure" do
+        Notion.configure { |config| config.logger ||= Rails.logger }
+      end
+    end
+  end
+end

data/lib/notion/resolver.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Notion
+  class AmbiguousDataSourceError < Error; end
+  class DataSourceNotFoundError < Error; end
+
+  class Resolver
+    TTL = 900
+    MAX_CACHE_SIZE = 100
+
+    def initialize(client, clock: Process.method(:clock_gettime))
+      @client = client
+      @clock = clock
+      @store = client.config.cache if client.respond_to?(:config)
+      @cache = {}
+      @mutex = Mutex.new
+    end
+
+    def resolve(database_id, name: nil)
+      key = [database_id, name]
+      external = @store&.read(cache_key(key))
+      return external if external
+
+      cached = cached_value(key)
+      return cached if cached
+
+      sources = Array(@client.databases.retrieve(database_id: database_id).data_sources)
+      selected = select(sources, name)
+      id = selected.fetch("id")
+      write_cache(key, id)
+      id
+    end
+
+    private
+
+    def cached_value(key)
+      @mutex.synchronize do
+        expires_at, value = @cache.delete(key)
+        fresh = expires_at && expires_at > monotonic
+        @cache[key] = [expires_at, value] if fresh
+        value if fresh
+      end
+    end
+
+    def write_cache(key, value)
+      @store&.write(cache_key(key), value, expires_in: TTL)
+      @mutex.synchronize do
+        @cache[key] = [monotonic + TTL, value]
+        @cache.shift while @cache.length > MAX_CACHE_SIZE
+      end
+    end
+
+    def cache_key(key)
+      "notion:data_source:#{key.compact.join(':')}"
+    end
+
+    def select(sources, name)
+      if name
+        source = sources.find { |candidate| candidate["name"] == name }
+        return source || raise(DataSourceNotFoundError, "data source not found")
+      end
+      return sources.first if sources.one?
+      raise DataSourceNotFoundError, "database contains no data sources" if sources.empty?
+
+      raise AmbiguousDataSourceError, "database contains #{sources.length} data sources; pass name:"
+    end
+
+    def monotonic
+      @clock.call(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/notion/testing.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "transport"
+
+module Notion
+  module Testing
+    module_function
+
+    def page(id: "page", properties: {}, **attributes)
+      { "object" => "page", "id" => id, "properties" => properties }.merge(attributes.transform_keys(&:to_s))
+    end
+
+    def response(body, status: 200, headers: {})
+      Transport::Response.new(
+        status: status, headers: headers, body: JSON.generate(body), request_id: headers["x-request-id"], elapsed: 0
+      )
+    end
+
+    def stub_notion_page(id: "page", **attributes)
+      raise LoadError, "webmock is required for stub_notion_page" unless defined?(WebMock)
+
+      WebMock.stub_request(:get, %r{/v1/pages/#{Regexp.escape(id)}\z})
+             .to_return(status: 200, body: JSON.generate(page(id: id, **attributes)))
+    end
+
+    class Adapter < Transport::Adapter
+      attr_reader :requests
+
+      def initialize(*responses)
+        super()
+        @responses = responses
+        @requests = []
+      end
+
+      def call(request)
+        @requests << request
+        response = @responses.shift || raise("no stubbed Notion response")
+        return response if response.is_a?(Transport::Response)
+
+        Transport::Response.new(status: 200, headers: {}, body: JSON.generate(response), request_id: nil, elapsed: 0)
+      end
+    end
+  end
+end

data/lib/notion/transport/net_http_adapter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Notion
+  module Transport
+    class NetHTTPAdapter < Adapter
+      REQUEST_CLASSES = {
+        delete: Net::HTTP::Delete,
+        get: Net::HTTP::Get,
+        head: Net::HTTP::Head,
+        patch: Net::HTTP::Patch,
+        post: Net::HTTP::Post,
+        put: Net::HTTP::Put
+      }.freeze
+
+      def initialize(config, base_url: "https://api.notion.com", pool_size: 5, clock: Process.method(:clock_gettime))
+        super()
+        @config = config
+        @base_uri = URI(base_url)
+        @clock = clock
+        @pool = SizedQueue.new(pool_size)
+        pool_size.times { @pool << build_connection }
+      end
+
+      def call(request)
+        http = @pool.pop
+        broken = false
+        started = monotonic
+        http.start unless http.started?
+        response = http.request(build_request(request))
+        headers = response.each_header.to_h
+        Response.new(
+          status: response.code.to_i,
+          headers: headers,
+          body: response.body,
+          request_id: headers["x-request-id"],
+          elapsed: monotonic - started
+        )
+      rescue Timeout::Error => e
+        broken = true
+        raise TimeoutError.new(e.message, cause: e)
+      rescue IOError, SocketError, SystemCallError => e
+        broken = true
+        raise TransportError.new(e.message, cause: e)
+      ensure
+        release(http, broken) if http
+      end
+
+      private
+
+      def build_connection
+        proxy = @config.proxy && URI(@config.proxy)
+        klass = proxy ? Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password) : Net::HTTP
+        http = klass.new(@base_uri.host, @base_uri.port)
+        http.use_ssl = @base_uri.scheme == "https"
+        http.open_timeout = @config.open_timeout
+        http.read_timeout = @config.read_timeout
+        http.ca_file = @config.ca_file if @config.ca_file
+        http
+      end
+
+      def build_request(request)
+        uri = @base_uri.dup
+        uri.path = request.path
+        uri.query = URI.encode_www_form(request.query) unless request.query.empty?
+        klass = REQUEST_CLASSES.fetch(request.verb) do
+          raise ArgumentError, "unsupported HTTP method: #{request.verb}"
+        end
+        klass.new(uri, request.headers).tap { |http_request| http_request.body = request.body if request.body }
+      end
+
+      def release(http, broken)
+        if broken
+          http.finish if http.started?
+          @pool << build_connection
+        else
+          @pool << http
+        end
+      rescue IOError
+        @pool << build_connection
+      end
+
+      def monotonic
+        @clock.call(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/notion/transport.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Notion
+  module Transport
+    Request = Data.define(:verb, :path, :query, :headers, :body, :idempotent) do
+      def idempotent? = idempotent
+    end
+
+    Response = Data.define(:status, :headers, :body, :request_id, :elapsed, :attempt, :retried) do
+      def initialize(status:, headers:, body:, request_id:, elapsed:, attempt: 1, retried: false)
+        super
+      end
+    end
+
+    class Adapter
+      def call(_request)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/notion/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Notion
+  VERSION = "0.1.0"
+end

data/lib/notion/webhooks/event.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Notion
+  module Webhooks
+    class Event < Objects::Base; end
+  end
+end

data/lib/notion/webhooks/rack_middleware.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Notion
+  module Webhooks
+    class RackMiddleware
+      def initialize(app, secret:, path: "/notion/events", &handler)
+        @app = app
+        @secret = secret
+        @path = path
+        @handler = handler
+      end
+
+      def call(env)
+        return @app.call(env) unless env["PATH_INFO"] == @path && env["REQUEST_METHOD"] == "POST"
+
+        payload = env.fetch("rack.input").read
+        data = JSON.parse(payload)
+        return verify_subscription(data) if data.key?("verification_token")
+
+        valid = Signature.valid?(
+          secret: @secret,
+          payload: payload,
+          signature: env["HTTP_X_NOTION_SIGNATURE"] || env["HTTP_NOTION_SIGNATURE"]
+        )
+        return [401, { "content-type" => "text/plain" }, ["invalid signature"]] unless valid
+
+        @handler&.call(Event.new(data))
+        [200, {}, []]
+      rescue JSON::ParserError
+        [400, { "content-type" => "text/plain" }, ["invalid JSON"]]
+      end
+
+      private
+
+      def verify_subscription(data)
+        @handler&.call(Event.new(data))
+        [200, { "content-type" => "application/json" }, [JSON.generate(data)]]
+      end
+    end
+  end
+end