notion-client-ruby 0.1.0

data/lib/notion/endpoints/async_tasks.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Notion
+  module Generated
+    module Endpoints
+      class AsyncTasks
+        TERMINAL = %w[success completed failed canceled cancelled].freeze
+
+        def wait(task_id:, timeout: 300, interval: 1, sleeper: Kernel.method(:sleep))
+          deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+          attempt = 0
+          loop do
+            task = retrieve(task_id: task_id)
+            status = task.status.to_s
+            raise Error, "async task #{status}" if status.match?(/fail|cancel/)
+            return task if TERMINAL.include?(status)
+            raise TimeoutError, "async task timed out" if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+            sleeper.call(interval == :exponential ? [2**attempt, 30].min : interval)
+            attempt += 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/notion/endpoints/base.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Notion
+  module Endpoints
+    class Base
+      class << self
+        def operations
+          @operations ||= {}
+        end
+
+        def operation(name, verb, template, path:, query:, query_rules:, body_rules:)
+          operations[name] = {
+            verb: verb,
+            path: template,
+            path_params: path,
+            query_params: query,
+            query_rules: query_rules,
+            body_rules: body_rules
+          }
+        end
+      end
+
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      def invoke_operation(name, params)
+        if block_given?
+          builder = Query::Builder.new
+          yield builder
+          params = params.merge(builder.to_h)
+        end
+        operation = self.class.operations.fetch(name)
+        perform(
+          name,
+          operation[:verb],
+          operation[:path],
+          params,
+          path: operation[:path_params],
+          query: operation[:query_params],
+          rules: operation.slice(:query_rules, :body_rules)
+        )
+      end
+
+      def perform(name, verb, template, params, path:, query:, rules: {})
+        original_params = params.dup
+        request_path = path.reduce(template) { |value, key| value.sub("{#{key}}", escape(params.delete(key.to_sym))) }
+        validate_query!(params, rules.fetch(:query_rules, {}))
+        request_query = params.slice(*query.map(&:to_sym))
+        request_body = prepare_body(params.except(*query.map(&:to_sym)), rules.fetch(:body_rules, {}))
+        result = @client.request(verb, request_path, query: request_query, body: request_body)
+        return result unless result.is_a?(Objects::List)
+
+        result.with_fetcher { |cursor| public_send(name, **original_params, start_cursor: cursor) }
+      end
+
+      def prepare_body(body, rules)
+        missing = Array(rules[:required]).reject { |key| body.key?(key.to_sym) }
+        raise ArgumentError, "required body parameters are missing: #{missing.join(', ')}" unless missing.empty?
+
+        validate_body_variants!(body, rules[:variants])
+        validate_constraints!(body, rules)
+        body.empty? && !rules[:send_empty] ? nil : body
+      end
+
+      def validate_body_variants!(body, variants)
+        variants = Array(variants)
+        return if variants.empty? || variants.any? { |keys| keys.all? { |key| body.key?(key.to_sym) } }
+
+        expected = variants.map { |keys| keys.join(" + ") }.join(" or ")
+        raise ArgumentError, "body must include #{expected}"
+      end
+
+      def validate_query!(params, rules)
+        missing = Array(rules[:required]).reject { |key| params.key?(key.to_sym) }
+        raise ArgumentError, "required query parameters are missing: #{missing.join(', ')}" unless missing.empty?
+
+        validate_constraints!(params, rules)
+      end
+
+      def validate_constraints!(params, rules)
+        rules.fetch(:enums, {}).each do |key, values|
+          value = params[key.to_sym]
+          next if value.nil? || values.include?(value.to_s)
+
+          raise ArgumentError, "#{key} must be one of: #{values.join(', ')}"
+        end
+        rules.fetch(:max_lengths, {}).each do |key, length|
+          value = params[key.to_sym]
+          next unless value.respond_to?(:length) && value.length > length
+
+          raise ArgumentError, "#{key} exceeds #{length} characters"
+        end
+      end
+
+      def escape(value)
+        raise ArgumentError, "required path parameter is missing" if value.nil? || value.to_s.empty?
+
+        URI.encode_uri_component(value.to_s)
+      end
+    end
+  end
+end

