pushizo 0.1.0

data/lib/pushizo/identity_token.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "base64"
+require "json"
+require "openssl"
+
+module Pushizo
+  # SDK JWT identity verification belirteci (ES256; ADR-0023 §9): sub = external_id, aud = app_id, ömür en çok
+  # 24 saat. Uygulamanız belirteci kendi sunucusundan alır ve istemci SDK'sının login(external_id, jwt) çağrısına verir.
+  module IdentityToken
+    MAX_LIFETIME_SECONDS = 86_400
+
+    module_function
+
+    def create(private_key_pem, kid:, app_id:, external_id:, expires_in: 3600, now: nil)
+      raise ArgumentError, "expires_in 1…86400 aralığında olmalı" unless expires_in.is_a?(Integer) && expires_in.between?(1, MAX_LIFETIME_SECONDS)
+
+      key = OpenSSL::PKey.read(private_key_pem)
+      raise ArgumentError, "ES256 için P-256 EC özel anahtarı gerekli" unless key.is_a?(OpenSSL::PKey::EC) && key.group.curve_name == "prime256v1"
+
+      iat = (now || Time.now).to_i
+      header = b64url(JSON.generate({ alg: "ES256", typ: "JWT", kid: kid }))
+      payload = b64url(JSON.generate({ sub: external_id, aud: app_id, iat: iat, exp: iat + expires_in }))
+      signing_input = "#{header}.#{payload}"
+      der = key.sign(OpenSSL::Digest.new("SHA256"), signing_input)
+      # JWS ES256 imzası DER değil r||s (her biri 32 bayt).
+      r, s = OpenSSL::ASN1.decode(der).value.map { |i| i.value.to_s(2).rjust(32, "\0".b) }
+      "#{signing_input}.#{b64url(r + s)}"
+    end
+
+    def b64url(data)
+      Base64.urlsafe_encode64(data, padding: false)
+    end
+  end
+
+  # Kısayol: Pushizo.identity_token(pem, kid:, app_id:, external_id:).
+  def self.identity_token(private_key_pem, **kwargs)
+    IdentityToken.create(private_key_pem, **kwargs)
+  end
+end

data/lib/pushizo/model.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Pushizo
+  # Çalışma zamanı tip dönüşümü: API yanıtlarını model sınıflarına, istek gövdelerini JSON uyumlu hash'e çevirir.
+  # Tip tanımı: :string, :integer, :number, :boolean, :binary, :any, [:array, T], [:map, T] veya model sınıf adı (String).
+  module Types
+    module_function
+
+    def coerce(value, type)
+      return value if value.nil?
+
+      case type
+      when String
+        klass = Pushizo::Models.const_get(type)
+        value.is_a?(Hash) ? klass.new(value) : value
+      when Array
+        kind, inner = type
+        if kind == :array && value.is_a?(Array)
+          value.map { |v| coerce(v, inner) }
+        elsif kind == :map && value.is_a?(Hash)
+          value.each_with_object({}) { |(k, v), h| h[k.to_s] = coerce(v, inner) }
+        else
+          value
+        end
+      else
+        value
+      end
+    end
+
+    # Model, sembol anahtarlı hash ve iç içe yapıları JSON uyumlu (string anahtarlı) değere çevirir.
+    def serialize(value)
+      case value
+      when BaseModel then serialize(value.to_h)
+      when Hash then value.each_with_object({}) { |(k, v), h| h[k.to_s] = serialize(v) }
+      when Array then value.map { |v| serialize(v) }
+      when Symbol then value.to_s
+      else value
+      end
+    end
+  end
+
+  # Hash tabanlı model: alanlara snake_case okuyucu/yazıcı ve [] ile erişilir; bilinmeyen alanlar korunur.
+  #
+  #   msg = hs.notifications.get("msg_1")
+  #   msg.status          # => "completed"
+  #   msg["status"]       # => "completed"
+  #   msg.to_h            # => { "id" => …, "status" => … }
+  class BaseModel
+    class << self
+      # JSON adı => [metot adı, tip]
+      def fields
+        @fields ||= {}
+      end
+
+      def field(json_name, method_name, type)
+        fields[json_name] = [method_name, type]
+        define_method(method_name) { Pushizo::Types.coerce(@attributes[json_name], type) }
+        define_method(:"#{method_name}=") { |v| @attributes[json_name] = Pushizo::Types.serialize(v) }
+      end
+
+      # JSON adına veya metot adına göre JSON anahtarı.
+      def json_key(key)
+        name = key.to_s
+        return name if fields.key?(name)
+
+        found = fields.find { |_json, (method, _type)| method.to_s == name }
+        found ? found[0] : name
+      end
+    end
+
+    def initialize(attributes = {})
+      @attributes = {}
+      (attributes || {}).each { |k, v| @attributes[self.class.json_key(k)] = Pushizo::Types.serialize(v) }
+    end
+
+    # JSON veya metot adıyla okuma (model alanları model nesnesine çevrilir).
+    def [](key)
+      json = self.class.json_key(key)
+      entry = self.class.fields[json]
+      entry ? Pushizo::Types.coerce(@attributes[json], entry[1]) : @attributes[json]
+    end
+
+    def []=(key, value)
+      @attributes[self.class.json_key(key)] = Pushizo::Types.serialize(value)
+    end
+
+    def key?(key)
+      @attributes.key?(self.class.json_key(key))
+    end
+
+    # JSON adlarıyla ham hash (derin kopya).
+    def to_h
+      Marshal.load(Marshal.dump(@attributes))
+    end
+    alias to_hash to_h
+
+    def to_json(*args)
+      @attributes.to_json(*args)
+    end
+
+    def ==(other)
+      other.class == self.class && other.to_h == to_h
+    end
+    alias eql? ==
+
+    def hash
+      [self.class, @attributes].hash
+    end
+
+    def inspect
+      "#<#{self.class.name} #{@attributes.inspect}>"
+    end
+    alias to_s inspect
+  end
+end

