grist-grist 0.1.1

data/lib/grist/type/access.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Grist
+  module Type
+    # Defines a Grist Organization
+    class Access < Grist::Type::Base
+      PATH = "/access"
+      KEYS = %w[
+        id
+        email
+        name
+        picture
+        ref
+        access
+        isMember
+      ].freeze
+
+      attr_accessor(*KEYS)
+
+      # List all organizations
+      # @return [Array] Array of organizations
+      def self.all
+        grist_res = new.list
+        return [] unless grist_res&.data.is_a?(Array)
+
+        grist_res.data&.map { |org| Organization.new(org) }
+      end
+
+      # Finds an organization by ID
+      # @param id [Integer] The ID of the organization to find
+      # return [self | nil] The organization or nil if not found
+      def self.find(id)
+        grist_res = new.get(id)
+        return unless grist_res.success? && grist_res.data
+
+        new(grist_res.data)
+      end
+
+      # Updates the organization
+      # @param id [Integer] The ID of the organization to delete
+      # @param data [Hash] The data to update the organization with
+      # @return [self | nil] The updated organization or nil if not found
+      def self.update(id, data)
+        org = find(id)
+        return unless org
+
+        org.update(data)
+      end
+
+      # Deletes the organization
+      # @param id [Integer] The ID of the organization to delete
+      # @return [self | nil] The deleted organization or nil if not found
+      def self.delete(id)
+        org = find(id)
+        return unless org
+
+        org.delete
+      end
+
+      def self.access(id)
+        org = find(id)
+        grist_res = org.access
+        return unless grist_res.success? && grist_res.data
+
+        grist_res.data
+      end
+    end
+  end
+end

data/lib/grist/type/base.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Grist
+  module Type
+    class Base
+      include Rest
+      include Accessible
+      include Searchable
+
+      PATH = ""
+      KEYS = %w[].freeze
+      attr_accessor(*KEYS)
+
+      def initialize(params = {})
+        keys.each do |key|
+          instance_variable_set("@#{key}", params[key])
+        end
+        @deleted = params.delete(:deleted) || false
+      end
+
+      def keys
+        self.class::KEYS
+      end
+
+      def deleted?
+        !!@deleted
+      end
+
+      # List all items
+      # @return [Array] Array of items
+      def self.all
+        grist_res = new.list
+
+        return [] unless grist_res&.data.is_a?(Array)
+        return [] unless grist_res&.data&.any?
+
+        grist_res.data.map { |org| new(org) }
+      end
+
+      # Finds an item by ID
+      # @param id [Integer] The ID of the item to find
+      # return [Grist::Type::Base, nil] The item or nil if not found
+      def self.find(id)
+        grist_res = new.get(id)
+        return unless grist_res.success? && grist_res.data
+
+        new(grist_res.data)
+      end
+
+      # Updates the item
+      # @param id [Integer] The ID of the item to delete
+      # @param data [Hash] The data to update the item with
+      # @return [Grist::Type::Base, nil] The updated item or nil if not found
+      def self.update(id, data)
+        org = find(id)
+        return unless org
+
+        org.update(data)
+      end
+
+      # Deletes the item
+      # @param id [Integer] The ID of the item to delete
+      # @return [Grist::Type::Base, nil] The deleted item or nil if not found
+      def self.delete(id)
+        org = find(id)
+        return unless org
+
+        org.delete
+      end
+    end
+  end
+end

data/lib/grist/type/column.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Grist
+  module Type
+    # Defines a Grist Workspace
+    class Column
+      include Rest
+
+      PATH = "/docs"
+      KEYS = %w[
+        id
+        fields
+      ].freeze
+
+      attr_accessor(*KEYS)
+
+      def initialize(params = {})
+        @doc_id = params[:doc_id]
+        KEYS.each do |key|
+          instance_variable_set("@#{key}", params[key])
+        end
+      end
+    end
+  end
+end

