licensechain_ruby_sdk 1.0.1

data/lib/licensechain/license_validator.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module LicenseChain
+  class LicenseValidator
+    attr_reader :client
+
+    def initialize(api_key: nil, base_url: nil, timeout: nil, retry_attempts: nil)
+      @client = Client.new(
+        api_key: api_key,
+        base_url: base_url,
+        timeout: timeout,
+        retry_attempts: retry_attempts
+      )
+    end
+
+    # Validate a license key
+    def validate_license(license_key, app_id: nil)
+      response = @client.validate_license(license_key, app_id: app_id)
+      
+      ValidationResult.new(
+        valid: response["valid"],
+        license: response["license"],
+        user: response["user"],
+        app: response["app"],
+        expires_at: response["expires_at"],
+        metadata: response["metadata"],
+        error: response["error"]
+      )
+    end
+
+    # Check if license is valid without full validation
+    def valid?(license_key, app_id: nil)
+      result = validate_license(license_key, app_id: app_id)
+      result.valid?
+    end
+
+    # Get license information
+    def get_license_info(license_key, app_id: nil)
+      result = validate_license(license_key, app_id: app_id)
+      result.license
+    end
+
+    # Check if license is expired
+    def expired?(license_key, app_id: nil)
+      result = validate_license(license_key, app_id: app_id)
+      return true unless result.valid?
+      
+      return false unless result.expires_at
+      
+      Time.parse(result.expires_at) < Time.now
+    end
+
+    # Get days until expiration
+    def days_until_expiration(license_key, app_id: nil)
+      result = validate_license(license_key, app_id: app_id)
+      return nil unless result.valid? && result.expires_at
+      
+      expires_at = Time.parse(result.expires_at)
+      ((expires_at - Time.now) / 1.day).ceil
+    end
+
+    # Batch validate multiple licenses
+    def validate_licenses(license_keys, app_id: nil)
+      license_keys.map do |license_key|
+        validate_license(license_key, app_id: app_id)
+      end
+    end
+
+    # Validate with custom validation rules
+    def validate_with_rules(license_key, app_id: nil, rules: {})
+      result = validate_license(license_key, app_id: app_id)
+      return result unless result.valid?
+
+      # Apply custom validation rules
+      if rules[:max_usage] && result.license&.dig("usage_count").to_i > rules[:max_usage]
+        result.instance_variable_set(:@valid, false)
+        result.instance_variable_set(:@error, "Usage limit exceeded")
+      end
+
+      if rules[:allowed_features] && result.license&.dig("features")
+        allowed_features = rules[:allowed_features]
+        license_features = result.license["features"] || []
+        invalid_features = license_features - allowed_features
+        
+        if invalid_features.any?
+          result.instance_variable_set(:@valid, false)
+          result.instance_variable_set(:@error, "Invalid features: #{invalid_features.join(', ')}")
+        end
+      end
+
+      result
+    end
+  end
+
+  # Result object for license validation
+  class ValidationResult
+    attr_reader :valid, :license, :user, :app, :expires_at, :metadata, :error
+
+    def initialize(valid:, license: nil, user: nil, app: nil, expires_at: nil, metadata: nil, error: nil)
+      @valid = valid
+      @license = license
+      @user = user
+      @app = app
+      @expires_at = expires_at
+      @metadata = metadata || {}
+      @error = error
+    end
+
+    def valid?
+      @valid
+    end
+
+    def invalid?
+      !@valid
+    end
+
+    def expired?
+      return false unless @expires_at
+      Time.parse(@expires_at) < Time.now
+    end
+
+    def user_email
+      @user&.dig("email")
+    end
+
+    def user_name
+      @user&.dig("name")
+    end
+
+    def app_name
+      @app&.dig("name")
+    end
+
+    def license_key
+      @license&.dig("key")
+    end
+
+    def license_id
+      @license&.dig("id")
+    end
+
+    def features
+      @license&.dig("features") || []
+    end
+
+    def usage_count
+      @license&.dig("usage_count") || 0
+    end
+
+    def created_at
+      @license&.dig("created_at")
+    end
+
+    def updated_at
+      @license&.dig("updated_at")
+    end
+
+    def to_h
+      {
+        valid: @valid,
+        license: @license,
+        user: @user,
+        app: @app,
+        expires_at: @expires_at,
+        metadata: @metadata,
+        error: @error
+      }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+  end
+end