data/lib/notion/endpoints/blocks.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Notion
+  module Generated
+    module Endpoints
+      class Blocks
+        def append_children(block_id:, children:, position: nil, after: nil, on_oversize: :split, **params)
+          successful_ids = []
+          Notion::Blocks::Chunker.new(children, on_oversize: on_oversize).chunks.each_with_index do |chunk, index|
+            placement = if index.zero?
+                          position || after_position(after)
+                        else
+                          after_position(successful_ids.last)
+                        end
+            response = perform(
+              :append_children,
+              :patch,
+              "/v1/blocks/{block_id}/children",
+              params.merge(block_id: block_id, children: chunk, position: placement).compact,
+              path: ["block_id"],
+              query: [],
+              rules: { body_rules: { send_empty: true, required: ["children"] } }
+            )
+            successful_ids.concat(response.results.filter_map(&:id)) if response.respond_to?(:results)
+          end
+          successful_ids
+        rescue Error => e
+          raise PartialAppendError.new(e.message, successful_ids: successful_ids, cause: e)
+        end
+
+        private
+
+        def after_position(id)
+          id && { type: "after_block", after_block: { id: id } }
+        end
+      end
+    end
+  end
+end

data/lib/notion/endpoints/data_sources.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Notion
+  module Generated
+    module Endpoints
+      class DataSources
+        def query(data_source_id:, **params)
+          if block_given?
+            builder = Query::Builder.new(
+              schema: @client.schema_for(data_source_id),
+              strict: @client.config.strict
+            )
+            yield builder
+            params.merge!(builder.to_h)
+          end
+          params[:data_source_id] = data_source_id
+          invoke_operation(:query, params)
+        end
+
+        def sync_since(data_source_id:, time:, **params)
+          filter = {
+            timestamp: "last_edited_time",
+            last_edited_time: { on_or_after: time.iso8601 }
+          }
+          query(data_source_id: data_source_id, **params, filter: filter)
+        end
+      end
+    end
+  end
+end

data/lib/notion/endpoints/file_uploads.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Notion
+  module Generated
+    module Endpoints
+      class FileUploads
+        def send(file_upload_id:, data:, filename:, content_type:, part_number: nil)
+          send_part(
+            file_upload_id: file_upload_id,
+            data: data,
+            filename: filename,
+            content_type: content_type,
+            part_number: part_number
+          )
+        end
+
+        def send_part(file_upload_id:, data:, filename:, content_type:, part_number: nil)
+          body, header = Multipart.encode(
+            data,
+            filename: filename,
+            content_type: content_type,
+            part_number: part_number
+          )
+          @client.request(
+            :post,
+            "/v1/file_uploads/#{URI.encode_uri_component(file_upload_id)}/send",
+            headers: { "content-type" => header },
+            body: body,
+            idempotent: !part_number.nil?
+          )
+        end
+      end
+    end
+  end
+end

data/lib/notion/endpoints/pages.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Notion
+  module Generated
+    module Endpoints
+      class Pages
+        def create(parent:, **params)
+          params[:parent] = parent
+          properties = params[:properties]
+          parent, data_source_id = normalize_parent(parent)
+          params[:parent] = parent unless parent.empty?
+          params[:properties] = convert(properties, data_source_id) if properties && data_source_id
+          invoke_operation(:create, params)
+        end
+
+        def update(page_id:, **params)
+          if primitive?(params[:properties])
+            page = retrieve(page_id: page_id)
+            parent = page.raw.fetch("parent", {})
+            data_source_id = parent["data_source_id"] || parent["database_id"]
+            params[:properties] = convert(params[:properties], data_source_id)
+          end
+          params[:page_id] = page_id
+          invoke_operation(:update, params)
+        end
+
+        private
+
+        def normalize_parent(parent)
+          data_source_id = parent[:data_source_id] || parent["data_source_id"]
+          database_id = parent[:database_id] || parent["database_id"]
+          return [parent, data_source_id] if data_source_id || !database_id
+          return [parent, database_id] if @client.config.notion_version == "2022-06-28"
+
+          data_source_id = @client.resolve_data_source(database_id: database_id)
+          normalized = parent.except(:database_id, "database_id").merge(data_source_id: data_source_id)
+          [normalized, data_source_id]
+        end
+
+        def primitive?(properties)
+          properties&.any? { |_name, value| !value.is_a?(Hash) }
+        end
+
+        def convert(properties, data_source_id)
+          return properties unless data_source_id
+
+          Objects::PropertySchema.convert(
+            properties,
+            @client.schema_for(data_source_id),
+            strict: @client.config.strict
+          )
+        end
+      end
+    end
+  end
+end

data/lib/notion/endpoints/views.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Notion
+  module Generated
+    module Endpoints
+      class Views
+        def with_query(view_id:, **params)
+          query = create_query(view_id: view_id, **params)
+          yield query_results(view_id: view_id, query_id: query.id)
+        ensure
+          delete_query(view_id: view_id, query_id: query.id) if query.respond_to?(:id)
+        end
+      end
+    end
+  end
+end

