spackle-ruby 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da95d997ac3fdc1de27078762389d267be3d9ff4a89091147eef7d8067a71fd1
-  data.tar.gz: 064c9007ff68c9f51003c49b31ff467595511acc876dd90cd5916ab5ea9d2c2d
+  metadata.gz: e8cf2b94103517a295249a12015de47bba73211680e6414e171df2bc9ab18ceb
+  data.tar.gz: 694bb847e82273d30bb5f7e325bdb795e56a5d4555bcefe01783dc597d22c3d6
 SHA512:
-  metadata.gz: c70087975948d0a24ae44f79ade37f0f821035e1503576992ed82b71dc81733547e22d87106f38e8bed5b48265194402f8f50b0d1968b5d05f41792e7196c6a6
-  data.tar.gz: 1b60e61ecca69ce71662c9a95a1d6b45ef24a4fac3d5469fcf4c21ab74818a63386adfa8bd6d14564016454874d38d1f2013881859dbd55a73a725497210076f
+  metadata.gz: e8e7b93be2dc27f5b823741bed3c29b05113811fb37ae6769e89cf323eb5f6b34c2f6aa1d402e15b064dae86e6864ac155cf6f3fb565fa3c873107020119384c
+  data.tar.gz: 0e4f7073e81f0bba5a572f9ff5e1ad9670cbf0f5e5ec9afc93d3de20c2c2d0cfe476208a232403aaa61046abed6f1e826c3b98fdd9e373bff61d0410067fcbb7

data/Gemfile

@@ -4,8 +4,9 @@ source "https://rubygems.org"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
-gem 'aws-sdk', '~> 3'
+gem "aws-sdk", "~> 3"
 gem "rake", "~> 13.0"
-gem "test-unit", "~> 3.5"
-
 gem "nokogiri", "~> 1.13"
+gem "minitest", "~> 5.18"
+
+gem "stripe", "~> 8.3"

data/Gemfile.lock

@@ -1356,23 +1356,23 @@ GEM
       aws-eventstream (~> 1, >= 1.0.2)
     jmespath (1.6.2)
     mini_portile2 (2.8.1)
+    minitest (5.18.0)
     nokogiri (1.13.10)
       mini_portile2 (~> 2.8.0)
       racc (~> 1.4)
-    power_assert (2.0.3)
     racc (1.6.2)
     rake (13.0.6)
