distributed-press-api-client 0.1.5 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9629ab7d59c1d050b2bab1917411f46ca1d1e23eede72d0ea99341d0dd2aca01
-  data.tar.gz: 5d755057e6eb43e84ae65409bdd864635c8135307a4377290ecc384ce8fc97e4
+  metadata.gz: 836e345691ad1ed5a6899ebc8bcfcb638e5b2d8fddfb6f947c84c2bd94f155b0
+  data.tar.gz: efe7d11dac7c925d328c0be16185e24a095be59ec11eedb223a30dfb9142f77c
 SHA512:
-  metadata.gz: d6bbbae13ac80552f7b83a3967ac74530a916c29ed8896f577b93028e3e5eb9002f7a23554cc8c84b5bc7fb150802873f862bf541c5f06da639767d0867895e2
-  data.tar.gz: f796cb6a9f5ed258a55580a32e8ba8625adc50ae367ec6eb29c885ddbd7f589d4b8ea9565eb019550f2045ba18928a2d6c8def03a21b1f329b6185066e622c41
+  metadata.gz: 10d33a9cc5f31928b07917a7db36bbdc21bfc3eb33f984eaa76aa760614fcdd6b929c8b0061e25388c691889ec187459a607f26ca75727a865fbab65857c6eb1
+  data.tar.gz: ad57ee2402ac1bcbb0359b14206d8fde897f9d66daa944b089ad8b80a6a5e5d46adf91244e259219a58ce419d958d516835bd266bdb00baa16656f38097524d7

data/lib/distributed_press/multipart.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+class DistributedPress
+  # Deals with multipart requests
+  class Multipart
+    # Newlines
+    NEWLINE  = "\r\n"
+
+    # Boundary separator
+    BOUNDARY = '--'
+
+    # Write the multipart header
+    #
+    # @param io [IO]
+    # @param filename [String]
+    def write_header(io, filename)
+      io.write BOUNDARY
+      io.write boundary
+      io.write NEWLINE
+      io.write "Content-Disposition: form-data; name=\"file\"; filename=\"#{filename}\""
+      io.write NEWLINE
+      io.write 'Content-Type: application/octet-stream'
+      io.write NEWLINE
+      io.write NEWLINE
+
+      nil
+    end
+
+    # Write the multipart footer
+    #
+    # @param io [IO]
+    def write_footer(io)
+      io.write NEWLINE
+      io.write BOUNDARY
+      io.write boundary
+      io.write BOUNDARY
+      io.write NEWLINE
+
+      nil
+    end
+
+    # Generate a MultiPart boundary and reuse it
+    #
+    # @return [String]
+    def boundary
+      @boundary ||= HTTParty::Request::MultipartBoundary.generate
+    end
+  end
+end