data/lib/notion/errors.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Notion
+  class Error < StandardError; end
+
+  class TransportError < Error
+    attr_reader :cause
+
+    def initialize(message, cause: nil)
+      @cause = cause
+      super(message)
+    end
+  end
+
+  class TimeoutError < TransportError; end
+
+  class APIError < Error
+    attr_reader :status, :code, :request_id, :additional_data, :response, :retry_after
+
+    def initialize(response)
+      unless response.respond_to?(:body)
+        super(response.to_s)
+        return
+      end
+
+      body = response.body.is_a?(Hash) ? response.body : {}
+      @status = response.status
+      @code = body["code"]
+      @request_id = response.request_id || body["request_id"]
+      @additional_data = body["additional_data"]
+      @retry_after = response.headers["retry-after"]&.to_f
+      @response = response
+      super(body["message"] || "Notion API request failed with status #{@status}")
+    end
+
+    def retryable?
+      status == 429 || status == 529 || status.between?(500, 599)
+    end
+
+    def self.from_response(response)
+      code = response.body.is_a?(Hash) && response.body["code"]
+      (ERROR_CODES[code] || STATUS_ERRORS[response.status] || self).new(response)
+    end
+  end
+
+  class BadRequestError < APIError; end
+  class InvalidJSONError < BadRequestError; end
+  class InvalidRequestURLError < BadRequestError; end
+  class InvalidRequestError < BadRequestError; end
+  class InvalidGrantError < BadRequestError; end
+  class ValidationError < BadRequestError; end
+  class MissingVersionError < BadRequestError; end
+  class InvalidBetaError < BadRequestError; end
+  class UnauthorizedError < APIError; end
+  class RestrictedResourceError < APIError; end
+  class ObjectNotFoundError < APIError; end
+  class ConflictError < APIError; end
+  class RateLimitedError < APIError; end
+  class ServerError < APIError; end
+  class InternalServerError < ServerError; end
+  class BadGatewayError < ServerError; end
+  class ServiceUnavailableError < ServerError; end
+  class DatabaseConnectionUnavailableError < ServiceUnavailableError; end
+  class GatewayTimeoutError < ServerError; end
+  class ServiceOverloadError < ServerError; end
+  class UnsupportedInVersionError < Error; end
+
+  class PartialAppendError < Error
+    attr_reader :successful_ids, :cause
+
+    def initialize(message, successful_ids:, cause: nil)
+      @successful_ids = successful_ids
+      @cause = cause
+      super(message)
+    end
+  end
+
+  APIError::ERROR_CODES = {
+    "invalid_json" => InvalidJSONError,
+    "invalid_request_url" => InvalidRequestURLError,
+    "invalid_request" => InvalidRequestError,
+    "invalid_grant" => InvalidGrantError,
+    "validation_error" => ValidationError,
+    "missing_version" => MissingVersionError,
+    "invalid_beta" => InvalidBetaError,
+    "unauthorized" => UnauthorizedError,
+    "restricted_resource" => RestrictedResourceError,
+    "object_not_found" => ObjectNotFoundError,
+    "conflict_error" => ConflictError,
+    "rate_limited" => RateLimitedError,
+    "internal_server_error" => InternalServerError,
+    "bad_gateway" => BadGatewayError,
+    "service_unavailable" => ServiceUnavailableError,
+    "database_connection_unavailable" => DatabaseConnectionUnavailableError,
+    "gateway_timeout" => GatewayTimeoutError,
+    "service_overload" => ServiceOverloadError
+  }.freeze
+  APIError::STATUS_ERRORS = {
+    400 => BadRequestError,
+    401 => UnauthorizedError,
+    403 => RestrictedResourceError,
+    404 => ObjectNotFoundError,
+    409 => ConflictError,
+    429 => RateLimitedError,
+    500 => InternalServerError,
+    502 => BadGatewayError,
+    503 => ServiceUnavailableError,
+    504 => GatewayTimeoutError,
+    529 => ServiceOverloadError
+  }.freeze
+end

data/lib/notion/experimental.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Notion
+  class Experimental
+    def initialize(client)
+      @client = client
+    end
+
+    def agents = @client.agents
+    def sessions = @client.sessions
+  end
+end

