schematichq 1.4.0

data/scripts/download-wasm.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+set -e
+
+# Downloads the rules engine WASM binary from the schematic-api GitHub Release.
+# Reads the pinned version from WASM_VERSION at the repo root.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+WASM_DIR="$REPO_ROOT/lib/schematic/wasm"
+VERSION_FILE="$REPO_ROOT/WASM_VERSION"
+TARGET_FILE="$WASM_DIR/rulesengine.wasm"
+
+GITHUB_REPO="SchematicHQ/schematic-api"
+
+if [ ! -f "$VERSION_FILE" ]; then
+    echo "ERROR: WASM_VERSION file not found at $VERSION_FILE"
+    exit 1
+fi
+
+VERSION=$(tr -d '[:space:]' < "$VERSION_FILE")
+TAG="rulesengine/v${VERSION}"
+
+# Skip download if binary already exists and version matches
+if [ -f "$TARGET_FILE" ] && [ -f "$WASM_DIR/.wasm_version" ]; then
+    CURRENT=$(tr -d '[:space:]' < "$WASM_DIR/.wasm_version")
+    if [ "$CURRENT" = "$VERSION" ]; then
+        echo "WASM binary already at version $VERSION, skipping download."
+        exit 0
+    fi
+fi
+
+# Ruby uses the same raw WASM binary as Python/C# (no wasm-bindgen).
+# Try Ruby-specific asset first, fall back to Python asset (identical binary).
+ASSET_NAME="rulesengine-wasm-ruby-v${VERSION}.tar.gz"
+FALLBACK_ASSET_NAME="rulesengine-wasm-python-v${VERSION}.tar.gz"
+
+echo "Downloading rules engine WASM v${VERSION}..."
+mkdir -p "$WASM_DIR"
+
+TMPDIR=$(mktemp -d)
+trap 'rm -rf "$TMPDIR"' EXIT
+
+DOWNLOADED=false
+
+if gh release download "$TAG" \
+    -R "$GITHUB_REPO" \
+    -p "$ASSET_NAME" \
+    -D "$TMPDIR" 2>/dev/null; then
+    DOWNLOADED=true
+elif gh release download "$TAG" \
+    -R "$GITHUB_REPO" \
+    -p "$FALLBACK_ASSET_NAME" \
+    -D "$TMPDIR" 2>/dev/null; then
+    ASSET_NAME="$FALLBACK_ASSET_NAME"
+    DOWNLOADED=true
+fi
+
+if [ "$DOWNLOADED" = false ]; then
+    echo "ERROR: Failed to download WASM binary"
+    echo "Tag: $TAG"
+    echo "Tried: rulesengine-wasm-ruby-v${VERSION}.tar.gz"
+    echo "Tried: rulesengine-wasm-python-v${VERSION}.tar.gz"
+    echo ""
+    echo "Ensure a release exists at:"
+    echo "  https://github.com/${GITHUB_REPO}/releases/tag/${TAG}"
+    echo ""
+    echo "Ensure the GitHub CLI is authenticated: gh auth status"
+    exit 1
+fi
+
+tar -xzf "$TMPDIR/$ASSET_NAME" -C "$TMPDIR"
+
+if [ ! -f "$TMPDIR/rulesengine.wasm" ]; then
+    echo "ERROR: rulesengine.wasm not found in release archive"
+    ls -la "$TMPDIR"
+    exit 1
+fi
+
+cp "$TMPDIR/rulesengine.wasm" "$TARGET_FILE"
+echo "$VERSION" > "$WASM_DIR/.wasm_version"
+
+echo "Downloaded rules engine WASM v${VERSION} to $TARGET_FILE"

