dato-rails 0.7.4 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd0388aa8f2f5230feb9b58e501d0d2b32d9a276eccf4029864061ea4fb42745
-  data.tar.gz: c084383123cfa44fe5834c8eb61e247d8b5482f4ce983bd9f712044e36fe1f5e
+  metadata.gz: efcf217eb4b7350ff1b1a431add8314ce1353c01c9ce2d5ffef606a0d91aa3e9
+  data.tar.gz: 1006e161f158eff58e2449f43ec8392bd1a6812efe07dfe75b6596af1774f932
 SHA512:
-  metadata.gz: 6cde762f15270f855bc106c523e6d428fca9763005b380177852fa990627ccd35445ba6abe8913d76f9899f6c7a30a132a829ef6ac00be2bda9d672faff99299
-  data.tar.gz: e54d6ac310cc81b0c62f65470e4a2c9ab0333e7ff71e9ca652a83f0ee1e3b9699c4889140cf3a6f8aaae421a3785433deb4eed48b01878ff9cfc5973afb7bbbd
+  metadata.gz: 40bf39ed3afb39b32d4f3516c4bd795649b4f79eab307b9d9699e262dd91fef7ffc35ced8cf75a2bcf8c2312766d7ef63a00fe8d58235b1c6f942c441a5e4961
+  data.tar.gz: 574dcb125c6539385851c4f0db6aefae191b8d03f7d5695394c4c92f0a7f6a0d86b581e909474c35a7bb4ba5952a0f86f0fe1103811568fffe65eca0d1705511

data/README.md

@@ -5,6 +5,7 @@ Use [DatoCMS](https://www.datocms.com/) in your Rails application.
 This gem allows you to fetch data using Dato GraphQL APIs and render the content in your Rails app.
 
 👉 See [this simple tutorial to get started on dev.to](https://dev.to/coorasse/datocms-with-ruby-on-rails-3ae5). 👈
+👉 See also [this second tutorial to build a Blog](https://dev.to/coorasse/rails-blog-with-datocms-264j-temp-slug-4336490). 👈
 
 ## Installation
 
@@ -31,7 +32,9 @@ queries to the GraphQL endpoint.
 Look at GQLi documentation for more information about the syntax of queries.
 You can also find some examples in specs of this library.
 
-Set your api token as `DATO_API_TOKEN` environment variable.
+Set your api token as `DATO_API_TOKEN` environment variable or as
+`Rails.application.credentials.dig(:dato, :api_token)`.
+ENV variable will have precedence.
 
 ```ruby
 client = Dato::Client.new # you can also pass the api token here.
@@ -57,7 +60,7 @@ GQLi::DSL.query {
         __typename
         id
         image {
-          responsiveImage(imgixParams: {fm: __enum("png")}) {
+          responsiveImage(imgixParams: { fm: __enum("png") }) {
             ___ Dato::Fragments::ResponsiveImage
           }
         }
@@ -86,7 +89,8 @@ If you have a responsive image, you can render it with:
 render Dato::ResponsiveImage.new(node.image.responsiveImage)
 ```
 
-To define a custom node, you can create a new `Dato::CustomNode` view component in your application and it will be automatically used.
+To define a custom node, you can create a new `Dato::CustomNode` view component in your application and it will be
+automatically used.
 
 You can also customize how each node type is rendered by specifying the mapping on the single render:
 
@@ -106,7 +110,9 @@ Dato::Config.overrides = {
 
 ## Preview and live
 
-The `Dato::Client` supports both [preview](https://www.datocms.com/docs/pro-tips/how-to-manage-a-live-and-a-preview-site) and [live updates](https://www.datocms.com/docs/real-time-updates-api) features from Dato CMS.
+The `Dato::Client` supports
+both [preview](https://www.datocms.com/docs/pro-tips/how-to-manage-a-live-and-a-preview-site)
+and [live updates](https://www.datocms.com/docs/real-time-updates-api) features from Dato CMS.
 
 ```ruby
 Dato::Client.new(preview: true) # to fetch draft versions
@@ -123,13 +129,13 @@ you probably have the following:
 
 ```ruby
 result = Dato::Client.new.execute!(my_query)
-render(MyComponent.new(result))
+render(MyComponent.new(result.data))
 ```
 
-you can now wrap everything in a `Dato::Live` component like this:
+you can now wrap everything in a `Dato::Wrapper` component like this:
 
 ```ruby
-render(Dato::Live.new(MyComponent, my_query, preview: true, live: true))
+render(Dato::Wrapper.new(MyComponent, my_query, preview: true, live: true))
 ```
 
 and your component will come to life with live updates 🎉 (requires turbo).
@@ -170,21 +176,26 @@ Dato::Client.new.items.destroy(item_id: '123')
 
 ## File upload
 
-Dato Rails also supports file uploads. 
-These can be created either from a local file or from a url. 
+Dato Rails also supports file uploads.
+These can be created either from a local file or from a url.
 Basically all file types are supported, as long as they are valid in the CMS.
+Be aware that dato jobs are not synchronous, so you may need to
+implement some kind of polling to check if the upload is finished.
+The create method returns a job id, which can be used to retrieve the upload result.
 
-> In addition to the binary file, also attributes and metadata can be uploaded. 
-Both metadata and attributes are optional.
+> In addition to the binary file, also attributes and metadata can be uploaded.
+> Both metadata and attributes are optional.
 > Provide attributes according to the [docs](https://www.datocms.com/docs/content-management-api/resources/upload)
 
 ### Upload from Url
+
 ```ruby
 Dato::Client.new.uploads.create_from_url('https://picsum.photos/seed/picsum/200/300')
 Dato::Client.new.uploads.create_from_url('https://picsum.photos/seed/picsum/200/300', attributes:)
 ```
 
 ### Upload from Local File
+
 ```ruby
 file = File.open('image.png')
 
@@ -200,10 +211,21 @@ attributes = { author: 'Dato Rails', default_field_metadata: meta }
 ```
 
 ### Optional: Filename
+
 ```ruby
 Dato::Client.new.uploads.create_from_url('https://picsum.photos/seed/picsum/200/300', filename: 'test.png')
 Dato::Client.new.uploads.create_from_file(file.path, filename: 'test.png')
+```
 
+### Getting the upload id
+
+As the file upload is asynchronous, you may need to implement some kind of polling to check if the upload is finished.
+With the retrieve_job_result method you can retrieve the upload id from the job result.
+
+```ruby
+job_id = client.uploads.create_from_file(file.path) # get back a job id
+response = client.uploads.retrieve_job_result(job_id).parse # check the status
+upload_id = response.dig('data', 'attributes', 'payload', 'data', 'id') # if nil, it's not done yet
 ```
 
 ## Configuration
@@ -218,15 +240,17 @@ Dato::Config.configure do |config|
   config.blocks = {} # default: {}
   config.cache = false # default: false
   config.cache_namespace = 'dato-rails' # default: 'dato-rails'
-  config.publish_key = ENV['DATO_PUBLISH_KEY'] # default: ENV['DATO_PUBLISH_KEY']
-  config.build_trigger_id = ENV['DATO_BUILD_TRIGGER_ID'] # default: ENV['DATO_BUILD_TRIGGER_ID']
+  config.api_token = ENV['DATO_PUBLISH_KEY'] # default: ENV.fetch("DATO_API_TOKEN", Rails.application.credentials.dig(:dato, :api_token))
+  config.publish_key = ENV['DATO_PUBLISH_KEY'] # default: ENV.fetch("DATO_PUBLISH_KEY", Rails.application.credentials.dig(:dato, :publish_key))
+  config.build_trigger_id = ENV['DATO_BUILD_TRIGGER_ID'] # default: ENV.fetch("DATO_BUILD_TRIGGER_ID", Rails.application.credentials.dig(:dato, :build_trigger_id))
+  config.mount_path = '/dato' # default: '/dato'
 end
 ```
 
 ## Caching
 
 The library supports caching of the rendered components.
-If you enable caching, the components rendered using `Dato::Live`, will be cached.
+If you enable caching, the components rendered using `Dato::Wrapper`, will be cached.
 
 To enable caching, you need to set the `cache` option in the configuration.
 
@@ -241,66 +265,92 @@ end
 Now a call to
 
 ```ruby
-render(Dato::Live.new(MyComponent, my_query))
+render(Dato::Wrapper.new(MyComponent, my_query))
 ```
 
-will be cached for 1 day. 
+will be cached for 1 day.
 
-This means that for the next 24 hours, the graphQL endpoint will not be invoked and the whole component rendering will also be skipped.
+This means that for the next 24 hours, the graphQL endpoint will not be invoked and the whole component rendering will
+also be skipped.
 
 **We will cache the entire HTML result of the component, not only the graphQL response.**
 
 If you want to expire the cache you have two options:
 
-### manually
+### manual
 
-executing `Rails.cache.clear(namespace: Dato::Config.cache_namespace)`
+executing `Dato::Cache.clear!` or running `bin/rails dato:cache:clear`.
 
 ### publish endpoint
 
 You can take advantage of the publish mechanism of Dato CMS to expire the cache.
-* Mount the `dato-rails` engine in your Rails routes file.
-* Set the `DATO_PUBLISH_KEY` environment variable
+
+* Set the `DATO_PUBLISH_KEY` environment variable or in Rails Credentials.
 * Create a build trigger with a custom webhook on your Dato CMS project setting.
 * Define the Trigger URL as `https://yourapp.com/dato/publish`
 * Set the `DATO_PUBLISH_KEY` as the Authorization header
 * Copy the build trigger id and set it as `DATO_BUILD_TRIGGER_ID` environment variable.
 
+### Caching of graphQL response / Controller helpers
+
+If you are not using ViewComponents or you need to cache a single GraphQL query, you can still do it using the
+`Dato::Cache` helper.
+
+In your controllers you already have a helper method `execute_dato_query`.
+You can use it in your controller action and queries results will be automatically cached if:
+
+* You have `Dato` cache enabled
+* You have Rails cache enabled (check your environment configuration)
+* you are not displaying a preview
+
+```ruby
+response = execute_dato_query(blog_post_query(params[:slug]), preview: params[:preview])
+@data = response.data
+```
+
+by using this helper, subsequent calls towards Dato will be cached.
+
+## Logs instrumentation
+
+In the logs you will see the time taken to fetch the data from Dato CMS.
+For example:
+
+```
+Completed 200 OK in 365ms (Views: 109.5ms | ActiveRecord: 0.7ms (4 queries, 0 cached) | Dato: 254.3ms | GC: 0.0ms)`
+```
+
+this is useful to identify if the bottleneck is in the fetching of the data from Dato CMS.
 
 
 ## Development
 
-After checking out the repo, run `bundle install` to install dependencies. 
+After checking out the repo, run `bundle install` to install dependencies.
 
 You can now clone the dato-rails project
 
 [![Clone DatoCMS project](https://dashboard.datocms.com/clone/button.svg)](https://dashboard.datocms.com/clone?projectId=57262&name=dato-rails
 )
 
-
 You then need to set a `DATO_API_TOKEN=abcd123x` in the `.env` file on the root of your project
-to consume data from your project.
+to consume data from your project. For testing purposes, set `TEST_MODEL_TYPE_ID=1234` in the `.env` file
+with the id of the author model type in your project.
 
-Then, run `bundle exec rspec` to run the tests. 
+Then, run `bundle exec rspec` to run the tests.
 
 You can also run `rails console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. 
-To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, 
-which will create a git tag for the version, push git commits and the created tag, 
+To install this gem onto your local machine, run `bundle exec rake install`.
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`,
+which will create a git tag for the version, push git commits and the created tag,
 and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/renuo/dato-rails. 
-This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to 
-adhere to the [code of conduct](https://github.com/renuo/dato-rails/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/renuo/dato-rails.
+This project is intended to be a safe, welcoming space for collaboration. 
+
+Try to be a decent human being while interacting with other people.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the Dato::Rails project's codebases, issue trackers, chat rooms and mailing lists is 
-expected to follow the [code of conduct](https://github.com/renuo/dato-rails/blob/master/CODE_OF_CONDUCT.md).

data/app/components/dato/base_component.rb

@@ -0,0 +1,9 @@
+module Dato
+  class BaseComponent < ViewComponent::Base
+    attr_reader :data
+
+    def initialize(data)
+      @data = data
+    end
+  end
+end

data/app/components/dato/image_block_record.html.erb

@@ -0,0 +1 @@
+<%= render Dato::ResponsiveImage.new(@node.image.responsiveImage) %>

data/app/components/dato/image_block_record.rb

@@ -0,0 +1,2 @@
+class Dato::ImageBlockRecord < Dato::Node
+end

data/app/components/dato/link.rb

@@ -12,7 +12,7 @@ class Dato::Link < Dato::DastNode
   def link_attributes
     attr = {
       "href" => @node.url,
-      "class" => "dato-cms-#{@node.type}",
+      "class" => "dato-cms-#{@node.type}"
     }
     %w[rel target].each { |type| attr[type] = extract_meta(type) }
     attr

data/app/components/dato/live_stream.html.erb

@@ -0,0 +1,26 @@
+<script type="text/javascript">
+  const eventSourceUrl = '<%= data.url %>';
+  const componentKlass = '<%= component_klass %>';
+  const frameId = '<%= frame_id %>';
+  const path = '<%= Dato::Engine.routes.url_helpers.live_path %>';
+  const eventSource = new EventSource(eventSourceUrl);
+  const csrfToken = document.querySelector('meta[name="csrf-token"]').content
+  eventSource.addEventListener("update", (event) => {
+    fetch(path, {
+      method: "POST",
+      headers: {
+        'X-CSRF-Token': csrfToken,
+        'Content-Type': 'application/json',
+        "Accept": "text/vnd.turbo-stream.html"
+      },
+      body: JSON.stringify({
+        component: componentKlass,
+        data: event.data,
+        frame_id: frameId
+      })
+    }).then(response => response.text())
+      .then(html => Turbo.renderStreamMessage(html));
+  });
+</script>
+
+<div id=<%= frame_id %>></div>

data/app/components/dato/live_stream.rb

@@ -0,0 +1,35 @@
+# This component can bring to life your dato components allowing previews and live updates.
+# Given that you have a ViewComponent "MyComponent" that renders your page, you can render your page with:
+# render(MyComponent.new(data_result_from_dato_query))
+# you can now use this wrapper component to do:
+# render(Dato::LiveStream.new(MyComponent, query, preview: true)
+module Dato
+  class LiveStream < ViewComponent::Base
+    delegate :turbo_frame_tag, to: :helpers
+
+    attr_reader :component_klass, :query, :preview
+
+    def initialize(component_klass, query, preview: false)
+      super()
+      @component_klass = component_klass
+      @query = query
+      @preview = preview
+    end
+
+    def data
+      @data ||= dato_fetch(query, preview: preview)
+    end
+
+    def frame_id
+      @frame_id ||= SecureRandom.hex(10)
+    end
+
+    private
+
+    def dato_fetch(query, preview: false)
+      client = Dato::Client.new(preview: preview, live: true)
+      response = client.live!(query)
+      response.data
+    end
+  end
+end

data/app/components/dato/node.rb

@@ -28,7 +28,7 @@ module Dato
     private
 
     def class_for_block(block)
-      class_name = (overrides[block.__typename] || Dato::Config.overrides[block.__typename])
+      class_name = overrides[block.__typename] || Dato::Config.overrides[block.__typename]
       if class_name.is_a?(String)
         class_name = class_name.constantize
       end
@@ -40,7 +40,7 @@ module Dato
     end
 
     def class_for_node(node)
-      class_name = (overrides[node.type] || Dato::Config.overrides[node.type])
+      class_name = overrides[node.type] || Dato::Config.overrides[node.type]
       if class_name.is_a?(String)
         class_name = class_name.constantize
       end

data/app/components/dato/responsive_image.html.erb

@@ -4,7 +4,7 @@
     <picture style="position: absolute; left: 0; top: 0; width: 100%">
       <source srcset="<%= @node.webpSrcSet %>" type="image/webp">
       <source srcset="<%= @node.srcSet %>">
-      <img src="<%= @node.src %>" alt="<%= @node.alt %>" title="<%= @node.title %>" loading="lazy" width="100%">
+      <img src="<%= @node.src %>" alt="<%= @node.alt %>" title="<%= @node.title %>" loading="lazy" width="100%"  class="<%= @custom_img_css_classes %>">
     </picture>
   </div>
 </div>

data/app/components/dato/responsive_image.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 class Dato::ResponsiveImage < Dato::Node
-  def initialize(node, root = nil, custom_css_classes: [])
+  def initialize(node, root = nil, custom_css_classes: [], custom_img_css_classes: [])
     super(node, root)
-    @custom_css_classes = custom_css_classes
+    @custom_css_classes = custom_css_classes.is_a?(Array) ? custom_css_classes.join(" ") : custom_css_classes
+    @custom_img_css_classes = custom_img_css_classes.is_a?(Array) ? custom_img_css_classes.join(" ") : custom_img_css_classes
   end
 end

data/app/components/dato/wrapper.html.erb

@@ -0,0 +1,32 @@
+<% if live? %>
+  <script type="text/javascript">
+      const eventSourceUrl = '<%= data.url %>';
+      const componentKlass = '<%= component_klass %>';
+      const frameId = '<%= frame_id %>';
+      const path = '<%= Dato::Engine.routes.url_helpers.live_path %>';
+      const eventSource = new EventSource(eventSourceUrl);
+      const csrfToken = document.querySelector('meta[name="csrf-token"]').content
+      eventSource.addEventListener("update", (event) => {
+          fetch(path, {
+              method: "POST",
+              headers: {
+                  'X-CSRF-Token': csrfToken,
+                  'Content-Type': 'application/json',
+                  "Accept": "text/vnd.turbo-stream.html"
+              },
+              body: JSON.stringify({
+                  component: componentKlass,
+                  data: event.data,
+                  frame_id: frameId
+              })
+          }).then(response => response.text())
+              .then(html => Turbo.renderStreamMessage(html));
+      });
+  </script>
+
+  <div id=<%= frame_id %>></div>
+<% else %>
+  <%= Dato::Cache.fetch(cache_key) do %>
+    <% render(component_klass.new(data)) %>
+  <% end %>
+<% end %>

data/app/components/dato/wrapper.rb

@@ -0,0 +1,38 @@
+module Dato
+  class Wrapper < ViewComponent::Base
+    attr_reader :component_klass, :query, :preview, :live
+
+    def initialize(component_klass, query, preview: false, live: false)
+      @component_klass = component_klass
+      @query = query
+      @preview = preview
+      @live = live
+    end
+
+    def live? = @live
+
+    def render_in(view_context)
+      if live?
+        LiveStream.new(component_klass, query, preview: preview).render_in(view_context)
+      else
+        super
+      end
+    end
+
+    def data
+      @data ||= dato_fetch(query, preview: preview)
+    end
+
+    def cache_key
+      @cache_key ||= Digest::MD5.hexdigest(query.to_gql)
+    end
+
+    private
+
+    def dato_fetch(query, preview: false)
+      client = Dato::Client.new(preview: preview)
+      response = client.execute!(query)
+      response.data
+    end
+  end
+end

data/app/controllers/dato/live_controller.rb

@@ -1,6 +1,6 @@
 module Dato
   class LiveController < ActionController::Base
-    def show
+    def create
       @data = Hashie::Mash.new(JSON.parse(params[:data], symbolize_names: true).dig(:response, :data))
     end
   end

data/app/controllers/dato/publish_controller.rb

@@ -7,7 +7,7 @@ module Dato
     before_action :check, only: :create
 
     def create
-      Rails.cache.clear(namespace: Dato::Config.cache_namespace)
+      Dato::Cache.clear!
 
       notify_success
 

data/app/views/dato/live/create.turbo_stream.erb

@@ -0,0 +1,7 @@
+<turbo-stream target="<%= params[:frame_id] %>" action="replace" method="morph">
+  <template>
+    <div id=<%= params[:frame_id] %>>
+      <%= render params[:component].constantize.new(@data) %>
+    </div>
+  </template>
+</turbo-stream>

data/config/routes.rb

@@ -1,4 +1,4 @@
 Dato::Engine.routes.draw do
-  get "live", to: "live#show"
+  post "live", to: "live#create"
   post "publish", to: "publish#create"
 end

data/lib/dato/cache.rb

@@ -21,5 +21,9 @@ module Dato
     def self.namespace
       Dato::Config.cache_namespace
     end
+
+    def self.clear!
+      Rails.cache.clear(namespace: namespace)
+    end
   end
 end

data/lib/dato/client.rb

@@ -1,6 +1,6 @@
 module Dato
   class Client
-    delegate :live!, :execute!, :execute, to: :@gql
+    delegate :live!, to: :@gql
     attr_reader :items, :uploads, :gql
 
     def initialize(api_token = Dato::Config.api_token, validate_query: false, preview: false, live: false)
@@ -9,5 +9,15 @@ module Dato
       @items = Dato::Items.new(api_token)
       @uploads = Dato::Uploads.new(api_token)
     end
+
+    def execute!(query)
+      ActiveSupport::Notifications.instrument("dato.query_execution") do
+        @gql.execute!(query)
+      end
+    end
+
+    def execute(query)
+      @gql.execute(query)
+    end
   end
 end

data/lib/dato/config.rb

@@ -6,8 +6,9 @@ module Dato
     config_accessor(:blocks) { {} }
     config_accessor(:cache) { false }
     config_accessor(:cache_namespace) { "dato-rails" }
-    config_accessor(:api_token) { ENV["DATO_API_TOKEN"] }
-    config_accessor(:publish_key) { ENV["DATO_PUBLISH_KEY"] }
-    config_accessor(:build_trigger_id) { ENV["DATO_BUILD_TRIGGER_ID"] }
+    config_accessor(:api_token) { ENV.fetch("DATO_API_TOKEN", Rails.application.credentials.dig(:dato, :api_token)) }
+    config_accessor(:publish_key) { ENV.fetch("DATO_PUBLISH_KEY", Rails.application.credentials.dig(:dato, :publish_key)) }
+    config_accessor(:build_trigger_id) { ENV.fetch("DATO_BUILD_TRIGGER_ID", Rails.application.credentials.dig(:dato, :build_trigger_id)) }
+    config_accessor(:mount_path) { "/dato" }
   end
 end

data/lib/dato/current_request.rb

@@ -0,0 +1,5 @@
+module Dato
+  class CurrentRequest < ActiveSupport::CurrentAttributes
+    attribute :dato_runtime
+  end
+end

data/lib/dato/engine.rb

@@ -1,5 +1,24 @@
 module Dato
   class Engine < ::Rails::Engine
     isolate_namespace Dato
+
+    initializer "dato_rails.action_controller" do
+      ActiveSupport.on_load(:action_controller) do
+        include Dato::Railties::ControllerRuntime
+      end
+
+      ActiveSupport::Notifications.subscribe("dato.query_execution") do |_, start, finish, _, _payload|
+        Dato::CurrentRequest.dato_runtime ||= 0
+        Dato::CurrentRequest.dato_runtime += (finish - start) * 1000
+      end
+    end
+
+    initializer "dato_rails.configuration" do |app|
+      if Dato::Config.mount_path
+        app.routes.append do
+          mount Dato::Engine => Dato::Config.mount_path
+        end
+      end
+    end
   end
 end

data/lib/dato/fragments/meta_tags.rb

@@ -0,0 +1,5 @@
+Dato::Fragments::MetaTags = GQLi::DSL.fragment("metaTagsFragment", "Tag") {
+  attributes
+  content
+  tag
+}

data/lib/dato/railties/controller_runtime.rb

@@ -0,0 +1,28 @@
+module Dato
+  module Railties
+    module ControllerRuntime
+      extend ActiveSupport::Concern
+
+      def execute_dato_query(query, preview: false)
+        client = Dato::Client.new(preview: preview)
+        if preview
+          return client.execute!(query)
+        end
+
+        key = "#{Digest::MD5.hexdigest(query.to_gql)}-query-#{preview}"
+        Dato::Cache.fetch(key) do
+          client.execute!(query)
+        end
+      end
+
+      module ClassMethods # :nodoc:
+        def log_process_action(payload)
+          messages = super
+          Dato::CurrentRequest.dato_runtime ||= 0
+          messages << ("Dato: %.1fms" % Dato::CurrentRequest.dato_runtime)
+          messages
+        end
+      end
+    end
+  end
+end

data/lib/dato/uploads.rb

@@ -30,10 +30,7 @@ module Dato
 
       upload_file_to_bucket(url: upload_url, path: path_to_file)
 
-      job_id = upload_file_to_dato(upload_id:, attributes:)
-      upload_id = retrieve_job_result(job_id).parse["data"]["attributes"]["payload"]["data"]["id"]
-
-      {upload_id:}
+      upload_file_to_dato(upload_id:, attributes:)
     end
 
     def retrieve_job_result(job_id)

data/lib/dato/version.rb

@@ -1,3 +1,3 @@
 module Dato
-  VERSION = "0.7.4"
+  VERSION = "0.9.0"
 end

data/lib/tasks/dato/rails_tasks.rake

@@ -1,4 +1,7 @@
-# desc "Explaining what the task does"
-# task :dato_rails do
-#   # Task goes here
-# end
+namespace :dato do
+  namespace :cache do
+    task clear: :environment do
+      Dato::Cache.clear!
+    end
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dato-rails
 version: !ruby/object:Gem::Version
-  version: 0.7.4
+  version: 0.9.0
 platform: ruby
 authors:
 - Alessandro Rodi
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-16 00:00:00.000000000 Z
+date: 2025-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-rails
@@ -114,14 +113,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: turbo-rails
   requirement: !ruby/object:Gem::Requirement
@@ -175,6 +174,7 @@ files:
 - README.md
 - Rakefile
 - app/assets/config/dato_rails_manifest.js
+- app/components/dato/base_component.rb
 - app/components/dato/block.html.erb
 - app/components/dato/block.rb
 - app/components/dato/blockquote.html.erb
@@ -184,12 +184,14 @@ files:
 - app/components/dato/dast_node.html.erb
 - app/components/dato/dast_node.rb
 - app/components/dato/heading.rb
+- app/components/dato/image_block_record.html.erb
+- app/components/dato/image_block_record.rb
 - app/components/dato/link.html.erb
 - app/components/dato/link.rb
 - app/components/dato/list.rb
 - app/components/dato/list_item.rb
-- app/components/dato/live.html.erb
-- app/components/dato/live.rb
+- app/components/dato/live_stream.html.erb
+- app/components/dato/live_stream.rb
 - app/components/dato/node.rb
 - app/components/dato/not_rendered.rb
 - app/components/dato/paragraph.rb
@@ -204,18 +206,23 @@ files:
 - app/components/dato/unknown_block.rb
 - app/components/dato/unknown_node.html.erb
 - app/components/dato/unknown_node.rb
+- app/components/dato/wrapper.html.erb
+- app/components/dato/wrapper.rb
 - app/controllers/dato/live_controller.rb
 - app/controllers/dato/publish_controller.rb
-- app/views/dato/live/show.html.erb
+- app/views/dato/live/create.turbo_stream.erb
 - config/routes.rb
 - lib/dato.rb
 - lib/dato/cache.rb
 - lib/dato/client.rb
 - lib/dato/config.rb
+- lib/dato/current_request.rb
 - lib/dato/engine.rb
+- lib/dato/fragments/meta_tags.rb
 - lib/dato/fragments/responsive_image.rb
 - lib/dato/gql.rb
 - lib/dato/items.rb
+- lib/dato/railties/controller_runtime.rb
 - lib/dato/uploads.rb
 - lib/dato/version.rb
 - lib/tasks/dato/rails_tasks.rake
@@ -225,7 +232,6 @@ metadata:
   homepage_uri: https://github.com/renuo/dato-rails
   source_code_uri: https://github.com/renuo/dato-rails
   changelog_uri: https://github.com/renuo/dato-rails/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -240,8 +246,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Use Dato CMS in your Rails application.
 test_files: []

data/app/components/dato/live.html.erb

@@ -1,22 +0,0 @@
-<% if live %>
-  <script type="text/javascript">
-    const eventSourceUrl = '<%=data.url %>';
-    const componentKlass = '<%=component_klass%>';
-    const frameId = '<%=frame_id%>';
-    const eventSource = new EventSource(eventSourceUrl);
-    eventSource.addEventListener("update", (event) => {
-      const params = new URLSearchParams({
-        component: componentKlass,
-        data: event.data,
-        frame_id: frameId
-      });
-      document.getElementById(frameId).src = `/dato/live?${params.toString()}`;
-    });
-  </script>
-
-  <%= turbo_frame_tag frame_id %>
-<% else %>
-  <%= Dato::Cache.fetch(cache_key) do %>
-    <% render(component_klass.new(data)) %>
-  <% end %>
-<% end %>

data/app/components/dato/live.rb

@@ -1,40 +0,0 @@
-# This component can bring to life your dato components allowing peviews and live updates.
-# Given that you have a component MyComponent that renders your page, you can would render your page with:
-# render(MyComponent.new(@data_result_from_dato_query))
-# you can now use this wrapper component to do:
-# render(Dato::Live.new(MyComponent, query, preview: true, live: true)
-module Dato
-  class Live < ViewComponent::Base
-    delegate :turbo_frame_tag, to: :helpers
-
-    attr_reader :component_klass, :query, :preview, :live
-
-    def initialize(component_klass, query, preview: false, live: false)
-      super()
-      @component_klass = component_klass
-      @query = query
-      @preview = preview
-      @live = live
-    end
-
-    def cache_key
-      @cache_key ||= Digest::MD5.hexdigest(query.to_gql)
-    end
-
-    def data
-      @data ||= dato_fetch(query, preview: preview, live: live)
-    end
-
-    def frame_id
-      @frame_id ||= SecureRandom.hex(10)
-    end
-
-    private
-
-    def dato_fetch(query, preview: false, live: false)
-      client = Dato::Client.new(preview: preview, live: live)
-      response = live ? client.live!(query) : client.execute!(query)
-      response.data
-    end
-  end
-end

data/app/views/dato/live/show.html.erb

@@ -1,3 +0,0 @@
-<%= turbo_frame_tag params[:frame_id] do %>
-  <%= render params[:component].constantize.new(@data) %>
-<% end %>