data/lib/pushizo/transport.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "uri"
+
+module Pushizo
+  # Net::HTTP tabanlı varsayılan taşıma. Özel taşıma aynı imzalı #call(method, url, headers, body, timeout)
+  # metodu sağlar ve [durum, başlıklar (küçük harf anahtar), gövde] döndürür; ağ hatasında istisna fırlatır.
+  class NetHttpTransport
+    def call(method, url, headers, body, timeout)
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      http.write_timeout = timeout if http.respond_to?(:write_timeout=)
+      request = Net::HTTPGenericRequest.new(method.to_s.upcase, !body.nil?, true, uri.request_uri, headers)
+      request.body = body unless body.nil?
+      response = http.start { |conn| conn.request(request) }
+      response_headers = {}
+      response.each_header { |k, v| response_headers[k.downcase] = v }
+      [response.code.to_i, response_headers, response.body.to_s]
+    end
+  end
+end

data/lib/pushizo/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pushizo
+  VERSION = "0.1.0"
+end

data/lib/pushizo/webhook.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "json"
+require "openssl"
+
+module Pushizo
+  # Giden webhook imza doğrulaması (alıcı tarafı).
+  #
+  # Başlık: Pushizo-Signature: t=<unix>,v1=<hex> — v1 = HMAC-SHA256(secret, "#{t}.#{ham_gövde}").
+  # Secret rotasyonunda başlıkta iki v1 bulunabilir; herhangi biri eşleşirse imza geçerlidir.
+  #
+  #   payload = request.body.read                       # ham gövde (JSON.parse etmeden)
+  #   header = request.get_header("HTTP_PUSHIZO_SIGNATURE")
+  #   events = Pushizo::Webhook.construct_events(payload, header, ENV.fetch("HS_WEBHOOK_SECRET"))
+  #   # Pushizo-Event-Id ile tekrarları ayıklayın; 2xx ile hızlı yanıt verin.
+  module Webhook
+    SIGNATURE_HEADER = "Pushizo-Signature"
+    EVENT_ID_HEADER = "Pushizo-Event-Id"
+    # Varsayılan zaman damgası toleransı (sn); daha eski t tekrar (replay) sayılır.
+    DEFAULT_TOLERANCE = 300
+
+    # Doğrulama sonucu: ok? ise timestamp, değilse reason doludur.
+    Result = Struct.new(:ok, :timestamp, :reason) do
+      def ok?
+        ok
+      end
+    end
+
+    module_function
+
+    # İmzayı doğrular. payload HAM istek gövdesidir; secret tek değer veya dizi (rotasyon) olabilir.
+    # now test için Unix zamanıdır (sn). Karşılaştırma sabit zamanlıdır.
+    def verify_signature(payload, header, secret, tolerance: DEFAULT_TOLERANCE, now: nil)
+      raw = header.is_a?(Array) ? header.first : header
+      return Result.new(false, nil, "missing_header") if raw.nil? || raw.to_s.empty?
+
+      timestamp = nil
+      signatures = []
+      raw.to_s.split(",").each do |part|
+        idx = part.index("=")
+        next if idx.nil? || idx.zero?
+
+        key = part[0...idx].strip
+        value = part[(idx + 1)..].strip
+        if key == "t" && value.match?(/\A[0-9]+\z/)
+          timestamp = value.to_i
+        elsif key == "v1" && value.match?(/\A[0-9a-f]{64}\z/)
+          signatures << [value].pack("H*")
+        end
+      end
+      return Result.new(false, nil, "malformed_header") if timestamp.nil? || signatures.empty?
+
+      current = (now || Time.now.to_i).to_i
+      return Result.new(false, nil, "timestamp_out_of_tolerance") if (current - timestamp).abs > tolerance
+
+      body = payload.to_s.b
+      Array(secret).each do |s|
+        expected = OpenSSL::HMAC.digest("SHA256", s.to_s, "#{timestamp}.".b + body)
+        return Result.new(true, timestamp, nil) if signatures.any? { |sig| secure_compare(sig, expected) }
+      end
+      Result.new(false, nil, "signature_mismatch")
+    end
+
+    # İmzayı doğrular ve gövdeyi olay listesine (Hash dizisi) çevirir: tekil gövde veya {"events": [...]} batch.
+    # Geçersiz imzada WebhookSignatureError fırlatır.
+    def construct_events(payload, header, secret, tolerance: DEFAULT_TOLERANCE, now: nil)
+      result = verify_signature(payload, header, secret, tolerance: tolerance, now: now)
+      raise WebhookSignatureError, result.reason unless result.ok?
+
+      body = begin
+        JSON.parse(payload.to_s)
+      rescue JSON::ParserError
+        raise WebhookSignatureError, "malformed_body"
+      end
+      raise WebhookSignatureError, "malformed_body" unless body.is_a?(Hash)
+
+      body["events"].is_a?(Array) ? body["events"] : [body]
+    end
+
+    def secure_compare(a, b)
+      return false unless a.bytesize == b.bytesize
+
+      if OpenSSL.respond_to?(:fixed_length_secure_compare)
+        OpenSSL.fixed_length_secure_compare(a, b)
+      else
+        result = 0
+        a.bytes.zip(b.bytes) { |x, y| result |= x ^ y }
+        result.zero?
+      end
+    end
+  end
+end