data/scripts/webhook_test_server.rb

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "webrick"
+require "json"
+require_relative "../lib/schematic/webhook_verification"
+
+secret = ENV["SCHEMATIC_WEBHOOK_SECRET"] || ARGV[0]
+port = (ENV["PORT"] || "8080").to_i
+
+unless secret
+  puts "Usage: ruby webhook_test_server.rb <webhook_secret>"
+  puts "  or set SCHEMATIC_WEBHOOK_SECRET environment variable"
+  exit 1
+end
+
+server = WEBrick::HTTPServer.new(Port: port)
+
+server.mount_proc "/webhook" do |req, res|
+  puts "\n--- Incoming Webhook ---"
+  puts "Method: #{req.request_method}"
+  puts "Headers:"
+  req.header.each { |k, v| puts "  #{k}: #{v.join(", ")}" }
+
+  body = req.body || ""
+  signature = req.header["x-schematic-webhook-signature"]&.first
+  timestamp = req.header["x-schematic-webhook-timestamp"]&.first
+
+  begin
+    Schematic::Webhooks.verify_signature(body, signature, timestamp, secret)
+    puts "\nSignature: VALID"
+
+    begin
+      parsed = JSON.pretty_generate(JSON.parse(body))
+      puts "Payload:\n#{parsed}"
+    rescue JSON::ParserError
+      puts "Payload (raw): #{body}"
+    end
+
+    res.status = 200
+    res.content_type = "application/json"
+    res.body = JSON.generate({ status: "ok" })
+  rescue Schematic::Webhooks::WebhookSignatureError => e
+    puts "\nSignature: INVALID (#{e.message})"
+    res.status = 401
+    res.content_type = "application/json"
+    res.body = JSON.generate({ error: e.message })
+  end
+end
+
+trap("INT") { server.shutdown }
+
+puts "Webhook test server listening on port #{port}"
+puts "POST webhooks to http://localhost:#{port}/webhook"
+server.start

data/testapp/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gem "redis"
+gem "webrick"

data/testapp/app.rb