-    test-unit (3.5.7)
-      power_assert
+    stripe (8.3.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   aws-sdk (~> 3)
+  minitest (~> 5.18)
   nokogiri (~> 1.13)
   rake (~> 13.0)
-  test-unit (~> 3.5)
+  stripe (~> 8.3)
 
 BUNDLED WITH
    1.17.2

data/README.md

@@ -21,7 +21,7 @@ gem install spackle-ruby
 ```ruby
 source 'https://rubygems.org'
 
-gem 'spackle'
+gem 'spackle-ruby'
 ```
 
 ### Configure your environment
@@ -63,10 +63,37 @@ customer.enabled("feature_key")
 customer.limit("feature_key")
 ```
 
+### Examine a customer's subscriptions
+
+A customer's current subscriptions are available on the `subscriptions` property. These are valid `Stripe::Subscription` objects as defined in the [Stripe Ruby library](https://stripe.com/docs/api/subscriptions/object?lang=ruby).
+
+```ruby
+customer.subscriptions
+```
+
+## Waiters
+
+There is a brief delay between when an action takes place in Stripe and when it is reflected in Spackle. To account for this, Spackle provides a `Waiters` module that can be used to wait for a Stripe object to be updated and replicated.
+
+1. Wait for a customer to be created
+   ```ruby
+   Spackle::Waiters.wait_for_customer("cus_00000000")
+   ```
+2. Wait for a subscription to be created
+   ```ruby
+   Spackle::Waiters.wait_for_subscription("cus_000000000", "sub_00000000")
+   ```
+3. Wait for a subscription to be updated
+   ```ruby
+   Spackle::Waiters.wait_for_subscription("cus_000000000", "sub_00000000", status: "active")
+   ```
+
+These will block until Spackle is updated with the latest information from Stripe or until a timeout occurs.
+
 ## Logging
 The Spackle Ruby library emits logs as it performs various internal tasks. You can control the verbosity of Spackle's logging a few different ways:
 
-1. Set the environment variable SPACKLE_LOG to the value `debug`, `info`, or `error`
+1. Set the environment variable SPACKLE_LOG to the value `debug`, `info`, `warn` or `error`
 
    ```sh
    $ export SPACKLE_LOG=debug
@@ -77,3 +104,67 @@ The Spackle Ruby library emits logs as it performs various internal tasks. You c
    ```ruby
    Spackle.log_level = 'debug'
    ```
+
+## Usage in development environments
+In production, Spackle requires a valid Stripe customer. However, that is not development environments where state needs to be controlled. As an alternative, you can use a file store to test your application with seed data.
+
+```json
+/app/spackle.json
+
+{
+  "cus_000000000": {
+    "features": [
+      {
+        "key": "flag_feature",
+        "value_flag": true
+      },
+      {
+        "key": "limit_feature",
+        "value_limit": 100
+      }
+    ],
+    "subscriptions": [
+      {
+        "id": "sub_000000000",
+        "status": "trialing",
+        "quantity": 1
+      }
+    ]
+  }
+}
+```
+
+Then configure the file store in your application:
+
+```ruby
+Spackle.store = Spackle::FileStore.new('/app/spackle.json')
+```
+
+## Usage in test environments
+
+In production, Spackle requires a valid Stripe customer. However, that is not ideal in testing or some development environments. As an alternative, you can use an in-memory store to test your application with seed data.
+
+```ruby
+Spackle.store = Spackle::MemoryStore.new()
+Spackle.store.set_customer_data("cus_000000000", {
+  "features": [
+    {
+      "key": "flag_feature",
+      "value_flag": True,
+    },
+    {
+      "key": "limit_feature",
+      "value_limit": 100,
+    },
+  ],
+  "subscriptions": [
+     {
+       "id": "sub_000000000",
+       "status": "trialing",
+       "quantity": 1,
+     }
+  ]
+})
+```
+
+**Note:** The in-memory store is not thread-safe and state will reset on each application restart.

data/Rakefile

@@ -1,7 +1,14 @@
-require "rake/testtask"
+require "minitest/test_task"
 
-task default: %i[test]
+Minitest::TestTask.create # named test, sensible defaults
 
-Rake::TestTask.new do |t|
-  t.pattern = "./test/**/*_test.rb"
+# or more explicitly:
+
+Minitest::TestTask.create(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.warning = false
+  t.test_globs = ["test/**/*_test.rb"]
 end
+
+task :default => :test

data/lib/spackle/customer.rb

@@ -1,38 +1,64 @@
+require 'stripe'
+
 module Spackle
   class Customer
-    @data = nil
+    attr_accessor :id
+    attr_accessor :data
 
     def self.retrieve(id)
       Util.log_debug("Retrieving customer data for #{id}")
-      data = Spackle.client.get_item({
-        'CustomerId' => id
-      })
+      data = Spackle.store.get_customer_data(id)
       Util.log_debug("Retrieved customer data for #{id}: #{data}")
-      Customer.new(data)
+      Customer.new(id, data)
     end
 
-    def initialize(data)
+    def initialize(id, data)
+      @id = id
       @data = data
     end
 
+    def features
+      return @data['features']
+    end
+
+    def subscriptions
+      subscriptions = []
+
+      @data['subscriptions'].each do |s|
+        subscription = Stripe::Subscription.new(s['id'])
+        subscription.update_attributes(s)
+        subscriptions.push(subscription)
+      end
+
+      subscriptions
+    end
+
+    def flag_features
+      features.select { |f| f['type'] == 0 }
+    end
+
+    def limit_features
+      features.select { |f| f['type'] == 1 }
+    end
+
     def enabled(key)
-      @data['features'].each do |f|
+      flag_features.each do |f|
         if f['key'] == key
           return f['value_flag']
         end
       end
 
-      return false
+      raise SpackleError.new "Flag feature #{key} not found"
     end
 
     def limit(key)
       @data['features'].each do |f|
         if f['key'] == key
-          return f['value_limit']
+          return f['value_limit'] || Float::INFINITY
         end
       end
 
-      return 0
+      raise SpackleError.new "Limit feature #{key} not found"
     end
   end
 end

data/lib/spackle/spackle_configuration.rb

@@ -4,18 +4,35 @@ module Spackle
   class SpackleConfiguration
     attr_accessor :api_key
     attr_accessor :api_base
-    attr_accessor :log_level
     attr_reader   :logger
+    attr_reader   :version
 
     def initialize
-      @api_base = 'https://api.spackle.so'
-      @log_level = Logger::INFO
+      @api_base = 'https://api.spackle.so/v1'
+      @log_level = Logger::WARN
       @logger = Logger.new(STDOUT, level: @log_level)
+      @version = 1
+      @store = nil
+    end
+
+    def log_level()
+      @log_level
     end
 
     def log_level=(level)
       @log_level = level
       @logger.level = level
     end
+
+    def store()
+      if @store == nil
+        @store = DynamoDBStore.new
+      end
+      @store
+    end
+
+    def store=(store)
+      @store = store
+    end
   end
 end

data/lib/spackle/stores/base.rb

@@ -0,0 +1,11 @@
+module Spackle
+  class BaseStore
+    def get_customer_data(id)
+      raise NoMethodError, 'get_customer_data not implemented'
+    end
+
+    def set_customer_data(id, data)
+      raise NoMethodError, 'set_customer_data not implemented'
+    end
+  end
+end

data/lib/spackle/{dynamodb.rb → stores/dynamodb.rb}

@@ -1,21 +1,41 @@
 require 'aws-sdk'
 require 'net/http'
 require 'json'
+require 'logger'
 
 module Spackle
-  class DynamoDB
+  class DynamoDBStore < BaseStore
     @client = nil
-    @identity_id = nil
-    @table_name = nil
-    @aws_region = nil
+    @store_config = {}
 
-    def initialize
-      @client = bootstrap_client
+    def initialize(client = nil, store_config = nil)
+      @store_config = store_config || {}
+      @client = client || bootstrap_client
     end
 
+    def get_customer_data(id)
+      data = query({
+        key_condition_expression: 'CustomerId = :customer_id',
+        filter_expression: 'Version = :version',
+        expression_attribute_values: {
+          ':customer_id' => id,
+          ':version' => Spackle.version
+        },
+        limit: 1
+      })
+
+      if not data.items.any?
+        raise SpackleError.new "Customer #{id} not found"
+      end
+
+      JSON.parse(data.items[0]['State'])
+    end
+
+    private
+
     def get_item(key)
       key = key.merge({
-        'AccountId' => @identity_id,
+        'AccountId' => @store_config['identity_id'],
       })
 
       response = @client.get_item({
@@ -26,12 +46,18 @@ module Spackle
       JSON.parse(response.item['State'])
     end
 
-    private
-
+    def query(query)
+      query[:table_name] = @store_config['table_name']
+      query[:key_condition_expression] = 'AccountId = :account_id AND ' + query[:key_condition_expression]
+      query[:expression_attribute_values] = query[:expression_attribute_values].merge({
+        ':account_id' => @store_config['identity_id']
+      })
+      @client.query(query)
+    end
 
     def bootstrap_client
       Util.log_debug('Bootstrapping DynamoDB client...')
-      uri = URI(Spackle.api_base + '/auth/session')
+      uri = URI(Spackle.api_base + '/sessions')
       https = Net::HTTP.new(uri.host, uri.port)
       https.use_ssl = true
 
@@ -42,17 +68,13 @@ module Spackle
       data = JSON.parse(response.body)
       Util.log_debug("Created session: #{data}")
 
-      @identity_id = data['identity_id']
-      @table_name = data['table_name']
-      @aws_region = data['aws_region']
-
+      @store_config = data['adapter']
       credentials = SpackleCredentials.new(
-        data['role_arn'],
-        data['token']
+        @store_config['role_arn'],
+        @store_config['token']
       )
 
       Aws::DynamoDB::Client.new(
-        region: @aws_region,
         credentials: credentials,
       )
     end

data/lib/spackle/stores/file.rb

@@ -0,0 +1,28 @@
+module Spackle
+  class FileStore < BaseStore
+    def initialize(path)
+      @path = path
+    end
+
+    def get_customer_data(id)
+      content = File.read(@path)
+      data = JSON.parse(content)
+      data[id]
+    end
+
+    def set_customer_data(id, customer_data)
+      data = {}
+      if File.exist?(@path)
+        content = File.read(@path)
+        data = JSON.parse(content)
+      end
+
+      if !data.has_key?(id)
+        raise SpackleError.new "Customer #{id} not found"
+      end
+
+      data[id] = customer_data
+      File.write(@path, JSON.pretty_generate(data))
+    end
+  end
+end

data/lib/spackle/stores/memory.rb

@@ -0,0 +1,21 @@
+module Spackle
+  class MemoryStore < BaseStore
+    @data = {}
+
+    def initialize()
+      @data = {}
+    end
+
+    def get_customer_data(id)
+      if !@data.has_key?(id)
+        raise SpackleError.new "Customer #{id} not found"
+      end
+
+      @data[id]
+    end
+
+    def set_customer_data(id, customer_data)
+      @data[id] = customer_data
+    end
+  end
+end

data/lib/spackle/util.rb

@@ -1,15 +1,21 @@
+require 'logger'
+
 module Spackle
   module Util
-    def self.log_error(message)
-      Spackle.logger.error(message)
+    def self.log_debug(message)
+      Spackle.logger.debug(message)
     end
 
     def self.log_info(message)
       Spackle.logger.info(message)
     end
 
-    def self.log_debug(message)
-      Spackle.logger.debug(message)
+    def self.log_warn(message)
+      Spackle.logger.warn(message)
+    end
+
+    def self.log_error(message)
+      Spackle.logger.error(message)
     end
   end
 end

data/lib/spackle/waiters.rb

@@ -0,0 +1,37 @@
+require 'logger'
+
+module Spackle
+  module Waiters
+    def self.wait_for_customer(customer_id, timeout = 15)
+      start = Time.now.to_i
+      while Time.now.to_i - start < timeout do
+        begin
+          return Spackle::Customer.retrieve(customer_id)
+        rescue SpackleError
+          sleep 1
+        end
+      end
+
+      raise SpackleError.new "Timeout waiting for customer #{customer_id}"
+    end
+
+    def self.wait_for_subscription(customer_id, subscription_id, timeout=15, **filters)
+      start = Time.now.to_i
+      while Time.now.to_i - start < timeout do
+        begin
+          customer = Spackle::Customer.retrieve(customer_id)
+          customer.subscriptions.each do |s|
+            if s.id == subscription_id and filters.all? { |k, v| s.send(k) == v }
+              return s
+            end
+          end
+          sleep 1
+        rescue SpackleError
+          sleep 1
+        end
+      end
+
+      raise SpackleError.new "Timeout waiting for subscription #{subscription_id}"
+    end
+  end
+end

data/lib/spackle.rb

@@ -2,17 +2,23 @@ require 'logger'
 require 'forwardable'
 
 require 'spackle/customer'
-require 'spackle/dynamodb'
 require 'spackle/spackle_configuration'
 require 'spackle/util'
+require 'spackle/waiters'
+
+require 'spackle/stores/base'
+require 'spackle/stores/dynamodb'
+require 'spackle/stores/file'
+require 'spackle/stores/memory'
 
 module Spackle
   @config = Spackle::SpackleConfiguration.new
   @client = nil
 
   LEVEL_DEBUG = Logger::DEBUG
-  LEVEL_ERROR = Logger::ERROR
   LEVEL_INFO = Logger::INFO
+  LEVEL_WARN = Logger::WARN
+  LEVEL_ERROR = Logger::ERROR
 
   class << self
     extend Forwardable
@@ -22,18 +28,12 @@ module Spackle
     def_delegators :@config, :api_key, :api_key=
     def_delegators :@config, :api_base, :api_base=
     def_delegators :@config, :log_level, :log_level=
+    def_delegators :@config, :store, :store=
     def_delegators :@config, :logger, :logger=
+    def_delegators :@config, :version, :version=
   end
 
-  def self.client
-    unless Spackle.api_key.nil?
-      @client ||= Spackle::DynamoDB.new()
-    end
-  end
-
-  def self.bootstrap
-    self.client
-    nil
+  class SpackleError < StandardError
   end
 end
 

data/spackle.gemspec

@@ -2,9 +2,9 @@ $LOAD_PATH.unshift(::File.join(::File.dirname(__FILE__), "lib"))
 
 Gem::Specification.new do |s|
   s.name          = "spackle-ruby"
-  s.version       = "0.0.1"
+  s.version       = "0.0.3"
   s.summary       = "Spackle Ruby gem"
-  s.description   = "Spackle is the easiest way to integrate your Ruby app with Stripe Billing." \
+  s.description   = "Spackle is the easiest way to integrate your Ruby app with Stripe Billing. " \
                     "See https://www.spackle.so for details."
   s.authors       = ["Spackle"]
   s.email         = "support@spackle.so"

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: spackle-ruby
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Spackle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-08 00:00:00.000000000 Z
+date: 2023-03-06 00:00:00.000000000 Z
 dependencies: []
-description: Spackle is the easiest way to integrate your Ruby app with Stripe Billing.See
-  https://www.spackle.so for details.
+description: Spackle is the easiest way to integrate your Ruby app with Stripe Billing.
+  See https://www.spackle.so for details.
 email: support@spackle.so
 executables:
 - spackle-console
@@ -26,9 +26,13 @@ files:
 - bin/spackle-console
 - lib/spackle.rb
 - lib/spackle/customer.rb
-- lib/spackle/dynamodb.rb
 - lib/spackle/spackle_configuration.rb
+- lib/spackle/stores/base.rb
+- lib/spackle/stores/dynamodb.rb
+- lib/spackle/stores/file.rb
+- lib/spackle/stores/memory.rb
 - lib/spackle/util.rb
+- lib/spackle/waiters.rb
 - spackle.gemspec
 homepage: https://docs.spackle.so/ruby
 licenses: