seam 1.1.3 → 2.0.0a2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 00d1bdc3f04b6886794f6d9b8947ed665f36841e
-  data.tar.gz: c75f378c4ed3a3baf11f68e5b121ff9065fc42b1
+SHA256:
+  metadata.gz: 3bb7a5a7828d18d2b54017d76ed325d0e7e25c482de942eca0330da40f7e1105
+  data.tar.gz: 8a86ca467008bb6f8d2b76394f9f773a938f072a384a29dc78dc16e430917bb3
 SHA512:
-  metadata.gz: 2ddef0ab3b75439ee35ed29d1f59b98cfa8f1d61662c91bcd075481640e6b0d7ef0bcff566ee2f373f2964598633c7f552015b711cec69e4fde100c0bf408bc6
-  data.tar.gz: b1c82553a5849831d45b2876ebe9e68a7e74b938c3efdd6be6e9a8e1f971e86154b00fc6a7b077615715f253cd17c5c2a6651a3b3311310e8d4200e4ee13b32c
+  metadata.gz: 138e121c4bc2482ca27d3a74df486effb52d749de8e1af57fa95ec20600c109e7b2779794e2724fbe8436192ce3a40481e693857ca19b99a320ca96fe4623fe6
+  data.tar.gz: 4ae84ca5a842777f890f5df0cbff9252fa22d9658f7d03422abcb992a1412e1a272a538019c0f436290bb0064dea0344292690a919a4aa305ec7b3d84e96a30b

data/Gemfile

@@ -1,4 +1,6 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
 
-# Specify your gem's dependencies in seam.gemspec
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in seam.gemspec.
 gemspec

data/Gemfile.lock

