lazy_graph 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cb285016525832f149dd41b91340c71f6f6c68d7aebcc0de6376dbf81c71cd8
-  data.tar.gz: fc0bee81e2e2b45dfad51c822c421d0496bda877d8e77598d29875b66f261286
+  metadata.gz: ab53c56801cc3d5974f3ede700635376e2d306d7f1427f7001d30ba1a99907e3
+  data.tar.gz: 8ee2894b379254714c2a9bc69f37af7c30397df606ae7a737c17f926ff59d8da
 SHA512:
-  metadata.gz: 0d156ef5344d260232771fa272d5a318342a46293a5991abb9c47948fd0b79c096f2f1f219cf9383a677435ec0e9e9f1bc95011b254d9828e2b19b86f991a5fe
-  data.tar.gz: e9c44f0ff222e41ad1992703b3f8adf1a4424f073bc80b89bb1d0f85f515fbe8413d023f9072141fbeaff5b242bf9e91fd415c43b8445cc10d2754a17af73b0a
+  metadata.gz: '038a530b89df0972ec9d4bd366fe05094ae07916a2a42dcff6aff26480aa6d395ca2ca8caa9656d1733f8acb541205dd27eedc38a49af46204b897a894a0737f'
+  data.tar.gz: 79d7482d2d6f32aecfc4916a02e0357789675396c93c0245f0d6a79a052dbd1036797025ea8a70175aa5ae256500fe95191521531f96a91b4d27035073b956b1

data/README.md

@@ -41,11 +41,13 @@
 
 ## Introduction
 
-**LazyGraph** is an ideal tool for building efficient, complex rules engines and optionally exposing these as stateless HTTP services.
+**LazyGraph** is an ideal tool for building complex and efficient rules engines, and optionally comes with batteries included for
+exposing these as stateless HTTP services using an opinionated set of defaults.
+
 Unlike traditional rules engines which utilize facts to manipulate stateful memory,
-LazyGraph encodes rules into a stateless and declarative knowledge graph.
+LazyGraph encodes rules into a stateless, declarative knowledge graph.
 