data/lib/licensechain/models.rb

@@ -0,0 +1,354 @@
+# frozen_string_literal: true
+
+module LicenseChain
+  # Base model class
+  class Model
+    include Enumerable
+
+    def initialize(attributes = {})
+      @attributes = attributes.dup
+    end
+
+    def [](key)
+      @attributes[key.to_s]
+    end
+
+    def []=(key, value)
+      @attributes[key.to_s] = value
+    end
+
+    def each(&block)
+      @attributes.each(&block)
+    end
+
+    def keys
+      @attributes.keys
+    end
+
+    def values
+      @attributes.values
+    end
+
+    def to_h
+      @attributes.dup
+    end
+
+    def to_json(*args)
+      @attributes.to_json(*args)
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id} #{@attributes.inspect}>"
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && @attributes == other.instance_variable_get(:@attributes)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @attributes.key?(method_name.to_s)
+        @attributes[method_name.to_s]
+      elsif @attributes.key?(method_name.to_s.chomp("="))
+        @attributes[method_name.to_s.chomp("=")] = args.first
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @attributes.key?(method_name.to_s) || @attributes.key?(method_name.to_s.chomp("=")) || super
+    end
+  end
+
+  # User model
+  class User < Model
+    def id
+      self["id"]
+    end
+
+    def email
+      self["email"]
+    end
+
+    def name
+      self["name"]
+    end
+
+    def company
+      self["company"]
+    end
+
+    def created_at
+      Time.parse(self["created_at"]) if self["created_at"]
+    end
+
+    def updated_at
+      Time.parse(self["updated_at"]) if self["updated_at"]
+    end
+
+    def email_verified?
+      self["email_verified"] == true
+    end
+
+    def active?
+      self["status"] == "active"
+    end
+  end
+
+  # Application model
+  class Application < Model
+    def id
+      self["id"]
+    end
+
+    def name
+      self["name"]
+    end
+
+    def description
+      self["description"]
+    end
+
+    def api_key
+      self["api_key"]
+    end
+
+    def webhook_url
+      self["webhook_url"]
+    end
+
+    def allowed_origins
+      self["allowed_origins"] || []
+    end
+
+    def created_at
+      Time.parse(self["created_at"]) if self["created_at"]
+    end
+
+    def updated_at
+      Time.parse(self["updated_at"]) if self["updated_at"]
+    end
+
+    def active?
+      self["status"] == "active"
+    end
+
+    def license_count
+      self["license_count"] || 0
+    end
+  end
+
+  # License model
+  class License < Model
+    def id
+      self["id"]
+    end
+
+    def key
+      self["key"]
+    end
+
+    def app_id
+      self["app_id"]
+    end
+
+    def user_id
+      self["user_id"]
+    end
+
+    def user_email
+      self["user_email"]
+    end
+
+    def user_name
+      self["user_name"]
+    end
+
+    def status
+      self["status"]
+    end
+
+    def expires_at
+      Time.parse(self["expires_at"]) if self["expires_at"]
+    end
+
+    def created_at
+      Time.parse(self["created_at"]) if self["created_at"]
+    end
+
+    def updated_at
+      Time.parse(self["updated_at"]) if self["updated_at"]
+    end
+
+    def metadata
+      self["metadata"] || {}
+    end
+
+    def features
+      self["features"] || []
+    end
+
+    def usage_count
+      self["usage_count"] || 0
+    end
+
+    def active?
+      self["status"] == "active"
+    end
+
+    def expired?
+      return false unless expires_at
+      expires_at < Time.now
+    end
+
+    def revoked?
+      self["status"] == "revoked"
+    end
+
+    def days_until_expiration
+      return nil unless expires_at
+      ((expires_at - Time.now) / 1.day).ceil
+    end
+  end
+
+  # Webhook model
+  class Webhook < Model
+    def id
+      self["id"]
+    end
+
+    def app_id
+      self["app_id"]
+    end
+
+    def url
+      self["url"]
+    end
+
+    def events
+      self["events"] || []
+    end
+
+    def secret
+      self["secret"]
+    end
+
+    def active?
+      self["status"] == "active"
+    end
+
+    def created_at
+      Time.parse(self["created_at"]) if self["created_at"]
+    end
+
+    def updated_at
+      Time.parse(self["updated_at"]) if self["updated_at"]
+    end
+
+    def last_triggered_at
+      Time.parse(self["last_triggered_at"]) if self["last_triggered_at"]
+    end
+
+    def failure_count
+      self["failure_count"] || 0
+    end
+  end
+
+  # Analytics model
+  class Analytics < Model
+    def total_licenses
+      self["total_licenses"] || 0
+    end
+
+    def active_licenses
+      self["active_licenses"] || 0
+    end
+
+    def expired_licenses
+      self["expired_licenses"] || 0
+    end
+
+    def revoked_licenses
+      self["revoked_licenses"] || 0
+    end
+
+    def validations_today
+      self["validations_today"] || 0
+    end
+
+    def validations_this_week
+      self["validations_this_week"] || 0
+    end
+
+    def validations_this_month
+      self["validations_this_month"] || 0
+    end
+
+    def top_features
+      self["top_features"] || []
+    end
+
+    def usage_by_day
+      self["usage_by_day"] || []
+    end
+
+    def usage_by_week
+      self["usage_by_week"] || []
+    end
+
+    def usage_by_month
+      self["usage_by_month"] || []
+    end
+  end
+
+  # Paginated response model
+  class PaginatedResponse < Model
+    def data
+      self["data"] || []
+    end
+
+    def page
+      self["page"] || 1
+    end
+
+    def limit
+      self["limit"] || 20
+    end
+
+    def total
+      self["total"] || 0
+    end
+
+    def total_pages
+      self["total_pages"] || 1
+    end
+
+    def has_next_page?
+      page < total_pages
+    end
+
+    def has_previous_page?
+      page > 1
+    end
+
+    def next_page
+      has_next_page? ? page + 1 : nil
+    end
+
+    def previous_page
+      has_previous_page? ? page - 1 : nil
+    end
+
+    def each(&block)
+      data.each(&block)
+    end
+
+    def size
+      data.size
+    end
+
+    def empty?
+      data.empty?
+    end
+  end
+end

