jobcelis 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f5e335df49a6f6251dc82ca2884ce9cfa1541ef94fe9936c19344069c1bf68f5
+  data.tar.gz: a1dcc32aa94793cc608150b7533fec44fd4117f11224c8e389459529da2153c3
+SHA512:
+  metadata.gz: 20cb85eba443c66a9e28f6a13587803096a852c00faa66167e51810d8c55b375f29b5c4a1d6a591c29a3e40ed02ad33d160db9b40608f01a22fe20dd510f827b
+  data.tar.gz: 0e1fdb03d0370f9e7903d58475ef8cd77fc995ae3e52f54da3adbeff0b6f5f65211bce5745cfab4e5b2ff7f2a31b44bd6aceced228799a8e5837e9f10c469171

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jobcelis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,376 @@
+# jobcelis
+
+Official Ruby SDK for the [Jobcelis](https://jobcelis.com) Event Infrastructure Platform.
+
+All API calls go to `https://jobcelis.com` by default -- you only need your API key to get started.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "jobcelis"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install jobcelis
+```
+
+## Quick Start
+
+```ruby
+require "jobcelis"
+
+# Only your API key is required -- connects to https://jobcelis.com automatically
+client = Jobcelis::Client.new(api_key: "your_api_key")
+```
+
+> **Custom URL:** If you're self-hosting Jobcelis, you can override the base URL:
+> ```ruby
+> client = Jobcelis::Client.new(api_key: "your_api_key", base_url: "https://your-instance.example.com")
+> ```
+
+## Authentication
+
+The auth methods do not require an API key. Use them to register, log in, and manage JWT tokens.
+
+```ruby
+require "jobcelis"
+
+client = Jobcelis::Client.new(api_key: "")
+
+# Register a new account
+user = client.register(email: "alice@example.com", password: "SecurePass123!", name: "Alice")
+
+# Log in -- returns JWT access token and refresh token
+session = client.login(email: "alice@example.com", password: "SecurePass123!")
+access_token = session["token"]
+refresh_tok = session["refresh_token"]
+
+# Set the JWT for subsequent authenticated calls
+client.set_auth_token(access_token)
+
+# Refresh an expired token
+new_session = client.refresh_token(refresh_tok)
+client.set_auth_token(new_session["token"])
+
+# Verify MFA (requires Bearer token already set)
+result = client.verify_mfa(token: access_token, code: "123456")
+```
+
+## Events
+
+```ruby
+# Send a single event
+event = client.send_event("order.created", { order_id: "123", amount: 99.99 })
+
+# Send batch events (up to 1000)
+batch = client.send_events([
+  { topic: "order.created", payload: { order_id: "1" } },
+  { topic: "order.created", payload: { order_id: "2" } },
+])
+
+# List events with pagination
+events = client.list_events(limit: 25)
+next_page = client.list_events(limit: 25, cursor: events["cursor"])
+
+# Get / delete a single event
+event = client.get_event("evt_abc123")
+client.delete_event("evt_abc123")
+```
+
+## Simulate
+
+```ruby
+# Dry-run an event to see which webhooks would fire
+result = client.simulate_event("order.created", { order_id: "test" })
+```
+
+## Webhooks
+
+```ruby
+# Create a webhook
+webhook = client.create_webhook(
+  url: "https://example.com/webhook",
+  topics: ["order.*"],
+)
+
+# List, get, update, delete
+webhooks = client.list_webhooks
+wh = client.get_webhook("wh_abc123")
+client.update_webhook("wh_abc123", url: "https://new-url.com/hook")
+client.delete_webhook("wh_abc123")
+
+# Health and templates
+health = client.webhook_health("wh_abc123")
+templates = client.webhook_templates
+```
+
+## Deliveries
+
+```ruby
+deliveries = client.list_deliveries(limit: 20, status: "failed")
+client.retry_delivery("del_abc123")
+```
+
+## Dead Letters
+
+```ruby
+dead_letters = client.list_dead_letters
+dl = client.get_dead_letter("dlq_abc123")
+client.retry_dead_letter("dlq_abc123")
+client.resolve_dead_letter("dlq_abc123")
+```
+
+## Replays
+
+```ruby
+replay = client.create_replay(
+  topic: "order.created",
+  from_date: "2026-01-01T00:00:00Z",
+  to_date: "2026-01-31T23:59:59Z",
+  webhook_id: "wh_abc123",  # optional
+)
+replays = client.list_replays
+r = client.get_replay("rpl_abc123")
+client.cancel_replay("rpl_abc123")
+```
+
+## Scheduled Jobs
+
+```ruby
+# Create a job
+job = client.create_job(
+  name: "daily-report",
+  queue: "default",
+  cron_expression: "0 9 * * *",
+  payload: { type: "daily" },
+)
+
+# CRUD
+jobs = client.list_jobs(limit: 10)
+job = client.get_job("job_abc123")
+client.update_job("job_abc123", cron_expression: "0 10 * * *")
+client.delete_job("job_abc123")
+
+# List runs for a job
+runs = client.list_job_runs("job_abc123", limit: 20)
+
+# Preview cron schedule
+preview = client.cron_preview("0 9 * * *", count: 10)
+```
+
+## Pipelines
+
+```ruby
+pipeline = client.create_pipeline(
+  name: "order-processing",
+  topics: ["order.created"],
+  steps: [
+    { type: "filter", config: { field: "amount", gt: 100 } },
+    { type: "transform", config: { add_field: "priority", value: "high" } },
+  ],
+)
+
+pipelines = client.list_pipelines
+p = client.get_pipeline("pipe_abc123")
+client.update_pipeline("pipe_abc123", name: "order-processing-v2")
+client.delete_pipeline("pipe_abc123")
+
+# Test a pipeline with a sample payload
+result = client.test_pipeline("pipe_abc123", { topic: "order.created", payload: { id: "1" } })
+```
+
+## Event Schemas
+
+```ruby
+schema = client.create_event_schema(
+  topic: "order.created",
+  schema: {
+    type: "object",
+    properties: {
+      order_id: { type: "string" },
+      amount: { type: "number" },
+    },
+    required: ["order_id", "amount"],
+  },
+)
+
+schemas = client.list_event_schemas
+s = client.get_event_schema("sch_abc123")
+client.update_event_schema("sch_abc123", schema: { type: "object" })
+client.delete_event_schema("sch_abc123")
+
+# Validate a payload against a topic's schema
+result = client.validate_payload("order.created", { order_id: "123", amount: 50 })
+```
+
+## Sandbox
+
+```ruby
+# Create a temporary endpoint for testing
+endpoint = client.create_sandbox_endpoint(name: "my-test")
+endpoints = client.list_sandbox_endpoints
+
+# Inspect received requests
+requests = client.list_sandbox_requests("sbx_abc123", limit: 20)
+
+client.delete_sandbox_endpoint("sbx_abc123")
+```
+
+## Analytics
+
+```ruby
+events_chart = client.events_per_day(days: 30)
+deliveries_chart = client.deliveries_per_day(days: 7)
+topics = client.top_topics(limit: 5)
+stats = client.webhook_stats
+```
+
+## Project and Token Management
+
+```ruby
+# Current project
+project = client.get_project
+client.update_project(name: "My Project v2")
+
+# Topics
+topics = client.list_topics
+
+# API token
+token = client.get_token
+new_token = client.regenerate_token
+```
+
+## Multi-Project Management
+
+```ruby
+projects = client.list_projects
+new_project = client.create_project("staging-env")
+p = client.get_project_by_id("proj_abc123")
+client.update_project_by_id("proj_abc123", name: "production-env")
+client.set_default_project("proj_abc123")
+client.delete_project("proj_abc123")
+```
+
+## Team Members
+
+```ruby
+members = client.list_members("proj_abc123")
+member = client.add_member("proj_abc123", email: "alice@example.com", role: "admin")
+client.update_member("proj_abc123", "mem_abc123", role: "viewer")
+client.remove_member("proj_abc123", "mem_abc123")
+```
+
+## Invitations
+
+```ruby
+# List pending invitations
+invitations = client.list_pending_invitations
+
+# Accept or reject
+client.accept_invitation("inv_abc123")
+client.reject_invitation("inv_def456")
+```
+
+## Audit Logs
+
+```ruby
+logs = client.list_audit_logs(limit: 100)
+next_page = client.list_audit_logs(cursor: logs["cursor"])
+```
+
+## Data Export
+
+Export methods return raw strings (CSV or JSON).
+
+```ruby
+# Export as CSV
+csv_data = client.export_events(format: "csv")
+File.write("events.csv", csv_data)
+
+# Export as JSON
+json_data = client.export_deliveries(format: "json")
+
+# Other exports
+client.export_jobs(format: "csv")
+client.export_audit_log(format: "csv")
+```
+
+## GDPR / Privacy
+
+```ruby
+# Consent management
+consents = client.get_consents
+client.accept_consent("marketing")
+
+# Data portability
+my_data = client.export_my_data
+
+# Processing restrictions
+client.restrict_processing
+client.lift_restriction
+
+# Right to object
+client.object_to_processing
+client.restore_consent
+```
+
+## Health Check
+
+```ruby
+health = client.health
+status = client.status
+```
+
+## Error Handling
+
+```ruby
+require "jobcelis"
+
+client = Jobcelis::Client.new(api_key: "your_api_key")
+
+begin
+  event = client.get_event("nonexistent")
+rescue Jobcelis::Error => e
+  puts "Status: #{e.status}"   # 404
+  puts "Detail: #{e.detail}"   # {"message"=>"Not found"}
+end
+```
+
+## Webhook Signature Verification
+
+```ruby
+require "jobcelis"
+
+# Sinatra example
+post "/webhook" do
+  body = request.body.read
+  signature = request.env["HTTP_X_SIGNATURE"]
+
+  unless Jobcelis::WebhookVerifier.verify(
+    secret: "your_webhook_secret",
+    body: body,
+    signature: signature
+  )
+    halt 401, "Invalid signature"
+  end
+
+  event = JSON.parse(body)
+  puts "Received: #{event['topic']}"
+  status 200
+  "OK"
+end
+```
+
+## License
+
+MIT

data/lib/jobcelis/client.rb

@@ -0,0 +1,662 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Jobcelis
+  # Client for the Jobcelis Event Infrastructure Platform API.
+  #
+  # All API calls go to https://jobcelis.com by default.
+  #
+  #   client = Jobcelis::Client.new(api_key: "your_api_key")
+  #
+  class Client
+    # @param api_key  [String]  Your project API key.
+    # @param base_url [String]  Base URL of the Jobcelis API (default: https://jobcelis.com).
+    # @param timeout  [Integer] Request timeout in seconds (default: 30).
+    def initialize(api_key:, base_url: "https://jobcelis.com", timeout: 30)
+      @api_key  = api_key
+      @base_url = base_url.chomp("/")
+      @timeout  = timeout
+      @auth_token = nil
+    end
+
+    # ------------------------------------------------------------------
+    # Auth
+    # ------------------------------------------------------------------
+
+    # Register a new account. Does not use API key auth.
+    def register(email:, password:, name: nil)
+      body = { email: email, password: password }
+      body[:name] = name unless name.nil?
+      public_post("/api/v1/auth/register", body)
+    end
+
+    # Log in and receive JWT + refresh token. Does not use API key auth.
+    def login(email:, password:)
+      public_post("/api/v1/auth/login", { email: email, password: password })
+    end
+
+    # Refresh an expired JWT using a refresh token. Does not use API key auth.
+    def refresh_token(refresh_token)
+      public_post("/api/v1/auth/refresh", { refresh_token: refresh_token })
+    end
+
+    # Verify MFA code. Requires Bearer token set via set_auth_token.
+    def verify_mfa(token:, code:)
+      post("/api/v1/auth/mfa/verify", { token: token, code: code })
+    end
+
+    # Set JWT bearer token for authenticated requests.
+    def set_auth_token(token)
+      @auth_token = token
+    end
+
+    # ------------------------------------------------------------------
+    # Events
+    # ------------------------------------------------------------------
+
+    # Send a single event.
+    def send_event(topic, payload, **kwargs)
+      post("/api/v1/events", { topic: topic, payload: payload, **kwargs })
+    end
+
+    # Send up to 1000 events in a batch.
+    def send_events(events)
+      post("/api/v1/events/batch", { events: events })
+    end
+
+    # Get event details.
+    def get_event(event_id)
+      get("/api/v1/events/#{event_id}")
+    end
+
+    # List events with cursor pagination.
+    def list_events(limit: 50, cursor: nil)
+      get("/api/v1/events", { limit: limit, cursor: cursor })
+    end
+
+    # Deactivate an event.
+    def delete_event(event_id)
+      do_delete("/api/v1/events/#{event_id}")
+    end
+
+    # ------------------------------------------------------------------
+    # Simulate
+    # ------------------------------------------------------------------
+
+    # Simulate sending an event (dry run).
+    def simulate_event(topic, payload)
+      post("/api/v1/simulate", { topic: topic, payload: payload })
+    end
+
+    # ------------------------------------------------------------------
+    # Webhooks
+    # ------------------------------------------------------------------
+
+    # Create a webhook.
+    def create_webhook(url:, **kwargs)
+      post("/api/v1/webhooks", { url: url, **kwargs })
+    end
+
+    # Get webhook details.
+    def get_webhook(webhook_id)
+      get("/api/v1/webhooks/#{webhook_id}")
+    end
+
+    # List webhooks.
+    def list_webhooks(limit: 50, cursor: nil)
+      get("/api/v1/webhooks", { limit: limit, cursor: cursor })
+    end
+
+    # Update a webhook.
+    def update_webhook(webhook_id, **kwargs)
+      patch("/api/v1/webhooks/#{webhook_id}", kwargs)
+    end
+
+    # Deactivate a webhook.
+    def delete_webhook(webhook_id)
+      do_delete("/api/v1/webhooks/#{webhook_id}")
+    end
+
+    # Get health status for a webhook.
+    def webhook_health(webhook_id)
+      get("/api/v1/webhooks/#{webhook_id}/health")
+    end
+
+    # List available webhook templates.
+    def webhook_templates
+      get("/api/v1/webhooks/templates")
+    end
+
+    # ------------------------------------------------------------------
+    # Deliveries
+    # ------------------------------------------------------------------
+
+    # List deliveries.
+    def list_deliveries(limit: 50, cursor: nil, **filters)
+      get("/api/v1/deliveries", { limit: limit, cursor: cursor, **filters })
+    end
+
+    # Retry a failed delivery.
+    def retry_delivery(delivery_id)
+      post("/api/v1/deliveries/#{delivery_id}/retry", {})
+    end
+
+    # ------------------------------------------------------------------
+    # Dead Letters
+    # ------------------------------------------------------------------
+
+    # List dead letters.
+    def list_dead_letters(limit: 50, cursor: nil)
+      get("/api/v1/dead-letters", { limit: limit, cursor: cursor })
+    end
+
+    # Get dead letter details.
+    def get_dead_letter(dead_letter_id)
+      get("/api/v1/dead-letters/#{dead_letter_id}")
+    end
+
+    # Retry a dead letter.
+    def retry_dead_letter(dead_letter_id)
+      post("/api/v1/dead-letters/#{dead_letter_id}/retry", {})
+    end
+
+    # Mark a dead letter as resolved.
+    def resolve_dead_letter(dead_letter_id)
+      patch("/api/v1/dead-letters/#{dead_letter_id}/resolve", {})
+    end
+
+    # ------------------------------------------------------------------
+    # Replays
+    # ------------------------------------------------------------------
+
+    # Start an event replay.
+    def create_replay(topic:, from_date:, to_date:, webhook_id: nil)
+      body = { topic: topic, from_date: from_date, to_date: to_date }
+      body[:webhook_id] = webhook_id unless webhook_id.nil?
+      post("/api/v1/replays", body)
+    end
+
+    # List replays.
+    def list_replays(limit: 50, cursor: nil)
+      get("/api/v1/replays", { limit: limit, cursor: cursor })
+    end
+
+    # Get replay details.
+    def get_replay(replay_id)
+      get("/api/v1/replays/#{replay_id}")
+    end
+
+    # Cancel a replay.
+    def cancel_replay(replay_id)
+      do_delete("/api/v1/replays/#{replay_id}")
+    end
+
+    # ------------------------------------------------------------------
+    # Jobs
+    # ------------------------------------------------------------------
+
+    # Create a scheduled job.
+    def create_job(name:, queue:, cron_expression:, **kwargs)
+      post("/api/v1/jobs", { name: name, queue: queue, cron_expression: cron_expression, **kwargs })
+    end
+
+    # List scheduled jobs.
+    def list_jobs(limit: 50, cursor: nil)
+      get("/api/v1/jobs", { limit: limit, cursor: cursor })
+    end
+
+    # Get job details.
+    def get_job(job_id)
+      get("/api/v1/jobs/#{job_id}")
+    end
+
+    # Update a scheduled job.
+    def update_job(job_id, **kwargs)
+      patch("/api/v1/jobs/#{job_id}", kwargs)
+    end
+
+    # Delete a scheduled job.
+    def delete_job(job_id)
+      do_delete("/api/v1/jobs/#{job_id}")
+    end
+
+    # List runs for a scheduled job.
+    def list_job_runs(job_id, limit: 50)
+      get("/api/v1/jobs/#{job_id}/runs", { limit: limit })
+    end
+
+    # Preview next occurrences for a cron expression.
+    def cron_preview(expression, count: 5)
+      get("/api/v1/jobs/cron-preview", { expression: expression, count: count })
+    end
+
+    # ------------------------------------------------------------------
+    # Pipelines
+    # ------------------------------------------------------------------
+
+    # Create an event pipeline.
+    def create_pipeline(name:, topics:, steps:, **kwargs)
+      post("/api/v1/pipelines", { name: name, topics: topics, steps: steps, **kwargs })
+    end
+
+    # List pipelines.
+    def list_pipelines(limit: 50, cursor: nil)
+      get("/api/v1/pipelines", { limit: limit, cursor: cursor })
+    end
+
+    # Get pipeline details.
+    def get_pipeline(pipeline_id)
+      get("/api/v1/pipelines/#{pipeline_id}")
+    end
+
+    # Update a pipeline.
+    def update_pipeline(pipeline_id, **kwargs)
+      patch("/api/v1/pipelines/#{pipeline_id}", kwargs)
+    end
+
+    # Delete a pipeline.
+    def delete_pipeline(pipeline_id)
+      do_delete("/api/v1/pipelines/#{pipeline_id}")
+    end
+
+    # Test a pipeline with a sample payload.
+    def test_pipeline(pipeline_id, payload)
+      post("/api/v1/pipelines/#{pipeline_id}/test", payload)
+    end
+
+    # ------------------------------------------------------------------
+    # Event Schemas
+    # ------------------------------------------------------------------
+
+    # Create an event schema.
+    def create_event_schema(topic:, schema:, **kwargs)
+      post("/api/v1/event-schemas", { topic: topic, schema: schema, **kwargs })
+    end
+
+    # List event schemas.
+    def list_event_schemas(limit: 50, cursor: nil)
+      get("/api/v1/event-schemas", { limit: limit, cursor: cursor })
+    end
+
+    # Get event schema details.
+    def get_event_schema(schema_id)
+      get("/api/v1/event-schemas/#{schema_id}")
+    end
+
+    # Update an event schema.
+    def update_event_schema(schema_id, **kwargs)
+      patch("/api/v1/event-schemas/#{schema_id}", kwargs)
+    end
+
+    # Delete an event schema.
+    def delete_event_schema(schema_id)
+      do_delete("/api/v1/event-schemas/#{schema_id}")
+    end
+
+    # Validate a payload against the schema for a topic.
+    def validate_payload(topic, payload)
+      post("/api/v1/event-schemas/validate", { topic: topic, payload: payload })
+    end
+
+    # ------------------------------------------------------------------
+    # Sandbox
+    # ------------------------------------------------------------------
+
+    # List sandbox endpoints.
+    def list_sandbox_endpoints
+      get("/api/v1/sandbox-endpoints")
+    end
+
+    # Create a sandbox endpoint.
+    def create_sandbox_endpoint(name: nil)
+      body = {}
+      body[:name] = name unless name.nil?
+      post("/api/v1/sandbox-endpoints", body)
+    end
+
+    # Delete a sandbox endpoint.
+    def delete_sandbox_endpoint(endpoint_id)
+      do_delete("/api/v1/sandbox-endpoints/#{endpoint_id}")
+    end
+
+    # List requests received by a sandbox endpoint.
+    def list_sandbox_requests(endpoint_id, limit: 50)
+      get("/api/v1/sandbox-endpoints/#{endpoint_id}/requests", { limit: limit })
+    end
+
+    # ------------------------------------------------------------------
+    # Analytics
+    # ------------------------------------------------------------------
+
+    # Get events per day for the last N days.
+    def events_per_day(days: 7)
+      get("/api/v1/analytics/events-per-day", { days: days })
+    end
+
+    # Get deliveries per day for the last N days.
+    def deliveries_per_day(days: 7)
+      get("/api/v1/analytics/deliveries-per-day", { days: days })
+    end
+
+    # Get top topics by event count.
+    def top_topics(limit: 10)
+      get("/api/v1/analytics/top-topics", { limit: limit })
+    end
+
+    # Get webhook delivery statistics.
+    def webhook_stats
+      get("/api/v1/analytics/webhook-stats")
+    end
+
+    # ------------------------------------------------------------------
+    # Project (single / current)
+    # ------------------------------------------------------------------
+
+    # Get current project details.
+    def get_project
+      get("/api/v1/project")
+    end
+
+    # Update current project.
+    def update_project(**kwargs)
+      patch("/api/v1/project", kwargs)
+    end
+
+    # List all topics in the current project.
+    def list_topics
+      get("/api/v1/topics")
+    end
+
+    # Get the current API token info.
+    def get_token
+      get("/api/v1/token")
+    end
+
+    # Regenerate the API token.
+    def regenerate_token
+      post("/api/v1/token/regenerate", {})
+    end
+
+    # ------------------------------------------------------------------
+    # Projects (multi)
+    # ------------------------------------------------------------------
+
+    # List all projects.
+    def list_projects
+      get("/api/v1/projects")
+    end
+
+    # Create a new project.
+    def create_project(name)
+      post("/api/v1/projects", { name: name })
+    end
+
+    # Get project by ID.
+    def get_project_by_id(project_id)
+      get("/api/v1/projects/#{project_id}")
+    end
+
+    # Update a project by ID.
+    def update_project_by_id(project_id, **kwargs)
+      patch("/api/v1/projects/#{project_id}", kwargs)
+    end
+
+    # Delete a project.
+    def delete_project(project_id)
+      do_delete("/api/v1/projects/#{project_id}")
+    end
+
+    # Set a project as the default.
+    def set_default_project(project_id)
+      patch("/api/v1/projects/#{project_id}/default", {})
+    end
+
+    # ------------------------------------------------------------------
+    # Teams
+    # ------------------------------------------------------------------
+
+    # List members of a project.
+    def list_members(project_id)
+      get("/api/v1/projects/#{project_id}/members")
+    end
+
+    # Add a member to a project.
+    def add_member(project_id, email:, role: "member")
+      post("/api/v1/projects/#{project_id}/members", { email: email, role: role })
+    end
+
+    # Update a member's role.
+    def update_member(project_id, member_id, role:)
+      patch("/api/v1/projects/#{project_id}/members/#{member_id}", { role: role })
+    end
+
+    # Remove a member from a project.
+    def remove_member(project_id, member_id)
+      do_delete("/api/v1/projects/#{project_id}/members/#{member_id}")
+    end
+
+    # ------------------------------------------------------------------
+    # Invitations
+    # ------------------------------------------------------------------
+
+    # List pending invitations for the current user.
+    def list_pending_invitations
+      get("/api/v1/invitations/pending")
+    end
+
+    # Accept an invitation.
+    def accept_invitation(invitation_id)
+      post("/api/v1/invitations/#{invitation_id}/accept", {})
+    end
+
+    # Reject an invitation.
+    def reject_invitation(invitation_id)
+      post("/api/v1/invitations/#{invitation_id}/reject", {})
+    end
+
+    # ------------------------------------------------------------------
+    # Audit
+    # ------------------------------------------------------------------
+
+    # List audit log entries.
+    def list_audit_logs(limit: 50, cursor: nil)
+      get("/api/v1/audit-log", { limit: limit, cursor: cursor })
+    end
+
+    # ------------------------------------------------------------------
+    # Export
+    # ------------------------------------------------------------------
+
+    # Export events as CSV or JSON. Returns raw string.
+    def export_events(format: "csv")
+      request_raw("GET", "/api/v1/export/events", params: { format: format })
+    end
+
+    # Export deliveries as CSV or JSON. Returns raw string.
+    def export_deliveries(format: "csv")
+      request_raw("GET", "/api/v1/export/deliveries", params: { format: format })
+    end
+
+    # Export jobs as CSV or JSON. Returns raw string.
+    def export_jobs(format: "csv")
+      request_raw("GET", "/api/v1/export/jobs", params: { format: format })
+    end
+
+    # Export audit log as CSV or JSON. Returns raw string.
+    def export_audit_log(format: "csv")
+      request_raw("GET", "/api/v1/export/audit-log", params: { format: format })
+    end
+
+    # ------------------------------------------------------------------
+    # GDPR
+    # ------------------------------------------------------------------
+
+    # Get current user consent status.
+    def get_consents
+      get("/api/v1/me/consents")
+    end
+
+    # Accept consent for a specific purpose.
+    def accept_consent(purpose)
+      post("/api/v1/me/consents/#{purpose}/accept", {})
+    end
+
+    # Export all personal data (GDPR data portability).
+    def export_my_data
+      get("/api/v1/me/data")
+    end
+
+    # Request restriction of data processing.
+    def restrict_processing
+      post("/api/v1/me/restrict", {})
+    end
+
+    # Lift restriction on data processing.
+    def lift_restriction
+      do_delete("/api/v1/me/restrict")
+    end
+
+    # Object to data processing.
+    def object_to_processing
+      post("/api/v1/me/object", {})
+    end
+
+    # Withdraw objection to data processing.
+    def restore_consent
+      do_delete("/api/v1/me/object")
+    end
+
+    # ------------------------------------------------------------------
+    # Health
+    # ------------------------------------------------------------------
+
+    # Check API health.
+    def health
+      get("/health")
+    end
+
+    # Get platform status page.
+    def status
+      get("/status")
+    end
+
+    private
+
+    # ------------------------------------------------------------------
+    # HTTP helpers
+    # ------------------------------------------------------------------
+
+    def get(path, params = nil)
+      request("GET", path, params: params)
+    end
+
+    def post(path, body)
+      request("POST", path, body: body)
+    end
+
+    def patch(path, body)
+      request("PATCH", path, body: body)
+    end
+
+    def do_delete(path)
+      request("DELETE", path)
+    end
+
+    def public_post(path, body)
+      uri = build_uri(path)
+      http = build_http(uri)
+
+      req = Net::HTTP::Post.new(uri)
+      req["Content-Type"] = "application/json"
+      req.body = JSON.generate(body)
+
+      resp = http.request(req)
+      handle_response(resp)
+    end
+
+    def request(method, path, params: nil, body: nil)
+      uri = build_uri(path, params)
+      http = build_http(uri)
+
+      req = build_request(method, uri)
+      req["Content-Type"] = "application/json"
+      req["X-Api-Key"] = @api_key
+      req["Authorization"] = "Bearer #{@auth_token}" if @auth_token
+      req.body = JSON.generate(body) if body
+
+      resp = http.request(req)
+      handle_response(resp)
+    end
+
+    def request_raw(method, path, params: nil)
+      uri = build_uri(path, params)
+      http = build_http(uri)
+
+      req = build_request(method, uri)
+      req["Content-Type"] = "application/json"
+      req["X-Api-Key"] = @api_key
+      req["Authorization"] = "Bearer #{@auth_token}" if @auth_token
+
+      resp = http.request(req)
+
+      unless resp.is_a?(Net::HTTPSuccess)
+        detail = begin
+                   parsed = JSON.parse(resp.body)
+                   parsed.is_a?(Hash) ? (parsed["error"] || parsed) : parsed
+                 rescue JSON::ParserError
+                   resp.body
+                 end
+        raise Jobcelis::Error.new(resp.code.to_i, detail)
+      end
+
+      resp.body
+    end
+
+    def build_uri(path, params = nil)
+      uri = URI("#{@base_url}#{path}")
+      if params
+        cleaned = params.reject { |_, v| v.nil? }
+        uri.query = URI.encode_www_form(cleaned) unless cleaned.empty?
+      end
+      uri
+    end
+
+    def build_http(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.open_timeout = @timeout
+      http.read_timeout = @timeout
+      http
+    end
+
+    def build_request(method, uri)
+      request_path = uri.request_uri
+      case method.upcase
+      when "GET"    then Net::HTTP::Get.new(request_path)
+      when "POST"   then Net::HTTP::Post.new(request_path)
+      when "PATCH"  then Net::HTTP::Patch.new(request_path)
+      when "DELETE" then Net::HTTP::Delete.new(request_path)
+      else raise ArgumentError, "Unsupported HTTP method: #{method}"
+      end
+    end
+
+    def handle_response(resp)
+      unless resp.is_a?(Net::HTTPSuccess)
+        detail = begin
+                   parsed = JSON.parse(resp.body)
+                   parsed.is_a?(Hash) ? (parsed["error"] || parsed) : parsed
+                 rescue JSON::ParserError
+                   resp.body
+                 end
+        raise Jobcelis::Error.new(resp.code.to_i, detail)
+      end
+
+      return nil if resp.code == "204"
+
+      JSON.parse(resp.body)
+    end
+  end
+end

data/lib/jobcelis/error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Jobcelis
+  class Error < StandardError
+    attr_reader :status, :detail
+
+    def initialize(status, detail)
+      @status = status
+      @detail = detail
+      super("HTTP #{status}: #{detail}")
+    end
+  end
+end

data/lib/jobcelis/webhook_verifier.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module Jobcelis
+  module WebhookVerifier
+    # Verify a webhook signature using HMAC-SHA256.
+    #
+    # @param secret    [String] The webhook signing secret.
+    # @param body      [String] The raw request body.
+    # @param signature [String] The signature from the X-Signature header.
+    # @return [Boolean] true if the signature is valid.
+    def self.verify(secret:, body:, signature:)
+      expected = OpenSSL::HMAC.hexdigest("SHA256", secret, body)
+      return false if signature.nil? || signature.empty?
+
+      OpenSSL.secure_compare(expected, signature)
+    end
+  end
+end

data/lib/jobcelis.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "jobcelis/error"
+require_relative "jobcelis/webhook_verifier"
+require_relative "jobcelis/client"
+
+module Jobcelis
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: jobcelis
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jobcelis
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby client for the Jobcelis API — events, webhooks, jobs, pipelines,
+  and more. Connects to https://jobcelis.com by default.
+email: vladiceli6@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/jobcelis.rb
+- lib/jobcelis/client.rb
+- lib/jobcelis/error.rb
+- lib/jobcelis/webhook_verifier.rb
+homepage: https://jobcelis.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://jobcelis.com
+  source_code_uri: https://github.com/vladimirCeli/jobcelis-ruby
+  documentation_uri: https://jobcelis.com/docs
+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: Official Ruby SDK for the Jobcelis Event Infrastructure Platform
+test_files: []