data/lib/distributed_press/v1/client/admin.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../client'
+
+class DistributedPress
+  module V1
+    class Client
+      # Admins can create and remove publishers
+      class Admin
+        attr_reader :client
+
+        # @param client [DistributedPress::V1::Client]
+        def initialize(client)
+          @client = client
+        end
+
+        # Creates a Admin, requires a token with admin capabilities
+        #
+        # @param schema [DistributedPress::V1::Schemas::NewAdmin]
+        # @return [DistributedPress::V1::Schemas::Admin]
+        def create(schema)
+          validate_schema! schema
+          validate_capabilities!
+
+          Schemas::Admin.new.call(**client.post(endpoint: '/v1/admin', schema: schema))
+        end
+
+        # Deletes a Admin, requires a token with admin capabilities
+        #
+        # @param schema [DistributedPress::V1::Schemas::Admin]
+        # @return [Boolean]
+        def delete(schema)
+          validate_schema! schema
+          validate_capabilities!
+
+          client.delete(endpoint: "/v1/admin/#{schema[:id]}", schema: schema)
+        end
+
+        private
+
+        # Raises an error if the schema is not valid
+        def validate_schema!(schema)
+          raise SchemaNotValidError unless schema.success?
+        end
+
+        # Raises an error if the client doesn't have the capabilities
+        def validate_capabilities!
+          raise TokenCapabilityMissingError, 'Token needs admin capability' unless client.token.admin?
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/client/auth.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../client'
+require_relative '../token'
+
+class DistributedPress
+  module V1
+    class Client
+      # Manage auth
+      class Auth
+        attr_reader :client
+
+        # @param client [DistributedPress::V1::Client]
+        def initialize(client)
+          @client = client
+        end
+
+        # Exchanges a token for another one
+        #
+        # @param schema [DistributedPress::V1::Schemas::NewTokenPayload]
+        # @return [DistributedPress::V1::Token]
+        def exchange(schema)
+          validate_schema! schema
+          validate_capabilities! schema
+
+          Token.new(token: client.post(endpoint: '/v1/auth/exchange', schema: schema).body)
+        end
+
+        # Revokes a token
+        #
+        # @param schema [DistributedPress::V1::Schemas::TokenPayload]
+        # @return [Boolean]
+        def revoke(schema)
+          validate_schema! schema
+
+          raise TokenCapabilityMissingError, 'Only admins can revoke tokens' unless client.token.admin?
+
+          client.delete(endpoint: "/v1/auth/revoke/#{schema[:tokenId]}", schema: schema)
+        end
+
+        private
+
+        # Raises an error if the schema is not valid
+        def validate_schema!(schema)
+          raise SchemaNotValidError unless schema.success?
+        end
+
+        # Raises an error if the client doesn't have the capabilities
+        # required.  Admins can do everything.
+        def validate_capabilities!(schema)
+          return if client.token.admin?
+
+          %w[publisher refresh].each do |capability|
+            if schema[:capabilities].include?(capability) && !client.token.public_send(:"#{capability}?")
+              raise TokenCapabilityMissingError, "Token needs #{capability} capability"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/client/publisher.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../client'
+
+class DistributedPress
+  module V1
+    class Client
+      # Publishers can create and update sites
+      class Publisher
+        # Client instance
+        #
+        # @return [DistributedPress::V1::Client]
+        attr_reader :client
+
+        # @param client [DistributedPress::V1::Client]
+        def initialize(client)
+          @client = client
+        end
+
+        # Creates a Publisher, requires a token with admin capabilities
+        #
+        # @param schema [DistributedPress::V1::Schemas::NewPublisher]
+        # @return [DistributedPress::V1::Schemas::Publisher]
+        def create(schema)
+          validate_schema! schema
+          validate_capabilities!
+
+          Schemas::Publisher.new.call(**client.post(endpoint: '/v1/publisher', schema: schema))
+        end
+
+        # Deletes a Publisher, requires a token with admin capabilities
+        #
+        # @param schema [DistributedPress::V1::Schemas::Publisher]
+        # @return [Boolean]
+        def delete(schema)
+          validate_schema! schema
+          validate_capabilities!
+
+          client.delete(endpoint: "/v1/publisher/#{schema[:id]}", schema: schema)
+        end
+
+        private
+
+        # Raises an error if the schema is not valid
+        def validate_schema!(schema)
+          raise SchemaNotValidError unless schema.success?
+        end
+
+        # Raises an error if the client doesn't have the capabilities
+        def validate_capabilities!
+          raise TokenCapabilityMissingError, 'Token needs admin capability' unless client.token.admin?
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/client/site.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+require_relative '../client'
+require_relative '../errors'
+require_relative '../../multipart'
+
+class DistributedPress
+  module V1
+    class Client
+      # Sites can be created and updated to set distribution options,
+      # and a tarball with their contents can be sent to Distributed
+      # Press.
+      class Site
+        # Client instance
+        #
+        # @return [DistributedPress::V1::Client]
+        attr_reader :client
+
+        # @param client [DistributedPress::V1::Client]
+        def initialize(client)
+          @client = client
+        end
+
+        # Retrieves information about a site
+        #
+        # @param schema [DistributedPress::V1::Schemas::PublishingSite]
+        def show(schema)
+          validate_schema! schema
+          validate_capabilities!
+
+          Schemas::Site.new.call(**client.get(endpoint: "/v1/sites/#{schema[:id]}"))
+        end
+
+        # Creates a website
+        #
+        # @param schema [DistributedPress::V1::Schemas::NewSite]
+        # @return [DistributedPress::V1::Schemas::Site]
+        def create(schema)
+          validate_schema! schema
+          validate_capabilities!
+
+          Schemas::Site.new.call(**client.post(endpoint: '/v1/sites', schema: schema))
+        end
+
+        # Updates a website configuration
+        #
+        # @param schema [DistributedPress::V1::Schemas::UpdateSite]
+        # @return [DistributedPress::V1::Schemas::Site]
+        def update(schema)
+          validate_schema! schema
+          validate_capabilities!
+
+          Schemas::Site.new.call(**client.post(endpoint: "/v1/sites/#{schema[:id]}", schema: schema))
+        end
+
+        # Publish changes to a website
+        #
+        # @param schema [DistributedPress::V1::Schemas::PublishingSite]
+        # @param path [String,Pathname]
+        # @return [Bool]
+        def publish(schema, path)
+          validate_schema! schema
+          validate_capabilities!
+          responses = []
+
+          Open3.popen2('tar', '--to-stdout', '--create', '--gzip', '--dereference', '--directory', path,
+                       '.') do |_, stdout, thread|
+            stream, body = IO.pipe
+            multipart = Multipart.new
+
+            Thread.new do
+              multipart.write_header body, 'site.tar.gz'
+              IO.copy_stream stdout, body
+              multipart.write_footer body
+
+              body.close
+            end
+
+            responses << client.put(endpoint: "/v1/sites/#{schema[:id]}", io: stream, boundary: multipart.boundary)
+
+            # wait for tar to finish
+            responses << thread.value
+          end
+
+          responses.all? &:success?
+        end
+
+        def delete
+          raise NotImplementedError
+        end
+
+        private
+
+        # Raises an error if the schema is not valid
+        def validate_schema!(schema)
+          raise SchemaNotValidError unless schema.success?
+        end
+
+        # Raises an error if the client doesn't have the capabilities
+        def validate_capabilities!
+          return if client.token.publisher? || client.token.admin?
+
+          raise TokenCapabilityMissingError, 'Token needs publisher or admin capability'
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/client.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'httparty'
+require 'open3'
+
+require_relative '../version'
+require_relative 'token'
+require_relative 'errors'
+require_relative 'schemas/site'
+require_relative 'schemas/new_site'
+require_relative 'schemas/update_site'
+
+class DistributedPress
+  module V1
+    # Distributed Press APIv1 client
+    class Client
+      include ::HTTParty
+
+      # API URL
+      # @return [String]
+      attr_reader :url
+
+      # Auth token
+      # @return [DistributedPress::V1:Token]
+      attr_reader :token
+
+      # Initializes a client with a API address and token.  Depending on
+      # the token capabilities we'll be able to do some actions or not.
+      #
+      # Automatically gets a new token if it's about to expire
+      #
+      # @param url [String]
+      # @param token [String,Distributed::Press::V1::Token]
+      def initialize(url: 'https://api.distributed.press', token: nil)
+        self.class.default_options[:base_uri] = @url = HTTParty.normalize_base_uri(url)
+
+        @token =
+          case token
+          when Token then token
+          else Token.new(token: token.to_s)
+          end
+
+        return if @token.forever?
+
+        raise TokenExpiredError if @token.expired?
+
+        exchange_token! if @token.expires_in_x_seconds < 60
+      end
+
+      # GET request
+      #
+      # @param endpoint [String]
+      # @return [Hash]
+      def get(endpoint:)
+        self.class.get(endpoint, headers: headers).tap do |response|
+          process_response_errors! endpoint, response
+        end
+      end
+
+      # POST request
+      #
+      # @param endpoint [String]
+      # @param schema [Dry::Schema::Result]
+      # @return [Hash]
+      def post(endpoint:, schema:)
+        self.class.post(endpoint, body: schema.to_h.to_json, headers: headers).tap do |response|
+          process_response_errors! endpoint, response
+        end
+      end
+
+      # PUT request
+      #
+      # @param endpoint [String]
+      # @param io [IO]
+      # @param boundary [String]
+      # @return [Hash]
+      def put(endpoint:, io:, boundary:)
+        multipart_headers = headers.dup
+        multipart_headers['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+        multipart_headers['Transfer-Encoding'] = 'chunked'
+
+        self.class.put(endpoint, body_stream: io, headers: multipart_headers).tap do |response|
+          process_response_errors! endpoint, response
+        end
+      end
+
+      # PATCH request
+      #
+      # @param endpoint [String]
+      # @param schema [Dry::Schema::Result]
+      def patch(endpoint:, schema:); end
+
+      # DELETE request, they return 200 when deletion is confirmed.
+      #
+      # @param endpoint [String]
+      # @param schema [Dry::Schema::Result]
+      # @return [Boolean]
+      def delete(endpoint:, schema:)
+        self.class.delete(endpoint, body: schema.to_h.to_json, headers: headers).tap do |response|
+          process_response_errors! endpoint, response
+        end.ok?
+      end
+
+      # Exchanges a token for a new one if expired.  Modifies the token
+      # used for initialization.  If you need the token for subsequent
+      # requests you can chain them.
+      def exchange_token!
+        raise TokenCapabilityMissingError, 'Exchanging tokens requires refresh capability' unless token.refresh?
+
+        new_token_payload = Schemas::NewTokenPayload.new.call(capabilities: token.capabilities)
+
+        @token = Token.new(token: post(endpoint: '/v1/auth/exchange', schema: new_token_payload).body)
+        nil
+      end
+
+      # Default headers
+      #
+      # @return [Hash]
+      def headers
+        @headers ||= {
+          'User-Agent' => "DistributedPress/#{DistributedPress::VERSION}",
+          'Accept' => 'application/json',
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{token}"
+        }
+      end
+
+      private
+
+      # Raise errors on server responses
+      #
+      # @param endpoint [String]
+      # @param response [HTTParty::Response]
+      def process_response_errors!(endpoint, response)
+        raise TokenUnauthorizedError if response.unauthorized?
+        raise Error, "#{endpoint}: #{response.code} #{response.to_s.tr("\n", "")}" unless response.ok?
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/errors.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class DistributedPress
+  module V1
+    # Base error
+    class Error < StandardError; end
+
+    # Token errors
+    class TokenError < Error; end
+
+    # Schema errors
+    class SchemaError < Error; end
+
+    # Header not valid
+    class TokenHeaderNotValidError < TokenError
+      def initialize(msg = 'Token header not valid')
+        super
+      end
+    end
+
+    # Payload not valid
+    class TokenPayloadNotValidError < TokenError
+      def initialize(msg = 'Token payload not valid')
+        super
+      end
+    end
+
+    # A token expired can't be exchanged for a new one
+    class TokenExpiredError < TokenError
+      def initialize(msg = 'Token expired! Get a new token from an admin')
+        super
+      end
+    end
+
+    # A capability is missing
+    class TokenCapabilityMissingError < TokenError; end
+
+    # Token is not authorized to do this action or is revoked
+    class TokenUnauthorizedError < TokenError
+      def initialize(msg = 'Token is not authorized or revoked')
+        super
+      end
+    end
+
+    # Schema doesn't have the required information
+    class SchemaNotValidError < SchemaError
+      def initialize(msg = 'Schema is not valid')
+        super
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/schemas/admin.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+class DistributedPress
+  module V1
+    module Schemas
+      # Schema for full admin
+      class Admin < Dry::Schema::JSON
+        define do
+          required(:id).filled(:string)
+          required(:name).filled(:string)
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/schemas/http_protocol.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+class DistributedPress
+  module V1
+    module Schemas
+      # HTTP protocol
+      class HttpProtocol < Dry::Schema::JSON
+        define do
+          required(:enabled).value(:bool)
+          # TODO: Validate URL
+          required(:link).filled(:string)
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/schemas/hyper_protocol.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+class DistributedPress
+  module V1
+    module Schemas
+      # Hypercore protocol
+      class HyperProtocol < Dry::Schema::JSON
+        define do
+          required(:enabled).value(:bool)
+          # TODO: Validate URL
+          required(:link).filled(:string)
+          required(:gateway).filled(:string)
+          required(:raw).filled(:string)
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/schemas/ipfs_protocol.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+class DistributedPress
+  module V1
+    module Schemas
+      # IPFS protocol
+      class IpfsProtocol < Dry::Schema::JSON
+        define do
+          required(:enabled).value(:bool)
+          # TODO: Validate URL
+          required(:link).filled(:string)
+          required(:gateway).filled(:string)
+          required(:cid).filled(:string)
+          required(:pubKey).filled(:string)
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/schemas/new_admin.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+class DistributedPress
+  module V1
+    module Schemas
+      # Schema representing a new admin.
+      class NewAdmin < Dry::Schema::JSON
+        define do
+          required(:name).filled(:string)
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/schemas/new_publisher.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+class DistributedPress
+  module V1
+    module Schemas
+      # Schema representing a new publisher.
+      class NewPublisher < Dry::Schema::JSON
+        define do
+          required(:name).filled(:string)
+        end
+      end
+    end
+  end
+end

data/lib/distributed_press/v1/schemas/new_site.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'dry-schema'
+
+class DistributedPress
+  module V1
+    module Schemas
+      # Schema representing a new site.  They are created by domain and
+      # optionally protocols enabled.
+      class NewSite < Dry::Schema::JSON
+        define do
+          # TODO: Validate domain name
+          required(:domain).filled(:string)
+
+          optional(:protocols).hash do
+            optional(:http).filled(:bool)
+            optional(:ipfs).filled(:bool)
+            optional(:hyper).filled(:bool)
+          end
+        end
+      end
+    end
+  end
+end