@@ -0,0 +1,137 @@
+PATH
+  remote: .
+  specs:
+    seam (2.0.0a2)
+      http (~> 5.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.6)
+      public_suffix (>= 2.0.2, < 6.0)
+    ansi (1.5.0)
+    ast (2.4.2)
+    base64 (0.2.0)
+    bigdecimal (3.1.7)
+    crack (1.0.0)
+      bigdecimal
+      rexml
+    diff-lcs (1.5.1)
+    docile (1.4.0)
+    domain_name (0.6.20240107)
+    ffi (1.16.3)
+    ffi-compiler (1.3.2)
+      ffi (>= 1.15.5)
+      rake
+    gem-release (2.2.2)
+    hashdiff (1.1.0)
+    http (5.2.0)
+      addressable (~> 2.8)
+      base64 (~> 0.1)
+      http-cookie (~> 1.0)
+      http-form_data (~> 2.2)
+      llhttp-ffi (~> 0.5.0)
+    http-cookie (1.0.5)
+      domain_name (~> 0.5)
+    http-form_data (2.3.0)
+    json (2.7.2)
+    language_server-protocol (3.17.0.3)
+    lint_roller (1.1.0)
+    llhttp-ffi (0.5.0)
+      ffi-compiler (~> 1.0)
+      rake (~> 13.0)
+    multi_json (1.15.0)
+    parallel (1.24.0)
+    parse_gemspec (1.0.0)
+    parse_gemspec-cli (1.0.0)
+      multi_json
+      parse_gemspec
+      thor
+    parser (3.3.0.5)
+      ast (~> 2.4.1)
+      racc
+    public_suffix (5.0.5)
+    racc (1.7.3)
+    rainbow (3.1.1)
+    rake (13.2.1)
+    regexp_parser (2.9.0)
+    rexml (3.2.6)
+    rspec (3.13.0)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.0)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.1)
+    rubocop (1.62.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.31.2)
+      parser (>= 3.3.0.4)
+    rubocop-performance (1.20.2)
+      rubocop (>= 1.48.1, < 2.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
+    ruby-progressbar (1.13.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-console (0.9.1)
+      ansi
+      simplecov
+      terminal-table
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    standard (1.35.1)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.62.0)
+      standard-custom (~> 1.0.0)
+      standard-performance (~> 1.3)
+    standard-custom (1.0.2)
+      lint_roller (~> 1.0)
+      rubocop (~> 1.50)
+    standard-performance (1.3.1)
+      lint_roller (~> 1.1)
+      rubocop-performance (~> 1.20.2)
+    terminal-table (3.0.2)
+      unicode-display_width (>= 1.1.1, < 3)
+    thor (1.3.1)
+    unicode-display_width (2.5.0)
+    webmock (3.0.1)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  gem-release (~> 2.2)
+  parse_gemspec-cli (~> 1.0)
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  seam!
+  simplecov (~> 0.21)
+  simplecov-console (~> 0.9)
+  standard (~> 1.3)
+  webmock (~> 3.0.0)
+
+BUNDLED WITH
+   2.4.19

data/LICENSE.txt

@@ -1,22 +1,20 @@
-Copyright (c) 2013 Darren Cauthon
+The MIT License (MIT)
 
-MIT License
+Copyright (c) 2021-2024 Seam Labs, Inc.
 
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
 
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,166 +1,169 @@
-# Seam
+# Seam Ruby SDK
 
-Simple workflows in Ruby. 
+[![RubyGems.org](https://img.shields.io/gem/v/seam)](https://rubygems.org/gems/seam)
+[![GitHub Actions](https://github.com/seamapi/ruby-next/actions/workflows/check.yml/badge.svg)](https://github.com/seamapi/ruby-next/actions/workflows/check.yml)
 
-## Usage
+SDK for the Seam API written in Ruby.
 
-Seam is meant for situations where you want to take some entity (user, order, ec.) through a long-running process that is comprised of multiple steps.
+## Description
 
-For example, if you want every new user a "hello" email after signup, then wait a few days, and then send a "gone so soon?" email if they haven't signed in again.
+TODO
 
-This gem provides some simple tools for building and executing this process.
-It provides a way to define the process, break it up into separate components, and then send entities through the process.
-
-####Define a workflow####
+## Installation
 
-To start, define a workflow.
+Add this as a dependency to your project using [Bundler] with
 
-````
-flow = Seam::Flow.new
-flow.send_order_to_warehouse
-flow.wait_for_order_to_be_shipped wait_up_to: 7.days
-flow.send_shipping_email email_template: 'shipping_7'
-flow.mark_order_as_fulfilled
-````
+```
+$ bundle add seam
+```
 
-A flow will convert any method call you make into a step that has to be completed. 
+[bundler]: https://bundler.io/
 
-You can also pass a hash to the method, which will be saved for later.
+## Development and Testing
 
-````
-flow.wait_for_order_to_be_shipped wait_up_to: 7.days
-````
+### Quickstart
 
-####Starting an instance of the flow####
+```
+$ git clone https://github.com/seamapi/ruby-next.git
+$ cd ruby-next
+$ bundle install
+```
 
-Starting an instance of the flow is done with "start":
+Run the command below
 
-````
-flow.start order_id: '1234'
-````
+```
+$ bundle exec rake
+```
 
-An instance of this effort was created and saved in whatever persistence is being used (in-memory by default). 
+Open an interactive ruby console with
 
-This effort will start at the first step (send_order_to_warehouse) and then progress through the steps as they are completed.
+```
+$ bundle exec rake
+```
 
-"start" also returns the effort that was created, and it will look like this:
+Primary development tasks are defined as [rake] tasks in the `Rakefile`
+and available via `rake`.
+View them with
 
-````
-<Seam::Effort 
-  @completed_steps=[], 
-  @history=[], 
-  @complete=false, 
-  @id="1ecc4cbe-16af-45f6-8532-7f37493ec11c", 
-  @created_at=2013-08-20 22:58:07 -0500, 
-  @next_execute_at=2013-08-20 22:58:07 -0500, 
-  @next_step="send_order_to_warehouse", 
-  @flow={"steps"=>[{"name"=>"send_order_to_warehouse", "type"=>"do", "arguments"=>{}}, {"name"=>"wait_for_order_to_be_shipped", "type"=>"do", "arguments"=>{}}, {"name"=>"send_shipping_email", "type"=>"do", "arguments"=>{}}, {"name"=>"mark_order_as_fulfilled", "type"=>"do", "arguments"=>{}}]}, 
-  @data={"order_id"=>"1234"}>
-````
+```
+$ bundle exec rake -T
+```
 
-So we have a unique instance of this flow and the instance has been saved in the database.  The first step to be executed for this instance is "send_order_to_warehouse", so let's create a worker for this step.
+[rake]: https://ruby.github.io/rake/
 
-####Defining workers for each step####
+### Source code
 
-A workflow is comprised of steps, and each step needs a worker.  Each worker will execute whatever it was meant to do, and then either:
+The [source code] is hosted on GitHub.
+Clone the project with
 
-1. Pass the workflow instance to the next step on the process, or
-2. Delay the step execution for a later date, or
-3. End the entire workflow process for the instance.
+```
+$ git clone git@github.com:seamapi/ruby-next.git
+```
 
-Since send_order_to_warehouse is the first step in this workflow, let's build the worker for it first:
+[source code]: https://github.com/seamapi/ruby-next
 
-````
-class SendOrderToWarehouseWorker < Seam::Worker
-  def process
-    # the current workflow instance is available as "effort"
-    order = Order.find effort.data['order_id']
-    warehouse_service.send order
+### Requirements
 
-    # by default, if this worker completes with no error the workflow instance will be sent to the next step
-  end
-end
-````
+You will need [Ruby] with [Bundler] and [Node.js] with [npm].
 
-If you name your class as a camel-case version of the step, Seam will automatically bind up the worker to the step.  
+Be sure that all commands run under the correct Ruby version, e.g.,
+if using [rbenv], install the correct version with
 
-To execute the worker, use:
+```
+$ rbenv install
+$ npm install
+```
 
-````
-SendOrderToWarehouse.execute_all
-````
+Install the development dependencies with
 
-This method will look for all workflow instances that are currently ready for the step in question.
+```
+$ bundle install
+```
 
-####Progressing through the workflow####
+[bundler]: https://bundler.io/
+[Node.js]: https://nodejs.org/
+[npm]: https://www.npmjs.com/
+[ruby]: https://www.ruby-lang.org/
+[rbenv]: https://github.com/rbenv/rbenv
 
-By default, steps are considered as being completed when the worker completes successfully.  There might be times where you don't want to go quickly, like the next step in this example:
+### Publishing
 
-````
-class WaitForOrderToBeShippedWorker < Seam::Worker
-  def process
-    effort.data["shipping_status"] = # some method that returns the shipping status
-    unless effort.data["shipping_status"] == "shipped"
-      try_again_in 4.hours
-    end
-  end
-end
-````
+New versions are created with [gem release].
 
-"try_again_in" can be used to signal that the step has not been completed and should be retried later.
+#### Automatic
 
-"eject" can also be used to signify that the entire workflow should be stopped, like so:
+New versions are released automatically with [semantic-release]
+as long as commits follow the [Angular Commit Message Conventions].
 
-````
-class WaitForOrderToBeShippedWorker < Seam::Worker
-  def process
-    effort.data["shipping_status"] = # some method that returns the shipping status
-    if effort.data["shipping_status"] == "cancelled"
-      eject # no need to continue!
-    end
-  end
-end
-````
+[Angular Commit Message Conventions]: https://semantic-release.gitbook.io/semantic-release/#commit-message-format
+[semantic-release]: https://semantic-release.gitbook.io/
 
-####History####
+#### Manual
 
-As workflow instances progress through each step, the history of every operation will be stored.  A history of the "data" block before and after each step run is also stored.
+Publish a new version by triggering a [version workflow_dispatch on GitHub Actions].
+The `version` input will be passed to the `--version` option of `gem bump`.
 
-The history is available through:
+This may be done on the web or using the [GitHub CLI] with
 
-````
-effort.history
-````
+```
+$ gh workflow run version.yml --raw-field version=<version>
+```
 
-####Waiting####
+[gem release]: https://github.com/svenfuchs/gem-release
+[GitHub CLI]: https://cli.github.com/
+[version workflow_dispatch on GitHub Actions]: https://github.com/seamapi/ruby-next/actions?query=workflow%3Aversion
 
-Seam comes with a default worker for waiting. It can be defined by calling "wait" on a flow, like this.
+## GitHub Actions
 
-````
-flow = Seam::Flow.new
-flow.send_order_to_warehouse
-flow.wait 2.days
-flow.check_if_the_order_has_been_fulfilled
-````
+_GitHub Actions should already be configured: this section is for reference only._
 
-## Installation
+The following repository secrets must be set on [GitHub Actions]:
 
-Add this line to your application's Gemfile:
+- `RUBYGEMS_API_KEY`: RubyGems.org token for publishing gems.
 
-    gem 'seam'
+These must be set manually.
 
-And then execute:
+### Secrets for Optional GitHub Actions
 
-    $ bundle
+The version, format, generate, and semantic-release GitHub actions
+require a user with write access to the repository.
+Set these additional secrets to enable the action:
 
-Or install it yourself as:
+- `GH_TOKEN`: A personal access token for the user.
+- `GIT_USER_NAME`: The GitHub user's real name.
+- `GIT_USER_EMAIL`: The GitHub user's email.
+- `GPG_PRIVATE_KEY`: The GitHub user's [GPG private key].
+- `GPG_PASSPHRASE`: The GitHub user's GPG passphrase.
 
-    $ gem install seam
+[github actions]: https://github.com/features/actions
+[gpg private key]: https://github.com/marketplace/actions/import-gpg#prerequisites
 
 ## Contributing
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+Please submit and comment on bug reports and feature requests.
+
+To submit a patch:
+
+1. Fork it (https://github.com/seamapi/ruby-next/fork).
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Make changes.
+4. Commit your changes (`git commit -am 'Add some feature'`).
+5. Push to the branch (`git push origin my-new-feature`).
+6. Create a new Pull Request.
+
+## License
+
+This Ruby gem is licensed under the MIT license.
+
+## Warranty
+
+This software is provided by the copyright holders and contributors "as is" and
+any express or implied warranties, including, but not limited to, the implied
+warranties of merchantability and fitness for a particular purpose are
+disclaimed. In no event shall the copyright holder or contributors be liable for
+any direct, indirect, incidental, special, exemplary, or consequential damages
+(including, but not limited to, procurement of substitute goods or services;
+loss of use, data, or profits; or business interruption) however caused and on
+any theory of liability, whether in contract, strict liability, or tort
+(including negligence or otherwise) arising in any way out of the use of this
+software, even if advised of the possibility of such damage.

data/Rakefile

@@ -1 +1,24 @@
+# frozen_string_literal: true
+
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "standard/rake"
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = "--pattern spec/**/*_spec.rb"
+end
+
+task default: %i[lint test]
+
+task test: "spec"
+task lint: "standard"
+task format: "standard:fix"
+
+desc "Open an interactive ruby console"
+task :console do
+  require "irb"
+  require "bundler/setup"
+  require "seam"
+  ARGV.clear
+  IRB.start
+end

data/lib/seam/client.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Seam
+  class Client
+    attr_accessor :api_key, :base_uri, :debug, :wait_for_action_attempt
+
+    def self.lts_version
+      Seam::LTS_VERSION
+    end
+
+    def initialize(api_key: nil, base_uri: nil, wait_for_action_attempt: false, debug: false)
+      @api_key = api_key || ENV["SEAM_API_KEY"]
+      @base_uri = base_uri || ENV["SEAM_API_URL"] || ENV["SEAM_ENDPOINT"] || "https://connect.getseam.com"
+      @debug = debug
+      @wait_for_action_attempt = wait_for_action_attempt
+
+      raise ArgumentError, "SEAM_API_KEY not found in environment, and api_key not provided" if @api_key.to_s.empty?
+
+      if ENV["SEAM_API_URL"]
+        warn "Using the SEAM_API_URL environment variable is deprecated. " \
+             "Support will be removed in a later major version. Use SEAM_ENDPOINT instead."
+      end
+    end
+
+    def lts_version
+      Seam::LTS_VERSION
+    end
+
+    def access_codes
+      @access_codes ||= Seam::Clients::AccessCodes.new(self)
+    end
+
+    def acs
+      @acs ||= Seam::Clients::Acs.new(self)
+    end
+
+    def action_attempts
+      @action_attempts ||= Seam::Clients::ActionAttempts.new(self)
+    end
+
+    def client_sessions
+      @client_sessions ||= Seam::Clients::ClientSessions.new(self)
+    end
+
+    def connect_webviews
+      @connect_webviews ||= Seam::Clients::ConnectWebviews.new(self)
+    end
+
+    def connected_accounts
+      @connected_accounts ||= Seam::Clients::ConnectedAccounts.new(self)
+    end
+
+    def devices
+      @devices ||= Seam::Clients::Devices.new(self)
+    end
+
+    def events
+      @events ||= Seam::Clients::Events.new(self)
+    end
+
+    def locks
+      @locks ||= Seam::Clients::Locks.new(self)
+    end
+
+    def networks
+      @networks ||= Seam::Clients::Networks.new(self)
+    end
+
+    def noise_sensors
+      @noise_sensors ||= Seam::Clients::NoiseSensors.new(self)
+    end
+
+    def phones
+      @phones ||= Seam::Clients::Phones.new(self)
+    end
+
+    def thermostats
+      @thermostats ||= Seam::Clients::Thermostats.new(self)
+    end
+
+    def user_identities
+      @user_identities ||= Seam::Clients::UserIdentities.new(self)
+    end
+
+    def webhooks
+      @webhooks ||= Seam::Clients::Webhooks.new(self)
+    end
+
+    def workspaces
+      @workspaces ||= Seam::Clients::Workspaces.new(self)
+    end
+
+    def health
+      request_seam(:get, "/health")
+    end
+
+    # @deprecated Please use {#devices.unmanaged} instead.
+    def unmanaged_devices
+      warn "[DEPRECATION] 'unmanaged_devices' is deprecated. Please use 'devices.unmanaged' instead."
+
+      @unmanaged_devices ||= Seam::Clients::DevicesUnmanaged.new(self)
+    end
+
+    # @deprecated Please use {#access_codes.unmanaged} instead.
+    def unmanaged_access_codes
+      warn "[DEPRECATION] 'unmanaged_access_codes' is deprecated. Please use 'access_codes.unmanaged' instead."
+
+      @unmanaged_access_codes ||= Seam::Clients::AccessCodesUnmanaged.new(self)
+    end
+
+    def request_seam_object(method, path, klass, inner_object, config = {})
+      response = request_seam(method, path, config)
+
+      data = response[inner_object]
+
+      klass.load_from_response(data, self)
+    end
+
+    def request_seam(method, path, config = {})
+      Seam::Request.new(
+        api_key: api_key,
+        base_uri: base_uri,
+        debug: debug
+      ).perform(
+        method, path, config
+      )
+    end
+  end
+end