data/lib/grist/type/doc.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Grist
+  module Type
+    # Defines a Grist Workspace
+    class Doc < Grist::Type::Base
+      PATH = "/docs"
+      KEYS = %w[
+        name
+        createdAt
+        updatedAt
+        id
+        isPinned
+        urlId
+        trunkId
+        type
+        forks
+        access
+      ].freeze
+
+      attr_accessor(*KEYS)
+
+      def initialize(params = {})
+        super params
+        @ws_id = params[:ws_id]
+        @tables = []
+      end
+
+      def tables_path
+        "#{path}/#{@id}/tables"
+      end
+
+      def tables
+        grist_res = request(:get, tables_path)
+        return [] if grist_res&.error?
+
+        @tables = grist_res.data["tables"]&.map do |t|
+          Table.new(t.merge(doc_id: @id, ws_id: @ws_id))
+        end
+      end
+
+      def create_tables(data)
+        grist_res = request(:post, tables_path, data)
+
+        return [] unless grist_res&.data.is_a?(Array)
+
+        tables
+      end
+
+      def update_table(data)
+        grist_res = request(:patch, tables_path, data)
+
+        return [] unless grist_res&.data.is_a?(Array)
+
+        tables
+      end
+
+      # def base_api_url
+      #   "#{ENV["GRIST_API_URL"]}/api/orgs/#{@org_id}"
+      # end
+
+      # Updates the workspace
+      # # @param id [Integer] The ID of the workspace to delete
+      # # # @param data [Hash] The data to update the workspace with
+      # # @return [self | nil] The updated workspace or nil if not found
+      def self.create(ws_id, data)
+        obj = new(ws_id: ws_id)
+        obj.create(data)
+      end
+
+      # List all workspaces
+      # # # @return [Array] Array of workspaces
+      def self.all(org_id)
+        grist_res = new(org_id: org_id).list
+        return [] unless grist_res&.data.is_a?(Array)
+
+        grist_res.data&.map { |org| Workspace.new(org) }
+      end
+
+      # Finds an workspace by ID
+      # # @param id [Integer] The ID of the workspace to find
+      # # # return [self | nil] The workspace or nil if not found
+      def self.find(id)
+        grist_res = new.get(id)
+        puts grist_res.inspect
+        return unless grist_res.success? && grist_res.data
+
+        new(grist_res.data)
+      end
+
+      def self.tables(doc_id)
+        org = find(doc_id)
+        return unless org
+
+        org.tables
+      end
+    end
+  end
+end

data/lib/grist/type/organization.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Grist
+  module Type
+    # Defines a Grist Organization
+    class Organization < Grist::Type::Base
+      PATH = "/orgs"
+      KEYS = %w[
+        id
+        name
+        createdAt
+        updatedAt
+        domain
+        host
+        owner
+      ].freeze
+
+      attr_accessor(*KEYS)
+      attr_reader :workspaces
+
+      # Initialize a new Organization
+      # @param params [Hash] The parameters to initialize the organization with
+      # @return [Grist::Type::Organization] The organization
+      # @note API: https://support.getgrist.com/api/#tag/organizations
+      # @example
+      #  org = Grist::Type::Organization.new(
+      #  "id" => 1,
+      #  "name" => "Grist Labs",
+      #  "domain" => "gristlabs",
+      #  "host" => "gristlabs.com",
+      # )
+      def initialize(params = {})
+        super params
+        @workspaces = []
+      end
+
+      # List Workspaces in the organization
+      # @return [Array] The array of Grist::Type::Workspace
+      # @note API: https://support.getgrist.com/api/#tag/workspaces
+      def workspaces
+        grist_res = request(:get, workspaces_path)
+
+        return [] unless grist_res.success? && grist_res.data
+
+        @workspaces = grist_res.data.map do |workspace|
+          Workspace.new(workspace)
+        end
+      end
+
+      # Create a new Workspace in the organization
+      # @param data [Hash] The data to create the workspace with
+      # @return [Decidim::Type::Workspace, nil] The organization or nil if not found
+      def create_workspace(data)
+        grist_res = request(:post, workspaces_path, data)
+
+        unless grist_res.success?
+          grist_res.print_error
+          return
+        end
+
+        data["id"] = grist_res.data
+        data.transform_keys!(&:to_s)
+
+        ws = Workspace.new(data)
+        @workspaces << ws
+
+        ws
+      end
+
+      # Get the path for the organization
+      # @return [String] The path for the organization
+      def workspaces_path
+        "#{path}/#{@id}/workspaces"
+      end
+
+      # Get users which can access to the organization
+      # @param id [Integer] The ID of the organization
+      # @return [Array, nil] An array of Grist::Type::Access or nil
+      def self.access(id)
+        org = find(id)
+        grist_res = org.access
+        return unless grist_res.success? && grist_res.data
+
+        grist_res.data["users"].map do |access|
+          Access.new(access)
+        end
+      end
+
+      # List workspaces in the organization
+      # @param id [Integer] The ID of the organization
+      # @return [Array] An array of Grist::Type::Workspace
+      def self.list_workspaces(id)
+        org = find(id)
+        return [] unless org
+
+        org.workspaces
+      end
+
+      # Create a new workspace in the organization
+      # @param org_id [Integer] The ID of the organization
+      # @param data [Hash] The data to create the workspace with
+      # @return [Grist::Type::Workspace, nil] The created workspace or nil if not found
+      def self.create_workspace(org_id, data)
+        org = find(org_id)
+        return unless org
+
+        org.create_workspace(data)
+      end
+    end
+  end
+end