@@ -0,0 +1,307 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+##
+# SDK E2E Test App for schematic-ruby.
+#
+# A lightweight HTTP server implementing the standard test app contract
+# defined in the SDK spec. The E2E harness (SchematicHQ/actions/sdk-e2e)
+# calls POST /configure after startup to pass an env-scoped API key,
+# then runs assertions against the other endpoints.
+#
+# SDK source is controlled by SDK_SOURCE env var:
+#   - "local" (default): loads from ../lib
+#   - "published": requires the 'schematichq' gem from RubyGems
+#
+# Usage:
+#   # Local build (default)
+#   ruby testapp/app.rb
+#
+#   # Published version
+#   cd testapp && bundle install
+#   SDK_SOURCE=published ruby app.rb
+
+require "webrick"
+require "json"
+require "socket"
+require "redis"
+
+# --- SDK Loading ---
+
+$LOAD_PATH.unshift(File.join(__dir__, "..", "lib")) unless ENV["SDK_SOURCE"] == "published"
+require "schematichq"
+
+# --- Constants ---
+
+PORT = Integer(ENV["PORT"] || "8080")
+CACHE_TTL = 2.0 # Short TTL for E2E -- tests sleep past this to verify cache expiration
+CACHE_TTL_MS = (CACHE_TTL * 1000).to_i
+
+# --- State ---
+
+module AppState
+  class << self
+    attr_accessor :client, :current_config, :cache_providers
+  end
+
+  self.client = nil
+  self.current_config = {}
+  self.cache_providers = nil
+end
+
+# --- Helpers ---
+
+def parse_json(request)
+  body = request.body
+  return {} if body.nil? || body.empty?
+
+  JSON.parse(body)
+end
+
+def json_response(response, status, body)
+  response.status = status
+  response["Content-Type"] = "application/json"
+  response.body = JSON.generate(body)
+end
+
+# --- Route handlers ---
+
+def handle_health(_request, response)
+  cfg = AppState.current_config
+  json_response(response, 200,
+                "status" => AppState.client ? "configured" : "waiting",
+                "config" => {
+                  "offline" => cfg["offline"] || false,
+                  "useDataStream" => cfg["useDataStream"] || false,
+                  "hasFlagDefaults" => cfg["flagDefaults"].is_a?(Hash) && !cfg["flagDefaults"].empty?,
+                  "cacheTtlMs" => CACHE_TTL_MS
+                })
+end
+
+def handle_configure(request, response)
+  config = parse_json(request)
+
+  # Close existing client if any
+  begin
+    AppState.client&.close
+  rescue StandardError
+    # ignore close errors
+  end
+
+  opts = {
+    api_key: config["apiKey"]
+  }
+
+  # Build Redis client if needed (shared between cache and DataStream/replicator)
+  redis_client = config["redisUrl"] ? Redis.new(url: config["redisUrl"]) : nil
+
+  # Cache provider: explicit Redis, disabled, or SDK defaults
+  cache_providers = if redis_client
+                      [Schematic::RedisCacheProvider.new(client: redis_client, ttl: CACHE_TTL)]
+                    elsif config["noCache"]
+                      []
+                    else
+                      [Schematic::LocalCache.new(ttl: CACHE_TTL)]
+                    end
+  opts[:cache_providers] = cache_providers
+  AppState.cache_providers = cache_providers
+
+  opts[:base_url] = config["baseUrl"] if config["baseUrl"]
+  opts[:event_capture_base_url] = config["eventCaptureBaseUrl"] if config["eventCaptureBaseUrl"]
+  opts[:flag_defaults] = config["flagDefaults"] if config["flagDefaults"]
+  opts[:offline] = true if config["offline"]
+
+  if config["useDataStream"]
+    opts[:use_data_stream] = true
+
+    datastream_opts = { cache_ttl: CACHE_TTL }
+    datastream_opts[:redis_client] = redis_client if redis_client
+
+    if config["replicatorUrl"]
+      datastream_opts[:replicator_mode] = true
+      datastream_opts[:replicator_health_url] = "#{config["replicatorUrl"]}/ready"
+    end
+
+    opts[:datastream_options] = datastream_opts
+  end
+
+  opts[:log_level] = :debug
+  AppState.client = Schematic::SchematicClient.new(**opts)
+  AppState.current_config = config
+
+  json_response(response, 200, "success" => true, "cacheTtlMs" => CACHE_TTL_MS)
+end
+
+def handle_check_flag(request, response)
+  unless AppState.client
+    json_response(response, 503, "error" => "not configured")
+    return
+  end
+
+  body = parse_json(request)
+
+  begin
+    value = AppState.client.check_flag(body["flagKey"], company: body["company"], user: body["user"])
+    json_response(response, 200, "value" => value)
+  rescue StandardError => e
+    json_response(response, 200, "value" => false, "error" => e.message)
+  end
+end
+
+def handle_check_flag_with_entitlement(request, response)
+  unless AppState.client
+    json_response(response, 503, "error" => "not configured")
+    return
+  end
+
+  body = parse_json(request)
+
+  begin
+    resp = AppState.client.check_flag_with_entitlement(body["flagKey"], company: body["company"], user: body["user"])
+    json_response(response, 200, resp.to_h.transform_keys(&:to_s))
+  rescue StandardError => e
+    json_response(response, 200, "value" => false, "error" => e.message)
+  end
+end
+
+def handle_identify(request, response)
+  unless AppState.client
+    json_response(response, 503, "error" => "not configured")
+    return
+  end
+
+  body = parse_json(request)
+
+  # Translate E2E contract to Ruby SDK's identify body:
+  #   E2E:  { "company": {k:v}, "user": {k:v}, "keys": {k:v} }
+  #   SDK:  { keys: {k:v}, company: { keys: {k:v} } }
+  identify_body = { keys: body["keys"] || body["user"] || {} }
+  identify_body[:company] = { keys: body["company"] } if body["company"]
+
+  begin
+    AppState.client.identify(identify_body)
+    json_response(response, 200, "success" => true)
+  rescue StandardError => e
+    json_response(response, 200, "success" => false, "error" => e.message)
+  end
+end
+
+def handle_track(request, response)
+  unless AppState.client
+    json_response(response, 503, "error" => "not configured")
+    return
+  end
+
+  body = parse_json(request)
+
+  track_body = { event: body["event"] }
+  track_body[:company] = body["company"] if body["company"]
+  track_body[:user] = body["user"] if body["user"]
+  track_body[:traits] = body["traits"] if body["traits"]
+  track_body[:quantity] = body["quantity"] unless body["quantity"].nil?
+
+  begin
+    AppState.client.track(track_body)
+    json_response(response, 200, "success" => true)
+  rescue StandardError => e
+    json_response(response, 200, "success" => false, "error" => e.message)
+  end
+end
+
+def handle_set_flag_default(request, response)
+  unless AppState.client
+    json_response(response, 503, "error" => "not configured")
+    return
+  end
+
+  body = parse_json(request)
+
+  begin
+    AppState.client.set_flag_default(body["flagKey"], body["value"])
+    json_response(response, 200, "success" => true)
+  rescue StandardError => e
+    json_response(response, 200, "success" => false, "error" => e.message)
+  end
+end
+
+def handle_config(_request, response)
+  cfg = AppState.current_config
+  json_response(response, 200,
+                "apiKey" => cfg["apiKey"] ? "#{cfg["apiKey"][0..6]}..." : nil,
+                "offline" => cfg["offline"] || false,
+                "useDataStream" => cfg["useDataStream"] || false,
+                "flagDefaults" => cfg["flagDefaults"] || {},
+                "cacheTtlMs" => CACHE_TTL_MS,
+                "configured" => !AppState.client.nil?)
+end
+
+# --- Port finder ---
+
+def find_available_port(start_port)
+  port = start_port
+  loop do
+    server = TCPServer.new("0.0.0.0", port)
+    server.close
+    return port
+  rescue Errno::EADDRINUSE
+    warn "Port #{port} in use, trying #{port + 1}..."
+    port += 1
+  end
+end
+
+# --- Server ---
+
+port = find_available_port(PORT)
+
+server = WEBrick::HTTPServer.new(
+  Port: port,
+  Logger: WEBrick::Log.new($stderr, WEBrick::Log::INFO),
+  AccessLog: [[File.open(File::NULL, "w"), WEBrick::AccessLog::COMMON_LOG_FORMAT]]
+)
+
+server.mount_proc("/health") { |req, res| handle_health(req, res) }
+
+server.mount_proc "/configure" do |req, res|
+  req.request_method == "POST" ? handle_configure(req, res) : json_response(res, 405, "error" => "method not allowed")
+end
+
+server.mount_proc "/check-flag" do |req, res|
+  req.request_method == "POST" ? handle_check_flag(req, res) : json_response(res, 405, "error" => "method not allowed")
+end
+
+server.mount_proc "/check-flag-with-entitlement" do |req, res|
+  req.request_method == "POST" ? handle_check_flag_with_entitlement(req, res) : json_response(res, 405, "error" => "method not allowed")
+end
+
+server.mount_proc "/identify" do |req, res|
+  req.request_method == "POST" ? handle_identify(req, res) : json_response(res, 405, "error" => "method not allowed")
+end
+
+server.mount_proc "/track" do |req, res|
+  req.request_method == "POST" ? handle_track(req, res) : json_response(res, 405, "error" => "method not allowed")
+end
+
+server.mount_proc "/set-flag-default" do |req, res|
+  req.request_method == "POST" ? handle_set_flag_default(req, res) : json_response(res, 405, "error" => "method not allowed")
+end
+
+server.mount_proc("/config") { |req, res| handle_config(req, res) }
+
+$stdout.puts "SDK E2E test app listening on http://localhost:#{port}"
+$stdout.puts "Waiting for POST /configure to initialize SchematicClient..."
+$stdout.flush
+
+# Graceful shutdown
+shutdown = proc do
+  warn "\nShutting down..."
+  AppState.client&.close
+rescue StandardError
+  nil
+ensure
+  server.shutdown
+end
+
+trap("INT", &shutdown)
+trap("TERM", &shutdown)
+
+server.start