data/lib/pushizo.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Pushizo Ruby sunucu SDK'sı (Net::HTTP, bağımlılıksız).
+#
+#   hs = Pushizo::Client.new(api_key: ENV.fetch("HS_API_KEY"), app_id: "app_…")
+#   hs.notifications.create(
+#     { target: { include_aliases: { external_id: [user_id] } }, contents: { en: "Shipped" } },
+#     idempotency_key: "order-#{order_id}"
+#   )
+require_relative "pushizo/version"
+require_relative "pushizo/errors"
+require_relative "pushizo/model"
+require_relative "pushizo/file_upload"
+require_relative "pushizo/generated/models"
+require_relative "pushizo/base_resource"
+require_relative "pushizo/generated/resources"
+require_relative "pushizo/transport"
+require_relative "pushizo/client"
+require_relative "pushizo/webhook"
+require_relative "pushizo/identity_token"
+
+module Pushizo
+  # SDK identity verification için identity_hash = HMAC-SHA256(sdk_secret, external_id) (hex).
+  def self.identity_hash(sdk_secret, external_id)
+    OpenSSL::HMAC.hexdigest("SHA256", sdk_secret, external_id.to_s)
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: pushizo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Pushizo
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-22 00:00:00.000000000 Z
+dependencies: []
+description: 'Pushizo public API istemcisi: bildirim gönderme, kullanıcı/abonelik
+  yönetimi, segment/şablon/kampanya ve webhook imza doğrulaması (Net::HTTP, bağımlılıksız).'
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/pushizo.rb
+- lib/pushizo/base_resource.rb
+- lib/pushizo/client.rb
+- lib/pushizo/errors.rb
+- lib/pushizo/file_upload.rb
+- lib/pushizo/generated/models.rb
+- lib/pushizo/generated/resources.rb
+- lib/pushizo/identity_token.rb
+- lib/pushizo/model.rb
+- lib/pushizo/transport.rb
+- lib/pushizo/version.rb
+- lib/pushizo/webhook.rb
+homepage: https://docs.pushizo.com/docs/sdk/ruby
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://docs.pushizo.com/docs/sdk/ruby
+  changelog_uri: https://docs.pushizo.com/docs/changelog
+  documentation_uri: https://docs.pushizo.com/docs/sdk/ruby
+  source_code_uri: https://github.com/pushizo/pushizo-ruby
+  bug_tracker_uri: https://github.com/pushizo/pushizo-ruby/issues
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Pushizo sunucu SDK'sı
+test_files: []