data/lib/licensechain/services/license_service.rb

@@ -0,0 +1,108 @@
+module LicenseChain
+  module Services
+    class LicenseService
+      def initialize(client)
+        @client = client
+      end
+
+      def create(app_id, user_email, metadata = {})
+        Utils.validate_not_empty(app_id, 'app_id')
+        Utils.validate_not_empty(user_email, 'user_email')
+        
+        data = {
+          appId: app_id,
+          plan: 'FREE',
+          issuedEmail: user_email,
+          metadata: Utils.sanitize_metadata(metadata)
+        }
+
+        response = @client.post("/apps/#{app_id}/licenses", data)
+        License.new(normalize_license_payload(response[:data] || response))
+      end
+
+      def get(license_id)
+        Utils.validate_not_empty(license_id, 'license_id')
+        
+        response = @client.get("/licenses/#{license_id}")
+        License.new(normalize_license_payload(response[:data] || response))
+      end
+
+      def update(license_id, updates = {})
+        Utils.validate_not_empty(license_id, 'license_id')
+        
+        response = @client.patch("/licenses/#{license_id}", Utils.sanitize_metadata(updates))
+        License.new(normalize_license_payload(response[:data] || response))
+      end
+
+      def revoke(license_id)
+        Utils.validate_not_empty(license_id, 'license_id')
+        
+        @client.delete("/licenses/#{license_id}")
+        true
+      end
+
+      def validate(license_key, hwuid = nil)
+        Utils.validate_not_empty(license_key, 'license_key')
+        body = { key: license_key }
+        body[:hwuid] = hwuid.to_s.strip != '' ? hwuid.to_s.strip : Utils.default_hwuid
+        response = @client.post('/licenses/verify', body)
+        response[:valid]
+      end
+
+      # Full POST /licenses/verify body (valid, optional license_token, license_jwks_uri, etc.).
+      def verify_with_details(license_key, hwuid = nil)
+        Utils.validate_not_empty(license_key, 'license_key')
+        body = { key: license_key }
+        body[:hwuid] = hwuid.to_s.strip != '' ? hwuid.to_s.strip : Utils.default_hwuid
+        @client.post('/licenses/verify', body)
+      end
+
+      def list_user_licenses(user_id, page = 1, limit = 10)
+        Utils.validate_not_empty(user_id, 'user_id')
+        page, limit = Utils.validate_pagination(page, limit)
+        
+        response = @client.get('/licenses', { page: page, limit: limit })
+        items = response[:data] || response[:licenses] || []
+        filtered = items.select do |license|
+          license[:issuedEmail] == user_id || license[:email] == user_id || license[:user_id] == user_id
+        end
+        {
+          data: filtered.map { |license| License.new(normalize_license_payload(license)) },
+          total: filtered.length,
+          page: page,
+          limit: limit
+        }
+      end
+
+      def stats
+        response = @client.get('/licenses/stats')
+        LicenseStats.new(response[:data] || response)
+      end
+
+      private
+
+      def validate_uuid(id, field_name)
+        Utils.validate_not_empty(id, field_name)
+        raise ValidationError, "Invalid #{field_name} format" unless Utils.validate_uuid(id)
+      end
+
+      def normalize_license_payload(payload)
+        {
+          id: payload[:id],
+          key: payload[:key] || payload[:licenseKey],
+          app_id: payload[:app_id] || payload[:appId] || '',
+          user_id: payload[:user_id],
+          user_email: payload[:user_email] || payload[:issuedEmail] || payload[:email] || '',
+          user_name: payload[:user_name] || payload[:issuedTo],
+          status: (payload[:status] || 'active').to_s.downcase,
+          expires_at: payload[:expires_at] || payload[:expiresAt],
+          created_at: payload[:created_at] || payload[:createdAt],
+          updated_at: payload[:updated_at] || payload[:updatedAt],
+          metadata: payload[:metadata] || {},
+          features: payload[:features] || [],
+          usage_count: payload[:usage_count] || 0
+        }
+      end
+    end
+  end
+end