data/lib/notion/file_uploader.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "uri"
+require "tempfile"
+
+module Notion
+  class FileUploader
+    PART_SIZE = 20 * 1024 * 1024
+
+    def initialize(client)
+      @client = client
+    end
+
+    def upload(path: nil, io: nil, filename: nil, content_type: "application/octet-stream", on_progress: nil,
+               concurrency: 3)
+      raise ArgumentError, "concurrency must be positive" unless concurrency.to_i.positive?
+
+      if path
+        return File.open(path, "rb") do |file|
+          upload_io(file, filename || File.basename(path), content_type, on_progress, concurrency)
+        end
+      end
+
+      raise ArgumentError, "path or io is required" unless io
+
+      upload_io(io, filename || "upload.bin", content_type, on_progress, concurrency)
+    end
+
+    def import(url:, filename: nil, content_type: nil, wait: true, timeout: 300, interval: 1,
+               sleeper: Kernel.method(:sleep))
+      uri = URI(url)
+      raise ArgumentError, "URL must use http or https" unless %w[http https].include?(uri.scheme)
+
+      upload = @client.file_uploads.create(**{
+        mode: "external_url",
+        external_url: url,
+        filename: filename,
+        content_type: content_type
+      }.compact)
+      wait ? wait_for_upload(upload, timeout, interval, sleeper) : upload
+    end
+
+    private
+
+    def wait_for_upload(upload, timeout, interval, sleeper)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      loop do
+        status = upload.respond_to?(:status) ? upload.status.to_s : ""
+        return upload if status == "uploaded"
+        raise Error, "file import #{status}" if status.match?(/fail|expire/)
+        raise TimeoutError, "file import timed out" if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+
+        sleeper.call(interval)
+        upload = @client.file_uploads.retrieve(file_upload_id: upload.id)
+      end
+    end
+
+    def upload_io(io, filename, content_type, on_progress, concurrency)
+      size = io.respond_to?(:size) ? io.size : nil
+      return upload_unsized(io, filename, content_type, on_progress, concurrency) unless size
+
+      mode = size > PART_SIZE ? "multi_part" : "single_part"
+      parts = (size.to_f / PART_SIZE).ceil
+      create_params = {
+        mode: mode,
+        filename: filename,
+        content_type: content_type
+      }
+      create_params[:number_of_parts] = parts if mode == "multi_part"
+      upload = @client.file_uploads.create(**create_params)
+      options = { filename: filename, content_type: content_type, size: size, on_progress: on_progress,
+                  concurrency: concurrency }
+      send_parts(upload.id, io, mode, options)
+      mode == "multi_part" ? @client.file_uploads.complete(file_upload_id: upload.id) : upload
+    end
+
+    def upload_unsized(io, filename, content_type, on_progress, concurrency)
+      Tempfile.create("notion-upload") do |file|
+        loop do
+          chunk = io.read(PART_SIZE)
+          break unless chunk
+
+          file.write(chunk)
+        end
+        file.flush
+        file.rewind
+        upload_io(file, filename, content_type, on_progress, concurrency)
+      end
+    end
+
+    def send_parts(id, io, mode, options)
+      if mode == "multi_part"
+        return send_parts_in_parallel(
+          id, io, options[:filename], options[:content_type], options[:size], options[:on_progress],
+          options[:concurrency]
+        )
+      end
+
+      send_part(id, io.read(PART_SIZE), options[:filename], options[:content_type], nil)
+      options[:on_progress]&.call(options[:size], options[:size])
+    end
+
+    def send_parts_in_parallel(id, io, filename, content_type, size, on_progress, concurrency)
+      read_mutex = Mutex.new
+      progress_mutex = Mutex.new
+      sent = 0
+      part = 0
+      errors = Queue.new
+      workers = Array.new(concurrency) do
+        Thread.new do
+          loop do
+            job = read_mutex.synchronize do
+              data = io.read(PART_SIZE)
+              data && [part += 1, data]
+            end
+            break unless job
+
+            send_part(id, job.last, filename, content_type, job.first)
+            progress_mutex.synchronize do
+              sent += job.last.bytesize
+              on_progress&.call(sent, size)
+            end
+          end
+        rescue StandardError => e
+          errors << e
+        end
+      end
+      workers.each(&:join)
+      raise errors.pop unless errors.empty?
+    end
+
+    def send_part(id, data, filename, content_type, part_number)
+      @client.file_uploads.send_part(
+        file_upload_id: id,
+        data: data,
+        filename: filename,
+        content_type: content_type,
+        part_number: part_number
+      )
+    end
+  end
+end

