pocketbase 0.1.1

data/lib/pocketbase/services/base_service.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module PocketBase
+  module Services
+    # Base class for all API services (port of js-sdk BaseService).
+    class BaseService
+      attr_reader :client
+
+      # Send-level option keys; anything else in an options hash is treated
+      # as a query parameter (mirrors js-sdk normalizeUnknownQueryParams).
+      SEND_OPTION_KEYS = %i[
+        method headers body query params request_key timeout
+      ].freeze
+
+      def initialize(client)
+        @client = client
+      end
+
+      private
+
+      # Builds the options hash for Client#send_request:
+      # merges defaults with user options, folds :params into :query and
+      # moves unknown top-level keys into :query.
+      def send_options(defaults = {}, options = {})
+        normalized = {}
+        (options || {}).each { |k, v| normalized[k.to_sym] = v }
+        opts = defaults.merge(normalized)
+        query = {}
+        query.merge!(stringify_top(opts.delete(:params))) if opts[:params]
+        query.merge!(stringify_top(opts.delete(:query))) if opts[:query]
+
+        opts.keys.each do |key|
+          next if SEND_OPTION_KEYS.include?(key.to_sym)
+
+          query[key] = opts.delete(key)
+        end
+
+        opts[:query] = query unless query.empty?
+        opts
+      end
+
+      def stringify_top(hash)
+        result = {}
+        (hash || {}).each { |k, v| result[k] = v }
+        result
+      end
+    end
+  end
+end