data/lib/grist/type/record.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Grist
+  module Type
+    # Defines a Grist Workspace
+    class Record < Grist::Type::Base
+      PATH = "/records"
+      KEYS = %w[
+        id
+        fields
+      ].freeze
+
+      attr_accessor(*KEYS)
+
+      def initialize(params = {})
+        super params
+        @table_id = params[:table_id]
+        @doc_id = params[:doc_id]
+      end
+    end
+  end
+end

data/lib/grist/type/table.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Grist
+  module Type
+    # Defines a Grist Workspace
+    class Table < Grist::Type::Base
+      KEYS = %w[
+        id
+        fields
+        columns
+      ].freeze
+
+      attr_accessor(*KEYS)
+
+      def initialize(params = {})
+        @doc_id = params[:doc_id]
+        super params
+      end
+
+      def to_hash
+        {
+          "id" => @id,
+          "fields" => @fields,
+          "columns" => @columns
+        }
+      end
+
+      def columns_path
+        "/docs/#{@doc_id}/tables/#{@id}/columns"
+      end
+
+      def columns
+        grist_res = request(:get, columns_path)
+        return [] unless grist_res.success? && grist_res.data
+
+        grist_res.data.map do |column|
+          Column.new(column)
+        end
+      end
+
+      def records_path
+        "/docs/#{@doc_id}/tables/#{@id}/records"
+      end
+
+      def records(params = {})
+        grist_res = request(:get, records_path, params)
+
+        return [] unless grist_res.success? && grist_res.data
+
+        @records = grist_res.data["records"].map do |record|
+          Record.new(record.merge(doc_id: @doc_id, table_id: @id))
+        end
+
+        @records
+      end
+
+      def create_records(data)
+        grist_res = request(:post, records_path, data)
+        return [] unless grist_res.success? && grist_res.data
+
+        @records = grist_res.data["records"].map do |record|
+          Record.new(record.merge(doc_id: @doc_id, table_id: @id))
+        end
+
+        @records
+      end
+
+      # def base_api_url
+      #   "#{ENV["GRIST_API_URL"]}/api/orgs/#{@org_id}"
+      # end
+
+      # Updates the workspace
+      # # @param id [Integer] The ID of the workspace to delete
+      # # # @param data [Hash] The data to update the workspace with
+      # # @return [self | nil] The updated workspace or nil if not found
+      def self.create(doc_id, data)
+        obj = new(doc_id: doc_id)
+        obj.create(data)
+      end
+
+      # List all workspaces
+      # # # @return [Array] Array of workspaces
+      def self.all(org_id)
+        grist_res = new(org_id: org_id).list
+        return [] unless grist_res&.data.is_a?(Array)
+
+        grist_res.data&.map { |org| Workspace.new(org) }
+      end
+
+      # Finds an workspace by ID
+      # # @param id [Integer] The ID of the workspace to find
+      # # # return [self | nil] The workspace or nil if not found
+      def self.find(id)
+        grist_res = new.get(id)
+        return unless grist_res.success? && grist_res.data
+
+        new(grist_res.data)
+      end
+
+      # Updates the workspace
+      # # @param id [Integer] The ID of the workspace to delete
+      # # # @param data [Hash] The data to update the workspace with
+      # # @return [self | nil] The updated workspace or nil if not found
+      def self.update(id, data)
+        org = find(id)
+        return unless org
+
+        org.update(data)
+      end
+
+      # Deletes the workspace
+      # # @param id [Integer] The ID of the workspace to delete
+      # # @return [self | nil] The deleted workspace or nil if not found
+      def self.delete(id)
+        org = find(id)
+        return unless org
+
+        org.delete
+      end
+
+      def self.access(id)
+        org = find(id)
+        grist_res = org.access
+        return unless grist_res.success? && grist_res.data
+
+        grist_res.data["users"].map do |access|
+          Access.new(access)
+        end
+      end
+    end
+  end
+end