data/lib/notion/generated/endpoints/agents.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+# This file is generated. DO NOT EDIT.
+
+module Notion
+  module Generated
+    module Endpoints
+      class Agents < Notion::Endpoints::Base
+      operation :query, :post, "/v1/agents/query", path: [], query: [], query_rules: { required: [], enums: {}, max_lengths: {} }, body_rules: { send_empty: true, required: [], variants: [], enums: {}, max_lengths: {} }
+      operation :retrieve, :get, "/v1/agents/{agent_id}", path: ["agent_id"], query: ["verbose"], query_rules: { required: [], enums: {}, max_lengths: {} }, body_rules: { send_empty: false, required: [], variants: [], enums: {}, max_lengths: {} }
+      operation :delete, :delete, "/v1/agents/{agent_id}", path: ["agent_id"], query: [], query_rules: { required: [], enums: {}, max_lengths: {} }, body_rules: { send_empty: false, required: [], variants: [], enums: {}, max_lengths: {} }
+      operation :insights, :get, "/v1/agents/{agent_id}/insights", path: ["agent_id"], query: ["start_time", "end_time"], query_rules: { required: [], enums: {}, max_lengths: {} }, body_rules: { send_empty: false, required: [], variants: [], enums: {}, max_lengths: {} }
+      operation :update_status, :patch, "/v1/agents/{agent_id}/status", path: ["agent_id"], query: [], query_rules: { required: [], enums: {}, max_lengths: {} }, body_rules: { send_empty: true, required: ["status"], variants: [["status"]], enums: {"status" => ["active", "disabled"]}, max_lengths: {} }
+      operation :update_credit_limit, :patch, "/v1/agents/{agent_id}/credit_limit", path: ["agent_id"], query: [], query_rules: { required: [], enums: {}, max_lengths: {} }, body_rules: { send_empty: true, required: ["credit_limit"], variants: [["credit_limit"]], enums: {}, max_lengths: {} }
+      operation :batch, :post, "/v1/agents/batch", path: [], query: [], query_rules: { required: [], enums: {}, max_lengths: {} }, body_rules: { send_empty: true, required: ["operations"], variants: [["operations"]], enums: {}, max_lengths: {} }
+
+    # Query agents
+    # @see https://developers.notion.com/reference/notion-agent-apis/query-agents
+    def query(**params, &block)
+
+      invoke_operation(:query, params, &block)
+    end
+    # Get agent
+    # @see https://developers.notion.com/reference/notion-agent-apis/retrieve-agent
+    def retrieve(agent_id:, **params, &block)
+        params[:agent_id] = agent_id
+      invoke_operation(:retrieve, params, &block)
+    end
+    # Delete agent
+    # @see https://developers.notion.com/reference/notion-agent-apis/delete-agent
+    def delete(agent_id:, **params, &block)
+        params[:agent_id] = agent_id
+      invoke_operation(:delete, params, &block)
+    end
+    # Get agent insights
+    # @see https://developers.notion.com/reference/notion-agent-apis/retrieve-agent-insights
+    def insights(agent_id:, **params, &block)
+        params[:agent_id] = agent_id
+      invoke_operation(:insights, params, &block)
+    end
+    # Update agent status
+    # @see https://developers.notion.com/reference/notion-agent-apis/update-agent-status
+    def update_status(agent_id:, status:, **params, &block)
+        params[:agent_id] = agent_id
+        params[:status] = status
+      invoke_operation(:update_status, params, &block)
+    end
+    # Update agent credit limit
+    # @see https://developers.notion.com/reference/notion-agent-apis/update-agent-credit-limit
+    def update_credit_limit(agent_id:, credit_limit:, **params, &block)
+        params[:agent_id] = agent_id
+        params[:credit_limit] = credit_limit
+      invoke_operation(:update_credit_limit, params, &block)
+    end
+    # Apply many agent operations
+    # @see https://developers.notion.com/reference/notion-agent-apis/batch-manage-agent
+    def batch(operations:, **params, &block)
+        params[:operations] = operations
+      invoke_operation(:batch, params, &block)
+    end
+      end
+    end
+  end
+end

data/lib/notion/generated/endpoints/async_tasks.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# This file is generated. DO NOT EDIT.
+
+module Notion
+  module Generated
+    module Endpoints
+      class AsyncTasks < Notion::Endpoints::Base
+      operation :retrieve, :get, "/v1/async_tasks/{task_id}", path: ["task_id"], query: [], query_rules: { required: [], enums: {}, max_lengths: {} }, body_rules: { send_empty: false, required: [], variants: [], enums: {}, max_lengths: {} }
+
+    # Retrieve an async task
+    # @see https://developers.notion.com/reference/retrieve-async-task
+    def retrieve(task_id:, **params, &block)
+        params[:task_id] = task_id
+      invoke_operation(:retrieve, params, &block)
+    end
+      end
+    end
+  end
+end