data/lib/pocketbase/services/batch_service.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module PocketBase
+  module Services
+    # Batch service for transactional multi-requests (port of js-sdk BatchService).
+    #
+    #   batch = pb.create_batch
+    #   batch.collection("posts").create(title: "hello")
+    #   batch.collection("posts").update("RECORD_ID", title: "hi")
+    #   batch.collection("posts").delete("OTHER_ID")
+    #   results = batch.send  # => [{ "status" => 200, "body" => {...} }, ...]
+    class BatchService < BaseService
+      def initialize(client)
+        super
+        @requests = []
+        @subs = {}
+      end
+
+      # Starts constructing a batch request entry for the given collection.
+      def collection(collection_id_or_name)
+        key = collection_id_or_name.to_s
+        @subs[key] ||= SubBatchService.new(@requests, key, @client)
+      end
+
+      # Sends the queued batch requests.
+      def send(options = {})
+        form = MultipartBody.new
+        json_data = []
+
+        @requests.each_with_index do |req, i|
+          json_data << {
+            "method" => req[:method],
+            "url" => req[:url],
+            "headers" => req[:headers],
+            "body" => req[:json],
+          }
+          (req[:files] || {}).each do |key, files|
+            Array(files).each do |file|
+              info = Multipart.file_info(file, key.to_s)
+              form.add_file("requests.#{i}.#{key}", info[:filename], info[:content_type], info[:data])
+            end
+          end
+        end
+
+        form.add_json_payload({ "requests" => json_data })
+
+        opts = send_options({ method: "POST", body: form }, options)
+        @client.send_request("/api/batch", opts)
+      end
+    end
+
+    # Per-collection batch request builder.
+    class SubBatchService
+      def initialize(requests, collection_id_or_name, client)
+        @requests = requests
+        @collection_id_or_name = collection_id_or_name
+        @client = client
+      end
+
+      # Registers an upsert request (update when body has an existing id, else create).
+      def upsert(body_params = nil, options = {})
+        enqueue("PUT", base_records_path, body_params, options)
+      end
+
+      # Registers a create request.
+      def create(body_params = nil, options = {})
+        enqueue("POST", base_records_path, body_params, options)
+      end
+
+      # Registers an update request.
+      def update(id, body_params = nil, options = {})
+        enqueue("PATCH", "#{base_records_path}/#{Utils.encode_uri_component(id.to_s)}", body_params, options)
+      end
+
+      # Registers a delete request.
+      def delete(id, options = {})
+        enqueue("DELETE", "#{base_records_path}/#{Utils.encode_uri_component(id.to_s)}", nil, options)
+      end
+
+      private
+
+      def base_records_path
+        "/api/collections/#{Utils.encode_uri_component(@collection_id_or_name)}/records"
+      end
+
+      def enqueue(http_method, url, body_params, options)
+        options = (options || {}).dup
+        options[:body] = body_params || {}
+        request = { method: http_method, url: url }
+        prepare_request(request, options)
+        @requests << request
+        nil
+      end
+
+      def prepare_request(request, options)
+        query = {}
+        query.merge!(options.delete(:params)) if options[:params]
+        query.merge!(options.delete(:query)) if options[:query]
+        options.keys.each do |key|
+          next if BaseService::SEND_OPTION_KEYS.include?(key.to_sym)
+
+          query[key] = options.delete(key)
+        end
+        unless query.empty?
+          serialized = Utils.serialize_query_params(query)
+          request[:url] += (request[:url].include?("?") ? "&" : "?") + serialized unless serialized.empty?
+        end
+
+        request[:headers] = options[:headers]
+        request[:json] = {}
+        request[:files] = {}
+
+        body = options[:body] || {}
+        if body.is_a?(MultipartBody)
+          raise ArgumentError, "pass a Hash (not a MultipartBody) as batch sub-request body"
+        end
+
+        body.each do |key, val|
+          key = key.to_s
+          if Multipart.file_value?(val)
+            (request[:files][key] ||= []) << val
+          elsif val.is_a?(Array)
+            files = val.select { |v| Multipart.file_value?(v) }
+            regular = val.reject { |v| Multipart.file_value?(v) }
+            if files.any? && files.length == val.length
+              (request[:files][key] ||= []).concat(files)
+            else
+              request[:json][key] = regular
+              if files.any?
+                file_key = key
+                file_key += "+" unless key.start_with?("+") || key.end_with?("+")
+                (request[:files][file_key] ||= []).concat(files)
+              end
+            end
+          else
+            request[:json][key] = val
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pocketbase/services/collection_service.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PocketBase
+  module Services
+    # Collection management service (port of js-sdk CollectionService).
+    class CollectionService < CrudService
+      def base_crud_path
+        "/api/collections"
+      end
+
+      # Imports the provided collections.
+      # If delete_missing is true, local collections not present in the
+      # imported configuration WILL BE DELETED (including their records)!
+      def import(collections, delete_missing = false, options = {})
+        opts = send_options(
+          { method: "PUT",
+            body: { "collections" => collections, "deleteMissing" => delete_missing } },
+          options
+        )
+        @client.send_request("#{base_crud_path}/import", opts)
+        true
+      end
+
+      # Deletes all records of the given collection. Returns true.
+      def truncate(collection_id_or_name, options = {})
+        opts = send_options({ method: "DELETE" }, options)
+        @client.send_request(
+          "#{base_crud_path}/#{Utils.encode_uri_component(collection_id_or_name.to_s)}/truncate", opts
+        )
+        true
+      end
+
+      # Returns a type-indexed map of scaffolded collection models.
+      def get_scaffolds(options = {})
+        opts = send_options({ method: "GET" }, options)
+        @client.send_request("#{base_crud_path}/meta/scaffolds", opts)
+      end
+
+      # Returns the list of all configurable OAuth2 providers.
+      def get_all_oauth2_providers(options = {})
+        opts = send_options({ method: "GET" }, options)
+        @client.send_request("#{base_crud_path}/meta/oauth2-providers", opts)
+      end
+
+      # Executes a view query and returns a sample of the resulting records.
+      def dry_run_view_query(query, options = {})
+        opts = send_options({ method: "POST", body: { "query" => query } }, options)
+        @client.send_request("#{base_crud_path}/meta/dry-run-view", opts)
+      end
+    end
+  end
+end

