Go SDK API Reference

Complete API reference for the Kiket Go SDK.

SDK Initialization

kiket.New(config Config) (*SDK, error)

Creates a new SDK instance.

sdk, err := kiket.New(kiket.Config{
    WebhookSecret:    "hmac-secret",
    ExtensionAPIKey:  "api-key",
    WorkspaceToken:   "workspace-token",
    BaseURL:          "https://kiket.dev",
    ExtensionID:      "com.example.ext",
    ExtensionVersion: "1.0.0",
    Settings:         kiket.Settings{},
    ManifestPath:     "extension.yaml",
    AutoEnvSecrets:   true,
    TelemetryEnabled: true,
    TelemetryURL:     "https://kiket.dev/api/v1/ext/telemetry",
})

Handler Registration

sdk.On(event string, handler WebhookHandler, versions ...string)

Registers a webhook handler for an event.

sdk.On("issue.created", func(ctx context.Context, payload kiket.WebhookPayload, hctx *kiket.HandlerContext) (interface{}, error) {
    // Handle event
    return nil, nil
})

// With specific version
sdk.On("issue.created", handler, "v2")

Handler Context

The HandlerContext provides access to SDK features within a handler:

type HandlerContext struct {
    Event            string            // Event name
    EventVersion     string            // Event version
    Headers          Headers           // Request headers
    Client           Client            // HTTP client
    Endpoints        *Endpoints        // Extension endpoints
    Settings         Settings          // Extension settings
    ExtensionID      string            // Extension ID
    ExtensionVersion string            // Extension version
    Secrets          SecretManager     // Secret manager
}

Secret Manager

Secrets.Get(ctx, key) (string, error)

Retrieves a secret value. Returns empty string if not found.

value, err := hctx.Secrets.Get(ctx, "api_token")

Secrets.Set(ctx, key, value) error

Creates or updates a secret.

err := hctx.Secrets.Set(ctx, "api_token", "new-value")

Secrets.Delete(ctx, key) error

Deletes a secret.

err := hctx.Secrets.Delete(ctx, "api_token")

Secrets.List(ctx) ([]string, error)

Lists all secret keys.

keys, err := hctx.Secrets.List(ctx)

Secrets.Rotate(ctx, key, newValue) error

Rotates a secret (deletes old, sets new).

err := hctx.Secrets.Rotate(ctx, "api_token", "rotated-value")

Custom Data Client

Access via hctx.Endpoints.CustomData(projectID).

List(ctx, moduleKey, table, opts) (*CustomDataListResponse, error)

Lists records from a custom data table.

client := hctx.Endpoints.CustomData(projectID)
records, err := client.List(ctx, "my-module", "my-table", &kiket.CustomDataListOptions{
    Limit: 100,
    Filters: map[string]interface{}{
        "status": "active",
    },
})

Get(ctx, moduleKey, table, recordID) (*CustomDataRecordResponse, error)

Retrieves a single record.

record, err := client.Get(ctx, "my-module", "my-table", 123)

Create(ctx, moduleKey, table, record) (*CustomDataRecordResponse, error)

Creates a new record.

record, err := client.Create(ctx, "my-module", "my-table", map[string]interface{}{
    "name":  "Test",
    "value": 42,
})

Update(ctx, moduleKey, table, recordID, record) (*CustomDataRecordResponse, error)

Updates an existing record.

record, err := client.Update(ctx, "my-module", "my-table", 123, map[string]interface{}{
    "value": 100,
})

Delete(ctx, moduleKey, table, recordID) error

Deletes a record.

err := client.Delete(ctx, "my-module", "my-table", 123)

SLA Events Client

Access via hctx.Endpoints.SLAEvents(projectID).

List(ctx, opts) (*SLAEventsListResponse, error)

Lists SLA events.

client := hctx.Endpoints.SLAEvents(projectID)
events, err := client.List(ctx, &kiket.SLAEventsListOptions{
    IssueID: 123,           // Optional: filter by issue
    State:   "breached",    // Optional: "imminent", "breached", "recovered"
    Limit:   50,            // Optional: max records
})

Rate Limit

Endpoints.RateLimit(ctx) (*RateLimitInfo, error)

Returns current rate limit status.

info, err := hctx.Endpoints.RateLimit(ctx)
// info.Limit, info.Remaining, info.WindowSeconds, info.ResetIn

Authentication

kiket.VerifySignature(secret, body, headers) error

Verifies webhook signature manually.

err := kiket.VerifySignature(secret, body, headers)
if kiket.IsAuthenticationError(err) {
    // Invalid signature
}

kiket.GenerateSignature(secret, body, timestamp) (signature, ts string)

Generates a signature for testing.

sig, ts := kiket.GenerateSignature(secret, body, nil)

HTTP Handler

The SDK implements http.Handler:

http.Handle("/webhook", sdk)

Or handle manually:

result, err := sdk.HandleWebhook(ctx, body, headers)

Types

WebhookPayload

type WebhookPayload map[string]interface{}

Headers

type Headers map[string]string

Settings

type Settings map[string]interface{}

RateLimitInfo

type RateLimitInfo struct {
    Limit         int
    Remaining     int
    WindowSeconds int
    ResetIn       int
}

SLAEventRecord

type SLAEventRecord struct {
    ID          interface{}
    IssueID     interface{}
    ProjectID   interface{}
    State       string
    TriggeredAt string
    ResolvedAt  *string
    Definition  map[string]interface{}
    Metrics     map[string]interface{}
}