-A LazyGraph is a similar to a limited [**JSON Schema**](https://json-schema.org/), which allows a single structure
+A LazyGraph is similar to a limited [**JSON Schema**](https://json-schema.org/), which allows a single structure
 to define both the shape of your data domain, and all of the rules that should run within it.
 
 To use it, you can:
@@ -70,6 +72,147 @@ The `LazyGraph` library also includes:
 - An optional **HTTP server** to serve dynamic computations from a simple endpoint
 (serve any collection of LazyGraph builders as a stateless rules microservice, no additional code required)!.
 
+## Elevator Pitch
+
+```ruby
+require 'lazy_graph'
+
+module ShoppingCartTotals
+  module API
+    class V1 < LazyGraph::Builder
+      rules_module :cart do
+        array :items do
+          string :name
+          integer :quantity
+          number :price
+          number :unit_total, rule: '${quantity} * ${price}'
+        end
+
+        object :coupon_codes, invisible: true, rule: :valid_coupons do
+          object :".*", pattern_property: true do
+            number :discount_abs
+            number :discount_percent
+            number :min_total
+            one_of [
+              { required: [:discount_abs] },
+              { required: %i[discount_percent min_total] }
+            ]
+          end
+        end
+
+        string :applied_coupon, default: ''
+        number :gross, rule: '${items.unit_total}.sum'
+        number :discount, rule: 'apply_coupon_code(${coupon_codes[applied_coupon]}, ${gross})'
+        number :net, rule: '${gross} - ${discount}'
+        number :gst, rule: '(${net} * 0.1).round(2)'
+        number :total, rule: '${net} + ${gst}'
+      end
+    end
+  end
+
+  module CouponHelpers
+    module_function
+
+    def valid_coupons
+      {
+        '10OFF' => { discount_abs: 10 },
+        '15%OVER100' => { discount_percent: 15, min_total: 100 },
+        '20%OVER200' => { discount_percent: 20, min_total: 200 }
+      }
+    end
+
+    def apply_coupon_code(coupon_code, net)
+      return 0 unless coupon_code
+
+      coupon_code[:discount_abs] || net > coupon_code[:min_total] ? net * coupon_code[:discount_percent] / 100.0 : 0
+    end
+  end
+
+  API::V1.register_helper_modules(CouponHelpers)
+  include LazyGraph.bootstrap_app!(reload_paths: [])
+end
+```
+
+With just the above, we've defined our set of rules for computing GST and cart total, given a set of items.
+We can now:
+* Invoke this module directly from Ruby code, e.g.
+
+```ruby
+ShoppingCartTotals::API::V1.cart.eval!({
+    "items": [
+        {"quantity": 2, "price": 200},
+        {"quantity": 2, "price": 5}
+    ],
+    "applied_coupon": "15%OVER100"
+}).get('[total,net,discount]')
+
+# => {total: 383.35, net: 348.5, discount: 61.5}
+```
+
+* Expose this same service via an efficient, stateless HTTP API
+e.g.
+
+```bash
+$ bundle exec ruby shopping_cart_totals.rb
+Starting single-process server on port 9292...
+[PID 67702] Listening on port 9292...
+```
+
+```bash
+$ RACK_ENV=production bundle exec ruby shopping_cart_totals.rb
+Starting Raxx server with 8 processes on port 9292...
+[PID 67791] Listening on port 9292...
+[PID 67792] Listening on port 9292...
+[PID 67793] Listening on port 9292...
+[PID 67794] Listening on port 9292...
+[PID 67795] Listening on port 9292...
+[PID 67796] Listening on port 9292...
+[PID 67797] Listening on port 9292...
+[PID 67799] Listening on port 9292...
+```
+
+```bash
+$ curl http://localhost:9292/api/v1 -XPOST -d '{
+  "modules": "cart",
+  "context": {
+    "items": [
+        {"quantity": 2, "price": 200},
+        {"quantity": 2, "price": 5}
+    ],
+    "applied_coupon": "15%OVER100"
+  }
+}' | jq
+
+{
+  "type": "success",
+  "result": {
+    "output": {
+      "items": [
+        {
+          "quantity": 2,
+          "price": 200,
+          "unit_total": 400
+        },
+        {
+          "quantity": 2,
+          "price": 5,
+          "unit_total": 10
+        }
+      ],
+      "applied_coupon": "15%OVER100",
+      "gross": 410,
+      "discount": 61.5,
+      "net": 348.5,
+      "gst": 34.85,
+      "total": 383.35
+    }
+  }
+}
+
+```
+The above showcases a selection of the most compelling features of LazyGraph in a simple single-file implementation, but there's much more to see.
+Read on to learn more...
+
 ## Features
 
 - **Lazy Evaluation & Caching**
@@ -81,6 +224,7 @@ The `LazyGraph` library also includes:
 - **Debug Trace**
   The order in which recursive calculations are processed is not always obvious.
   LazyGraph is able to provide a detailed trace of exactly, when and how each value was computed.
+  Output from LazyGraph is transparent and traceable.
 
 - **Rich Querying Syntax**
   Extract exactly what you need from your model with an intuitive path-like syntax. Support for nested properties, arrays, indexing, ranges, wildcards, and more.
@@ -125,19 +269,23 @@ In this section, we’ll explore how to set up a minimal LazyGraph use case:
 
 ### Defining a Schema
 
-A LazyGraph schema looks like a standard JSON Schema, but with a few key differences:
+A LazyGraph schema looks like a standard JSON Schema, you can build LazyGraph schemas
+efficiently using the builder DSL, but can just as easily define one from a plain-old Ruby hash.
+
+There are a few key differences between a JSON schema and a LazyGraph schema:
+
 * The `rule` property, which defines how to compute derived fields.
   - `rule:`
-    Defines a that computes this property’s value, if not given, referencing other fields in the graph.
-* The schema also does not support computation across node types of `oneOf`, `allOf`, `anyOf`, `not`, or references
+    Defines a rule that computes this property’s value, if not given, referencing other fields in the graph.
+
+* The schema also *does not* support computation across node types of `oneOf`, `allOf`, `anyOf`, `not`, or references
 (read examples for alternative mechanisms for achieving similar flexibility in your live schema)
 
 Any field (even object and array fields) can have a `rule` property.
 
-Values at this property are lazily computed by the rule, if not present in the input.
-However, if the value is present in the input, the rule is not triggered.
-This makes a LazyGraph highly flexible.
-(you can override *absolutely any* step in a complex computation graph, if you choose).
+Values at this property are lazily computed, according the rule, if not present in the input.
+However, if the value is present in the input, the rule is not triggered, which makes a LazyGraph highly flexible as
+you can override *absolutely any* computed step or input in a complex computation graph, if you choose.
 
 Here’s a simple **shopping cart** example:
 
@@ -191,7 +339,7 @@ cart_graph = cart_schema.to_lazy_graph
 
 ### Providing Input
 
-Next, we create an **input document** that partially fills out the schema. For instance:
+Once you've defined a `LazyGraph`, you should feed it an **input document** that partially fills out the schema. For instance:
 
 ```ruby
 input_data = {
@@ -209,7 +357,8 @@ input_data = {
 
 ### Querying the Graph
 
-To compute derived fields and extract results, we can do:
+Then, to compute derived fields and extract results, we can query our lazy graph instance, to efficiently
+resolve subsections of the graph (or just resolve the whole thing!).
 
 ```ruby
 # Create the graph and run the query:
@@ -287,7 +436,7 @@ end
 
 # Then we can build a cart schema, feed input, and query:
 cart_schema = ShoppingCart::CartBuilder.cart_base
-context = cart_schema.context({
+context = cart_schema.feed({
   cart: {
     items: [
       { name: 'Widget', price: 10.0, quantity: 2 },
@@ -313,7 +462,9 @@ rules_module :stock do
 end
 ```
 
-You can then merge these, by chaining module builder calls
+You can easily merge these, by chaining module builder calls.
+This merging capability is particularly powerful if you have a very large business domain with many overlapping concerns.
+You can allow the caller to dynamically compose and query any combination of these sub-domains, as required.
 
 ```ruby
 # Combine two modules
@@ -337,6 +488,8 @@ This graph-based approach means you can nest derived fields deeply without worry
 There are several different ways to define Rules in a LazyGraph.
 The most portable way (using plain old JSON) is to define a rule as a string that references other properties in the schema using
 ${} placeholder syntax.
+
+##### Simple inline rules
 E.g.
 
 ```ruby
@@ -361,12 +514,13 @@ rule: {
 }
 ```
 
+##### Block Rules
 The most expressive way to define rules is to use a Ruby block, proc or lambda.
-The arguments to the block are automatically resolved as inputs into the block.
-You can use keyword arguments to map paths to the input names.
+This is also the recommended approach for any rules that are more than a simple expression.
+
+The arguments to the block are *automatically* resolved and fed as inputs into the block.
+You can use keyword arguments to map paths to the input names (only necessary if the input name differs from the resolved input path)
 
-*Note:* Block rules cannot be define from inside a REPL, as LazyGraph needs to read these from disk
-to be able to include the source code inside debug outputs.
 ```ruby
 # The input price is resolved to the value at path: 'price'
 # The input quantity is resolved to the value at path:  'quantity'
@@ -376,7 +530,11 @@ rule: ->(price, quantity, store_details: store.details) {
 }
 ```
 
-Resolutions are relative to the current node.
+*Note:* Block rules *cannot* be defined from inside a REPL, as LazyGraph needs to read and interpret these blocks from the source code
+on the filesystem to be able to perform resolution and to include the original source code inside debug outputs.
+
+Resolution is performed relative to the current node.
+
 I.e. it will look for the path in the current node, and then in the parent node, and so on, until it finds a match.
 If you wish to make an absolute reference, you can prefix the path with a `$` to indicate that it should start at the root of the schema.
 Note, inside lambda rules, absolute references begin with a _ instead.
@@ -388,10 +546,16 @@ rule: ->(store_details: _.store.details) {
 }
 ```
 
-Inside rules, the scope is set such that you are able to freely access any other node in the computation graph.
+Within the body of a rule, a full binding/context stack is populated, from the current node up to the root node
+and used for resolution of any variables.
+This means that within a rule you exist "within" the graph, and are able to freely access any other node in the computation graph.
+
 Just type a variable by name and it will automatically be recursively resolved to the correct value.
+
 *However* it is essential that you explicitly define all inputs to the rule to ensure resolution is correct,
-as LazyGraph will not automatically resolve any variables that are dynamically accessed.
+as LazyGraph will not automatically resolve any variables that are dynamically accessed, meaning any variables that are
+generated by rules may *not yet* have been populated when accessed from within a rule, unless it's been explicitly indicated as dependency.
+
 This is advanced functionality, and should be used with caution. In general, it is best to define all input dependencies explicitly.
 You can put a breakpoint inside a lambda rule to inspect the current scope and understand what is available to you.
 Check out:
@@ -408,7 +572,8 @@ If you pass `debug: true`, the output will contain an "output_trace" array,
 containing a detailed, ordered log of how each derived field was computed (inputs, calc and outputs).
 
 ```ruby
-context = cart_schema.to_graph_ctx({
+cart_builder = ShoppingCart::CartBuilder.cart_base
+context = cart_builder.feed({
   cart: {
     items: [
       { name: 'Widget', price: 10.0, quantity: 2 },
@@ -416,28 +581,106 @@ context = cart_schema.to_graph_ctx({
     ]
   }
 }, debug: true)
-result = context['cart.cart_total'] # triggers computations
 
-puts result[:debug_trace]
+# Get debug output
+context.debug("cart.cart_total")
+# =>
+# [{output: :"$.cart.items[0].total", result: 20.0, inputs: {price: 10.0, quantity: 2}, calc: "${price} * ${quantity}", location: "$.cart.items[0]"},
+#  {output: :"$.cart.items[1].total", result: 1.0, inputs: {price: 1.0, quantity: 1}, calc: "${price} * ${quantity}", location: "$.cart.items[1]"},
+#  {output: :"$.cart.cart_total", result: 21.0, inputs: {"items.total": [20.0, 1.0]}, calc: "${items.total}.sum", location: "$.cart"}]
+
+# Alternatively, use #resolve to get a hash with both :output and :debug_trace keys populated
+context.resolve("cart.cart_total")
+
+#  context.resolve("cart.cart_total")
 # =>
-# [{output: :"$.cart.items[0].total",
-#   result: 20.0,
-#   inputs: {aa22c03893cb0018e: 10.0, a2fb52b44379212e4: 2},
-#   calc: ["aa22c03893cb0018e * a2fb52b44379212e4"],
-#   location: "$.cart.items[0]"},
-#  {output: :"$.cart.items[1].total",
-#   result: 1.0,
-#   inputs: {aa22c03893cb0018e: 1.0, a2fb52b44379212e4: 1},
-#   calc: ["aa22c03893cb0018e * a2fb52b44379212e4"],
-#   location: "$.cart.items[1]"},
-#  {output: :"$.cart.cart_total", result: 21.0, inputs: {item_totals: [20.0, 1.0]}, calc: ["item_totals.sum"], location: "$.cart"}]
+# {output: 21.0,
+# debug_trace:
+#  [{output: :"$.cart.items[0].total", result: 20.0, inputs: {price: 10.0, quantity: 2}, calc: "${price} * ${quantity}", location: "$.cart.items[0]"},
+#   {output: :"$.cart.items[1].total", result: 1.0, inputs: {price: 1.0, quantity: 1}, calc: "${price} * ${quantity}", location: "$.cart.items[1]"},
+#   {output: :"$.cart.cart_total", result: 21.0, inputs: {"items.total": [20.0, 1.0]}, calc: "${items.total}.sum", location: "$.cart"}]}
 ```
 
 In cases where you accidentally create **circular dependencies**, LazyGraph will log warnings to the debug logs, and detect and break infinite loops
 in the dependency resolution, ensuring that the remainder of the graph is still computed correctly.
 
 ### Conditional Sub-Graphs
-[TODO]
+
+Nodes within a graph, can be conditionally evaluated, based on properties elsewhere in the graph.
+This can help you avoid excessive computation, and support polymorphism in outputs.
+To use this functionality within the Builder dsl, use the #object_conditional helper.
+
+E.g.
+
+```ruby
+module ConversionAPI
+  class Rgb < LazyGraph::Builder
+    rules_module :rgb_converter do
+      %i[h s l g r b c m y k].each { number _1 }
+      string :mode, enum: %i[hsl cmyk rgb]
+      one_of [
+        { required: %i[r g b], properties: { mode: { const: 'rgb' } } },
+        { required: %i[h s l], properties: { mode: { const: 'hsl' } } },
+        { required: %i[c m y k], properties: { mode: { const: 'cmyk' } } }
+      ]
+
+      object_conditional :color do
+        matches :hsl, mode: 'hsl' do
+          array :rgb, type: :number, rule: lambda { |h, s, l|
+            a = s * [l, 1 - l].min
+            f = ->(n, k = (n + h / 30) % 12) { l - a * [[k - 3, 9 - k, 1].min, -1].max }
+            [255 * f.call(0), 255 * f.call(8), 255 * f.call(4)]
+          }
+        end
+
+        matches :cmyk, mode: 'cmyk' do
+          array :rgb, type: :number, rule: lambda { |c, m, y, k|
+            f = ->(x, k) { 255 * (1 - x) * (1 - k) }
+            [f.call(c, k), f.call(m, k), f.call(y, k)]
+          }
+        end
+
+        matches :rgb, mode: 'rgb' do
+          array :rgb, type: :number, rule: :"[${r},${g},${b}]"
+        end
+
+        array :rgb, type: :number
+      end
+    end
+  end
+
+  include LazyGraph.bootstrap_app!
+end
+
+```
+
+```bash
+$ bundle exec ruby converter.rb
+# [PID 91560] Listening on port 9292...
+
+$ curl -XPOST http://localhost:9292/rgb -d '{
+  "modules": "rgb_converter",
+  "query": "color.rgb",
+  "context": {
+    "mode": "hsl",
+    "h": 100,
+    "s": 0.2,
+    "l": 0.5
+  }
+}' | jq
+
+# {
+#  "type": "success",
+#  "result": {
+#    "output": [
+#      127.5,
+#      153.0,
+#      102.0
+#    ]
+#  }
+#}
+```
+
 
 ### Advanced Path Syntax
 
@@ -447,7 +690,7 @@ LazyGraph’s query engine supports a flexible path notation:
 - **Object bracket expansions**: If a property is enclosed in `[keyName]`, the key and value are kept together when extracting partial JSON. For example, `"cart[items]"` yields `{"cart"=>{"items"=>[...]}}`.
 - **Array indexing**: `"items[0]"`, `"items[0..2]"`, `"items[*]"` (all items), or `"items[0, 2, 4]"` for picking multiple indexes.
 - **Ranged queries**: `"items[1..3]"` returns a slice from index 1 to 3 inclusive.
-- **Root Queries**: 'Useful inside rules for depdencies that are not relative to the current node. E.g. `"$.cart.items[0].total"` (or `_.cart.items[0].total` inside proc rules).
+- **Root Queries**: 'Useful inside rules for dependencies that are not relative to the current node. E.g. `"$.cart.items[0].total"` (or `_.cart.items[0].total` inside proc rules).
 
 ### LazyGraph Server
 
@@ -464,7 +707,6 @@ A minimal example might look like:
 
 ```ruby
 require 'lazy_graph'
-require 'lazy_graph/server'
 
 module CartAPI
   VERSION = '0.1.0'
@@ -512,24 +754,17 @@ module CartAPI
   end
 
   # Bootstrap our builder group.
-  include LazyGraph::BuilderGroup.bootstrap!(reload_paths: File.join(__dir__, 'cart_api/**/*.rb'))
+  include LazyGraph.bootstrap_app!
 end
 ```
 
-`config.ru`
-```ruby
-require_relative 'lib/paybun'
-
-run CartAPI.server
-```
-
 Then send requests like:
 
 ```bash
 curl -X POST http://localhost:9292/cart/v1 \
   -H 'Content-Type: application/json' \
   -d '{
-    "modules": { "cart" : {}, "stock": {} },
+    "modules": ["cart", "stock"],
     "query": "cart.cart_total",
     "context": {
       "cart": {

data/Rakefile

@@ -1,4 +1,15 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks'
-task default: %i[]
+require 'minitest/test_task'
+require 'debug'
+
+Minitest::TestTask.create(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.warning = false
+  t.test_globs = ['test/**/*_test.rb']
+  t.test_prelude = 'require "helpers/test_helper.rb"'
+end
+
+task default: :test

data/examples/converter.rb

@@ -0,0 +1,41 @@
+require 'debug'
+require 'lazy_graph'
+
+module ConversionAPI
+  class Rgb < LazyGraph::Builder
+    rules_module :rgb_converter do
+      %i[h s l g r b c m y k].each { number _1 }
+      string :mode, enum: %i[hsl cmyk rgb]
+      one_of [
+        { required: %i[r g b], properties: { mode: { const: 'rgb' } } },
+        { required: %i[h s l], properties: { mode: { const: 'hsl' } } },
+        { required: %i[c m y k], properties: { mode: { const: 'cmyk' } } }
+      ]
+
+      object_conditional :color do
+        matches :hsl, mode: 'hsl' do
+          array :rgb, type: :number, rule: lambda { |h, s, l|
+            a = s * [l, 1 - l].min
+            f = ->(n, k = (n + h / 30) % 12) { l - a * [[k - 3, 9 - k, 1].min, -1].max }
+            [255 * f.call(0), 255 * f.call(8), 255 * f.call(4)]
+          }
+        end
+
+        matches :cmyk, mode: 'cmyk' do
+          array :rgb, type: :number, rule: lambda { |c, m, y, k|
+            f = ->(x, k) { 255 * (1 - x) * (1 - k) }
+            [f.call(c, k), f.call(m, k), f.call(y, k)]
+          }
+        end
+
+        matches :rgb, mode: 'rgb' do
+          array :rgb, type: :number, rule: :"[${r},${g},${b}]"
+        end
+
+        array :rgb, type: :number
+      end
+    end
+  end
+
+  include LazyGraph.bootstrap_app!
+end

data/examples/performance_tests.rb

@@ -15,8 +15,8 @@ class PerformanceBuilder < LazyGraph::Builder
 
         object :position, rule: :"$.positions[position_id]"
         object :pay_schedule, rule: :'pay_schedules[pay_schedule_id]'
-        number :pay_rate, rule: :"position.pay_rate"
-        string :employee_id, rule: :id
+        number :pay_rate, rule: :"${position.pay_rate}"
+        string :employee_id, rule: :"${id}"
       end
     end
 
@@ -94,7 +94,6 @@ def benchmark_ips_n(n, debug: false, validate: false)
 end
 
 def console_n(n, debug: false, validate: false)
-  require 'debug'
   graph = PerformanceBuilder.performance.build!(debug: debug, validate: validate)
   employees = gen_employees(n)
   result = graph.context(employees).get('')
@@ -105,5 +104,6 @@ case ARGV[0]
 when 'ips' then benchmark_ips_n(ARGV.fetch(1, 1000).to_i)
 when 'memory' then memory_profile_n(ARGV.fetch(1, 1000).to_i)
 when 'console' then console_n(ARGV.fetch(1, 1000).to_i, debug: true)
-else profile_n(ARGV.fetch(1, 100_000).to_i)
+when 'profile' then profile_n(ARGV.fetch(1, 100_000).to_i)
+else nil
 end

data/examples/shopping_cart_totals.rb

@@ -0,0 +1,56 @@
+require 'lazy_graph'
+
+module ShoppingCartTotals
+  module API
+    class V1 < LazyGraph::Builder
+      rules_module :cart do
+        array :items do
+          string :name
+          integer :quantity
+          number :price
+          number :unit_total, rule: '${quantity} * ${price}'
+        end
+
+        object :coupon_codes, invisible: true, rule: :valid_coupons do
+          object :".*", pattern_property: true do
+            number :discount_abs
+            number :discount_percent
+            number :min_total
+            one_of [
+              { required: [:discount_abs] },
+              { required: %i[discount_percent min_total] }
+            ]
+          end
+        end
+
+        string :applied_coupon, default: ''
+        number :gross, rule: '${items.unit_total}.sum'
+        number :discount, rule: 'apply_coupon_code(${coupon_codes[applied_coupon]}, ${gross})'
+        number :net, rule: '${gross} - ${discount}'
+        number :gst, rule: '(${net} * 0.1).round(2)'
+        number :total, rule: '${net} + ${gst}'
+      end
+    end
+  end
+
+  module CouponHelpers
+    module_function
+
+    def valid_coupons
+      {
+        '10OFF' => { discount_abs: 10 },
+        '15%OVER100' => { discount_percent: 15, min_total: 100 },
+        '20%OVER200' => { discount_percent: 20, min_total: 200 }
+      }
+    end
+
+    def apply_coupon_code(coupon_code, net)
+      return 0 unless coupon_code
+
+      coupon_code[:discount_abs] || net > coupon_code[:min_total] ? net * coupon_code[:discount_percent] / 100.0 : 0
+    end
+  end
+
+  API::V1.register_helper_modules(CouponHelpers)
+  include LazyGraph.bootstrap_app!(reload_paths: [])
+end