data/lib/pocketbase/services/cron_service.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module PocketBase
+  module Services
+    # Cron service (port of js-sdk CronService).
+    class CronService < BaseService
+      # Returns the list of all registered cron jobs.
+      def get_full_list(options = {})
+        opts = send_options({ method: "GET" }, options)
+        @client.send_request("/api/crons", opts)
+      end
+
+      # Runs the specified cron job. Returns true.
+      def run(job_id, options = {})
+        opts = send_options({ method: "POST" }, options)
+        @client.send_request("/api/crons/#{Utils.encode_uri_component(job_id.to_s)}", opts)
+        true
+      end
+    end
+  end
+end

data/lib/pocketbase/services/crud_service.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module PocketBase
+  module Services
+    # Base CRUD service (port of js-sdk CrudService).
+    class CrudService < BaseService
+      # Base path for the crud actions (without trailing slash).
+      def base_crud_path
+        raise NotImplementedError, "subclass must define #base_crud_path"
+      end
+
+      # Response data decoder (identity by default; override in subclasses).
+      def decode(data)
+        data
+      end
+
+      # Returns all list items batch-fetched at once
+      # (1000 items per request by default; change with `batch:`).
+      #
+      #   service.get_full_list(batch: 200, filter: "...")
+      #   service.get_full_list(200, filter: "...")   # legacy positional form
+      def get_full_list(batch = nil, options = {})
+        if batch.is_a?(Hash)
+          options = batch.merge(options)
+          batch = nil
+        end
+        batch_size = batch || options.delete(:batch) || 1000
+        get_full_list_batched(batch_size, options)
+      end
+
+      # Returns a paginated items list.
+      #
+      #   result = service.get_list(1, 30, filter: "...", sort: "-created")
+      #   result["items"] # => Array of decoded items
+      def get_list(page = 1, per_page = 30, options = {})
+        opts = send_options({ method: "GET" }, options)
+        opts[:query] = { "page" => page, "perPage" => per_page }.merge(opts[:query] || {})
+        response = @client.send_request(base_crud_path, opts)
+        response["items"] = (response["items"] || []).map { |item| decode(item) }
+        response
+      end
+
+      # Returns the first item matching the filter (raises 404 when none found).
+      def get_first_list_item(filter, options = {})
+        opts = options.merge(
+          request_key: "one_by_filter_#{base_crud_path}_#{filter}",
+          filter: filter,
+          skipTotal: 1
+        )
+        result = get_list(1, 1, opts)
+        items = result["items"] || []
+        if items.empty?
+          raise ClientResponseError.new(
+            status: 404,
+            response: { "code" => 404, "message" => "The requested resource wasn't found.", "data" => {} }
+          )
+        end
+
+        items[0]
+      end
+
+      # Returns a single item by id (raises 404 when id is empty).
+      def get_one(id, options = {})
+        if id.nil? || id.to_s.empty?
+          raise ClientResponseError.new(
+            url: @client.build_url(base_crud_path + "/"),
+            status: 404,
+            response: { "code" => 404, "message" => "Missing required record id.", "data" => {} }
+          )
+        end
+
+        opts = send_options({ method: "GET" }, options)
+        decode(@client.send_request("#{base_crud_path}/#{Utils.encode_uri_component(id.to_s)}", opts))
+      end
+
+      # Creates a new item. Pass a File/IO value inside body for file uploads.
+      def create(body_params = nil, options = {})
+        opts = send_options({ method: "POST", body: body_params }, options)
+        decode(@client.send_request(base_crud_path, opts))
+      end
+
+      # Updates an existing item by id.
+      def update(id, body_params = nil, options = {})
+        opts = send_options({ method: "PATCH", body: body_params }, options)
+        decode(@client.send_request("#{base_crud_path}/#{Utils.encode_uri_component(id.to_s)}", opts))
+      end
+
+      # Deletes an item by id. Returns true on success.
+      def delete(id, options = {})
+        opts = send_options({ method: "DELETE" }, options)
+        @client.send_request("#{base_crud_path}/#{Utils.encode_uri_component(id.to_s)}", opts)
+        true
+      end
+
+      private
+
+      def get_full_list_batched(batch_size, options)
+        options = (options || {}).merge(skipTotal: 1)
+        result = []
+        page = 1
+        loop do
+          list = get_list(page, batch_size || 1000, options)
+          items = list["items"] || []
+          result.concat(items)
+          break if items.length < list["perPage"].to_i
+
+          page += 1
+        end
+        result
+      end
+    end
+  end
+end