data/lib/grist/type/workspace.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Grist
+  module Type
+    # Defines a Grist Workspace
+    class Workspace < Grist::Type::Base
+      PATH = "/workspaces"
+      KEYS = %w[
+        id
+        name
+        createdAt
+        updatedAt
+        isSupportWorkspace
+        docs
+        access
+        owner
+        orgDomain
+      ].freeze
+
+      attr_accessor(*KEYS)
+      attr_reader :org_id
+
+      def initialize(params = {})
+        @org_id = params[:org_id]
+        @docs = []
+        super params
+      end
+
+      def docs
+        return @docs if @docs&.any? && @docs.first.is_a?(Doc)
+
+        if @docs.any? && @docs.first.is_a?(Hash)
+          @docs = @docs.map do |doc|
+            Doc.new(doc.merge(ws_id: @id))
+          end
+        end
+
+        @docs
+      end
+
+      # Create a new Doc in the workspace
+      # @param data [Hash] The data to create the doc with
+      # @return [Grist::Type::Doc, nil] The created doc or nil if not found
+      def create_doc(data)
+        grist_res = request(:post, doc_path, data)
+
+        return unless grist_res.success?
+
+        data["id"] = grist_res.data
+        data.transform_keys!(&:to_s)
+        doc = Doc.new(data)
+        @docs ||= []
+        @docs << doc
+
+        doc
+      end
+
+      # Creates the workspace
+      # @param id [Integer] The ID of the workspace to create
+      # @param data [Hash] The data to create the workspace with
+      # @return [Grist::Type::Workspace, nil] The created workspace or nil if not found
+      def self.create(org_id, data)
+        org = Type::Organization.find(org_id)
+        org.create_workspace(data)
+      end
+
+      # List all workspaces
+      # @param org_id [Integer] The ID of the organization to list workspaces for
+      # @return [Array] Array of workspaces
+      def self.all(org_id)
+        grist_res = new(org_id: org_id).list
+
+        return [] unless grist_res&.data.is_a?(Array)
+        return [] unless grist_res&.data&.any?
+
+        grist_res.data.map { |org| Workspace.new(org) }
+      end
+
+      private
+
+      # @note Method to create a new doc in workspace
+      # @note API: https://support.getgrist.com/api/#tag/docs/operation/createDoc
+      def doc_path
+        "/workspaces/#{@id}/docs"
+      end
+    end
+  end
+end

data/lib/grist/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Grist
+  module Ruby
+    VERSION = "0.1.1"
+  end
+end

data/lib/grist.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "logger"
+require "json"
+require_relative "grist/version"
+require_relative "grist/rest"
+require_relative "grist/accessible"
+require_relative "grist/searchable"
+require_relative "grist/type/base"
+require_relative "grist/type/table"
+require_relative "grist/type/record"
+require_relative "grist/type/doc"
+require_relative "grist/type/access"
+require_relative "grist/type/workspace"
+require_relative "grist/type/organization"
+require_relative "grist/response"
+
+module Grist
+  class Error < StandardError
+    def self.help; end
+  end
+
+  class NetworkError < Error; end
+  class APIError < Error; end
+
+  class InvalidApiKey < APIError
+    def self.help
+      "help: Ensure the GRIST_API_KEY environment variable is set and valid."
+    end
+  end
+
+  class NotFound < APIError; end
+
+  def self.logger
+    @logger ||= Logger.new($stdout)
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  def self.api_key
+    ENV["GRIST_API_KEY"]
+  end
+
+  def self.token_auth
+    "Bearer #{Grist.api_key}"
+  end
+
+  def self.base_api_url
+    base_api_url = ENV["GRIST_API_URL"]
+    return base_api_url[0..-2] if !base_api_url.nil? && base_api_url != "" && base_api_url.end_with?("/")
+
+    base_api_url
+  end
+
+  def self.localhost?
+    base_api_url.include?("http://localhost")
+  end
+end