notion-client-ruby 0.1.0

data/lib/notion/markdown/local_converter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Notion
+  module Markdown
+    module LocalConverter
+      module_function
+
+      def to_blocks(markdown)
+        markdown.lines.filter_map do |line|
+          text = line.chomp
+          next if text.empty?
+
+          hashes, content = text.match(/\A(\#{1,3})\s+(.*)\z/)&.captures
+          type = hashes ? "heading_#{hashes.length}" : "paragraph"
+          content ||= text
+          { "object" => "block", "type" => type, type => rich_text(content) }
+        end
+      end
+
+      def to_markdown(blocks)
+        blocks.map do |block|
+          type = block["type"]
+          rich_text = Array(block.dig(type, "rich_text"))
+          text = rich_text.map { |item| item["plain_text"] || item.dig("text", "content") }.join
+          type.start_with?("heading_") ? "#{'#' * type.delete_prefix('heading_').to_i} #{text}" : text
+        end.join("\n\n")
+      end
+
+      def rich_text(content)
+        { "rich_text" => [{ "type" => "text", "text" => { "content" => content } }] }
+      end
+    end
+  end
+end

data/lib/notion/middleware/api_version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Notion
+  module Middleware
+    class ApiVersion
+      def initialize(app, config)
+        @app = app
+        @config = config
+      end
+
+      def call(request)
+        headers = request.headers.merge("notion-version" => @config.notion_version)
+        headers["notion-beta"] = @config.betas.join(",") unless @config.betas.empty?
+        @app.call(request.with(headers: headers))
+      end
+    end
+  end
+end

data/lib/notion/middleware/authentication.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Notion
+  module Middleware
+    class Authentication
+      def initialize(app, config)
+        @app = app
+        @config = config
+        @refresh_mutex = Mutex.new
+      end
+
+      def call(request)
+        token = access_token
+        raise ConfigurationError, "token is required" if token.nil? || token.empty?
+
+        headers = request.headers.merge(
+          "authorization" => "Bearer #{token}",
+          "user-agent" => @config.user_agent
+        )
+        @app.call(request.with(headers: headers))
+      end
+
+      private
+
+      def access_token
+        token = @config.token_store&.read(@config.token_key)
+        token = refresh_expired(token) if expired?(token) && @config.auto_refresh
+        token&.access_token || @config.token
+      end
+
+      def refresh_expired(token)
+        @refresh_mutex.synchronize do
+          current = @config.token_store.read(@config.token_key)
+          expired?(current) ? refresh(current || token) : current
+        end
+      end
+
+      def expired?(token)
+        token&.expires_at && token.expires_at <= Time.now
+      end
+
+      def refresh(token)
+        raise ConfigurationError, "oauth_client is required for token refresh" unless @config.oauth_client
+        raise ConfigurationError, "refresh token is missing" unless token.refresh_token
+
+        refreshed = @config.oauth_client.refresh(refresh_token: token.refresh_token)
+        @config.token_store.write(@config.token_key, refreshed)
+        refreshed
+      end
+    end
+  end
+end

data/lib/notion/middleware/compatibility.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Notion
+  module Middleware
+    class Compatibility
+      def initialize(app, config)
+        @app = app
+        @version = config.notion_version
+      end
+
+      def call(request)
+        response = @app.call(Compat.request(@version, request))
+        Compat.response(@version, response)
+      end
+    end
+  end
+end

data/lib/notion/middleware/instrumentation.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Notion
+  module Middleware
+    class Instrumentation
+      @subscribers = []
+      @mutex = Mutex.new
+
+      class << self
+        attr_reader :subscribers
+
+        def subscribe(&block)
+          @mutex.synchronize { subscribers << block }
+          block
+        end
+
+        def unsubscribe(block)
+          @mutex.synchronize { subscribers.delete(block) }
+        end
+
+        def each_subscriber(&)
+          @mutex.synchronize { subscribers.dup }.each(&)
+        end
+
+        def publish(name, payload)
+          each_subscriber { |subscriber| subscriber.call(name, payload) }
+          ActiveSupport::Notifications.instrument(name, payload) if defined?(ActiveSupport::Notifications)
+        end
+      end
+
+      def initialize(app, clock: Process.method(:clock_gettime))
+        @app = app
+        @clock = clock
+      end
+
+      def call(request)
+        started = monotonic
+        response = @app.call(request)
+        publish(request, response, monotonic - started)
+        response
+      end
+
+      private
+
+      def publish(request, response, duration)
+        payload = {
+          method: request.verb,
+          path: request.path,
+          status: response.status,
+          duration: duration,
+          request_id: response.request_id,
+          attempt: response.attempt,
+          retried: response.retried
+        }
+        self.class.publish("request.notion", payload)
+      end
+
+      def monotonic
+        @clock.call(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/notion/middleware/json_codec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Notion
+  module Middleware
+    class JsonCodec
+      def initialize(app)
+        @app = app
+      end
+
+      def call(request)
+        response = @app.call(encode(request))
+        response.with(body: decode(response))
+      end
+
+      private
+
+      def encode(request)
+        return request unless request.body.is_a?(Hash) || request.body.is_a?(Array)
+
+        request.with(
+          body: JSON.generate(request.body),
+          headers: request.headers.merge("content-type" => "application/json")
+        )
+      end
+
+      def decode(response)
+        return nil if response.body.nil? || response.body.empty?
+
+        JSON.parse(response.body)
+      rescue JSON::ParserError
+        response.body
+      end
+    end
+  end
+end

data/lib/notion/middleware/logging.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Notion
+  module Middleware
+    class Logging
+      SENSITIVE = /authorization|token|secret/i
+
+      def initialize(app, logger:, level: :info)
+        @app = app
+        @logger = logger
+        @level = level
+      end
+
+      def call(request)
+        return @app.call(request) unless @logger
+
+        log(event: "request", method: request.verb, path: request.path, headers: redact(request.headers))
+        response = @app.call(request)
+        log(event: "response", status: response.status, request_id: response.request_id)
+        response
+      end
+
+      private
+
+      def redact(value)
+        value.to_h { |key, item| [key, key.to_s.match?(SENSITIVE) ? "[REDACTED]" : item] }
+      end
+
+      def log(payload)
+        @logger.public_send(@level, JSON.generate(payload))
+      end
+    end
+  end
+end

data/lib/notion/middleware/rate_limiter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Notion
+  module Middleware
+    class RateLimiter
+      State = Struct.new(:tokens, :updated_at, :blocked_until, :mutex)
+
+      class MemoryStore
+        def initialize
+          @states = {}
+          @mutex = Mutex.new
+        end
+
+        def state(key, burst, now)
+          return State.new(burst, now, now, Mutex.new) unless key
+
+          @mutex.synchronize { @states[key] ||= State.new(burst, now, now, Mutex.new) }
+        end
+      end
+
+      DEFAULT_STORE = MemoryStore.new
+
+      def initialize(
+        app, rate:, burst:, key: nil, store: DEFAULT_STORE,
+        clock: Process.method(:clock_gettime), sleeper: Kernel.method(:sleep)
+      )
+        @app = app
+        @rate = rate.to_f
+        @burst = burst.to_f
+        @clock = clock
+        @sleeper = sleeper
+        @state = store.state(key && [key, @rate, @burst], @burst, monotonic)
+      end
+
+      def call(request)
+        wait
+        response = @app.call(request)
+        pause(response.headers["retry-after"].to_f, response) if response.status == 429
+        response
+      end
+
+      private
+
+      def wait
+        loop do
+          delay = @state.mutex.synchronize { next_delay }
+          return unless delay.positive?
+
+          @sleeper.call(delay)
+        end
+      end
+
+      def next_delay
+        now = monotonic
+        return @state.blocked_until - now if now < @state.blocked_until
+
+        @state.tokens = [@burst, @state.tokens + ((now - @state.updated_at) * @rate)].min
+        @state.updated_at = now
+        return (1.0 - @state.tokens) / @rate if @state.tokens < 1.0
+
+        @state.tokens -= 1.0
+        0
+      end
+
+      def pause(seconds, response)
+        @state.mutex.synchronize do
+          @state.blocked_until = [@state.blocked_until, monotonic + seconds].max
+        end
+        reason = response.body&.dig("additional_data", "rate_limit_reason") if response.body.is_a?(Hash)
+        Instrumentation.publish("rate_limited.notion", retry_after: seconds, reason: reason)
+      end
+
+      def monotonic
+        @clock.call(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/notion/middleware/retry.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Notion
+  module Middleware
+    class Retry
+      RETRYABLE = [429, 529].freeze
+      IDEMPOTENT_RETRYABLE = [500, 502, 503, 504].freeze
+
+      def initialize(app, max_attempts:, cap:, sleeper: Kernel.method(:sleep), random: Random.new)
+        @app = app
+        @max_attempts = max_attempts
+        @cap = cap
+        @sleeper = sleeper
+        @random = random
+      end
+
+      def call(request)
+        attempt = 0
+        loop do
+          attempt += 1
+          response = @app.call(request)
+          unless attempt < @max_attempts && retryable?(response, request)
+            return response.with(attempt: attempt, retried: attempt > 1)
+          end
+
+          @sleeper.call(delay(response, attempt))
+        end
+      end
+
+      private
+
+      def retryable?(response, request)
+        RETRYABLE.include?(response.status) ||
+          (request.idempotent? && IDEMPOTENT_RETRYABLE.include?(response.status))
+      end
+
+      def delay(response, attempt)
+        retry_after = response.headers["retry-after"]
+        return retry_after.to_f if retry_after
+
+        @random.rand * [2**(attempt - 1), @cap].min
+      end
+    end
+  end
+end

data/lib/notion/middleware/stack.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Notion
+  module Middleware
+    class Stack
+      def self.build(adapter, config)
+        app = JsonCodec.new(adapter)
+        app = Compatibility.new(app, config)
+        app = ApiVersion.new(app, config)
+        app = Authentication.new(app, config)
+        key = config.token || (config.token_store && [config.token_store.object_id, config.token_key])
+        store = config.rate_limit_store || RateLimiter::DEFAULT_STORE
+        app = RateLimiter.new(app, rate: config.rate, burst: config.burst, key: key, store: store)
+        app = Retry.new(app, max_attempts: config.max_attempts, cap: config.retry_cap)
+        app = Logging.new(app, logger: config.logger, level: config.log_level)
+        Instrumentation.new(app)
+      end
+    end
+  end
+end

data/lib/notion/middleware.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "middleware/stack"
+require_relative "middleware/json_codec"
+require_relative "middleware/compatibility"
+require_relative "middleware/api_version"
+require_relative "middleware/authentication"
+require_relative "middleware/rate_limiter"
+require_relative "middleware/retry"
+require_relative "middleware/logging"
+require_relative "middleware/instrumentation"

data/lib/notion/multipart.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Notion
+  module Multipart
+    module_function
+
+    def encode(data, filename:, content_type:, part_number: nil)
+      filename = quoted_header_value(filename, "filename")
+      content_type = header_value(content_type, "content_type")
+      boundary = "notion-#{SecureRandom.hex(12)}"
+      body = +"".b
+      append_field(body, boundary, "part_number", part_number.to_s) if part_number
+      body << "--#{boundary}\r\n"
+      body << %(Content-Disposition: form-data; name="file"; filename="#{filename}"\r\n)
+      body << "Content-Type: #{content_type}\r\n\r\n"
+      body << data.b << "\r\n--#{boundary}--\r\n"
+      [body, "multipart/form-data; boundary=#{boundary}"]
+    end
+
+    def header_value(value, name)
+      value = value.to_s
+      raise ArgumentError, "#{name} cannot contain newlines" if value.match?(/[\r\n]/)
+
+      value
+    end
+
+    def quoted_header_value(value, name)
+      header_value(value, name).gsub(/[\\"]/) { |character| "\\#{character}" }
+    end
+
+    def append_field(body, boundary, name, value)
+      body << "--#{boundary}\r\n"
+      body << %(Content-Disposition: form-data; name="#{name}"\r\n\r\n)
+      body << "#{value}\r\n"
+    end
+  end
+end

data/lib/notion/oauth.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Notion
+  module OAuth
+    Token = Data.define(:access_token, :refresh_token, :bot_id, :workspace_id, :expires_at, :raw)
+
+    class Client
+      def initialize(client_id:, client_secret:, redirect_uri:, base_url: "https://api.notion.com")
+        @client_id = client_id
+        @client_secret = client_secret
+        @redirect_uri = redirect_uri
+        @base_url = base_url
+      end
+
+      def authorize_url(state:, owner: "user")
+        query = URI.encode_www_form(
+          client_id: @client_id,
+          response_type: "code",
+          owner: owner,
+          redirect_uri: @redirect_uri,
+          state: state
+        )
+        "https://api.notion.com/v1/oauth/authorize?#{query}"
+      end
+
+      def exchange(code:)
+        token_request(grant_type: "authorization_code", code: code, redirect_uri: @redirect_uri)
+      end
+
+      def refresh(refresh_token:)
+        token_request(grant_type: "refresh_token", refresh_token: refresh_token)
+      end
+
+      def introspect(token:)
+        request("/v1/oauth/introspect", token: token)
+      end
+
+      def revoke(token:)
+        request("/v1/oauth/revoke", token: token)
+      end
+
+      private
+
+      def token_request(**body)
+        data = request("/v1/oauth/token", body)
+        Token.new(
+          access_token: data["access_token"],
+          refresh_token: data["refresh_token"],
+          bot_id: data["bot_id"],
+          workspace_id: data["workspace_id"],
+          expires_at: data["expires_in"] && (Time.now + data["expires_in"]),
+          raw: data
+        )
+      end
+
+      def request(path, body)
+        uri = URI.join(@base_url, path)
+        request = Net::HTTP::Post.new(uri)
+        credentials = ["#{@client_id}:#{@client_secret}"].pack("m0")
+        request["authorization"] = "Basic #{credentials}"
+        request["content-type"] = "application/json"
+        request.body = JSON.generate(body)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") { |http| http.request(request) }
+        data = JSON.parse(response.body)
+        raise Error, data["message"] || "OAuth request failed" unless response.is_a?(Net::HTTPSuccess)
+
+        data
+      end
+    end
+
+    class TokenStore
+      def read(_key) = raise(NotImplementedError)
+      def write(_key, _token) = raise(NotImplementedError)
+    end
+
+    class MemoryTokenStore < TokenStore
+      def initialize
+        super
+        @tokens = {}
+        @mutex = Mutex.new
+      end
+
+      def read(key) = @mutex.synchronize { @tokens[key] }
+      def write(key, token) = @mutex.synchronize { @tokens[key] = token }
+    end
+  end
+end

data/lib/notion/object_factory.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Notion
+  module ObjectFactory
+    TYPES = {
+      "page" => Objects::Page,
+      "database" => Objects::Database,
+      "data_source" => Objects::DataSource,
+      "block" => Objects::Block,
+      "user" => Objects::User,
+      "comment" => Objects::Comment,
+      "view" => Objects::View,
+      "file_upload" => Objects::File,
+      "async_task" => Objects::AsyncTask,
+      "list" => Objects::List
+    }.freeze
+
+    module_function
+
+    def build(value)
+      return wrap_value(value) unless value.is_a?(Hash)
+      if !value.key?("object") && value.key?("type") && value.key?(value["type"])
+        return Objects::PropertyValue.build(value)
+      end
+      return Objects::Block.build(value) if value["object"] == "block"
+
+      klass = value.key?("results") ? Objects::List : TYPES.fetch(value["object"], Objects::Unknown)
+      klass.new(value)
+    end
+
+    def wrap_value(value)
+      case value
+      when Hash then value.key?("object") ? build(value) : value.transform_values { |item| wrap_value(item) }
+      when Array then value.map { |item| wrap_value(item) }
+      else value
+      end
+    end
+  end
+end

data/lib/notion/objects/base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Notion
+  module Objects
+    class Base
+      attr_reader :raw
+
+      def initialize(raw)
+        @raw = deep_freeze(raw)
+      end
+
+      def [](key)
+        value_for(key.to_s)
+      end
+
+      def deconstruct_keys(keys)
+        selected = keys || raw.keys
+        selected.to_h { |key| [key.to_sym, value_for(key.to_s)] }
+      end
+
+      def in_trash?
+        !!(raw["in_trash"] || raw["archived"])
+      end
+
+      def inspect
+        attributes = %w[object id type].filter_map { |key| "#{key}=#{raw[key].inspect}" if raw.key?(key) }
+        "#<#{self.class} #{attributes.join(' ')}>"
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        raw.key?(attribute_name(name)) || super
+      end
+
+      def method_missing(name, *args)
+        key = attribute_name(name)
+        return super unless args.empty? && raw.key?(key)
+
+        name.end_with?("?") ? !!raw[key] : value_for(key)
+      end
+
+      private
+
+      def deep_freeze(value)
+        case value
+        when Hash then value.each_value { |item| deep_freeze(item) }
+        when Array then value.each { |item| deep_freeze(item) }
+        end
+        value.freeze
+      end
+
+      def attribute_name(name)
+        name.to_s.delete_suffix("?")
+      end
+
+      def value_for(key)
+        ObjectFactory.wrap_value(raw[key])
+      end
+    end
+
+    class Unknown < Base; end
+  end
+end