data/lib/pocketbase/services/file_service.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module PocketBase
+  module Services
+    # File service (port of js-sdk FileService).
+    class FileService < BaseService
+      # Builds an absolute record file URL for the given filename.
+      #
+      #   pb.files.get_url(record, "avatar.png", thumb: "100x100", download: true)
+      def get_url(record, filename, query_params = {})
+        record ||= {}
+        collection = record["collectionId"] || record[:collectionId] ||
+                     record["collectionName"] || record[:collectionName]
+        id = record["id"] || record[:id]
+        return "" if filename.nil? || filename.to_s.empty? || id.nil? || collection.nil?
+
+        parts = ["api", "files",
+                 Utils.encode_uri_component(collection.to_s),
+                 Utils.encode_uri_component(id.to_s),
+                 Utils.encode_uri_component(filename.to_s)]
+        result = @client.build_url(parts.join("/"))
+
+        query_params.delete(:download) if query_params[:download] == false
+        query_params.delete("download") if query_params["download"] == false
+
+        params = Utils.serialize_query_params(query_params)
+        result += (result.include?("?") ? "&" : "?") + params unless params.empty?
+        result
+      end
+
+      # Requests a new private file access token for the current auth model.
+      def get_token(options = {})
+        opts = send_options({ method: "POST" }, options)
+        data = @client.send_request("/api/files/token", opts)
+        data["token"] || data[:token] || ""
+      end
+    end
+  end
+end

data/lib/pocketbase/services/health_service.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module PocketBase
+  module Services
+    # Health service (port of js-sdk HealthService).
+    class HealthService < BaseService
+      # Checks the health status of the API.
+      def check(options = {})
+        opts = send_options({ method: "GET" }, options)
+        @client.send_request("/api/health", opts)
+      end
+    end
+  end
+end

data/lib/pocketbase/services/log_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module PocketBase
+  module Services
+    # Logs service (port of js-sdk LogService).
+    class LogService < BaseService
+      # Returns a paginated logs list.
+      def get_list(page = 1, per_page = 30, options = {})
+        opts = send_options({ method: "GET" }, options)
+        opts[:query] = { "page" => page, "perPage" => per_page }.merge(opts[:query] || {})
+        @client.send_request("/api/logs", opts)
+      end
+
+      # Returns a single log by id (raises 404 when id is empty).
+      def get_one(id, options = {})
+        if id.nil? || id.to_s.empty?
+          raise ClientResponseError.new(
+            url: @client.build_url("/api/logs/"),
+            status: 404,
+            response: { "code" => 404, "message" => "Missing required log id.", "data" => {} }
+          )
+        end
+
+        opts = send_options({ method: "GET" }, options)
+        @client.send_request("/api/logs/#{Utils.encode_uri_component(id.to_s)}", opts)
+      end
+
+      # Returns logs statistics.
+      def get_stats(options = {})
+        opts = send_options({ method: "GET" }, options)
+        @client.send_request("/api/logs/stats", opts)
+      end
+
+      # Deletes all logs. Returns true.
+      def truncate(options = {})
+        opts = send_options({ method: "DELETE" }, options)
+        @client.send_request("/api/logs", opts)
+        true
+      end
+    end
+  end
+end