data/lib/licensechain/services/product_service.rb

@@ -0,0 +1,49 @@
+module LicenseChain
+  module Services
+    class ProductService
+      def initialize(client)
+        @client = client
+      end
+
+      def create(name, description = nil, price = nil, currency = 'USD', metadata = {})
+        validate_required_params(name, price, currency)
+        raise ValidationError, 'Product endpoints are not available in API v1'
+      end
+
+      def get(product_id)
+        raise ValidationError, 'Product endpoints are not available in API v1'
+      end
+
+      def update(product_id, updates = {})
+        raise ValidationError, 'Product endpoints are not available in API v1'
+      end
+
+      def delete(product_id)
+        raise ValidationError, 'Product endpoints are not available in API v1'
+      end
+
+      def list(page = 1, limit = 10)
+        page, limit = Utils.validate_pagination(page, limit)
+        {
+          data: [],
+          total: 0,
+          page: page,
+          limit: limit
+        }
+      end
+
+      def stats
+        ProductStats.new({ total: 0, active: 0, revenue: 0 })
+      end
+
+      private
+
+      def validate_required_params(name, price, currency)
+        Utils.validate_not_empty(name, 'name')
+        Utils.validate_positive(price, 'price')
+        raise ValidationError, 'Invalid currency' unless Utils.validate_currency(currency)
+      end
+
+    end
+  end
+end