@intelmesh/sdk 0.1.0

package/src/resources/lists.ts

@@ -0,0 +1,91 @@
+// ---------------------------------------------------------------------------
+// Lists resource — CRUD + items
+// ---------------------------------------------------------------------------
+
+import type { HttpClient } from '../client/http.js';
+import type {
+  AddItemsRequest,
+  BulkImportRequest,
+  CreateListRequest,
+  List,
+  PaginatedResponse,
+  PaginationParams,
+  UpdateListRequest,
+} from '../types.js';
+
+/**
+ * Resource for named list management (blocklists, allowlists, etc.).
+ */
+export class Lists {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  /**
+   * Lists all named lists with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of named lists.
+   */
+  async list(params: PaginationParams = {}): Promise<PaginatedResponse<List>> {
+    return this.http.get<PaginatedResponse<List>>('/api/v1/lists', {
+      cursor: params.cursor,
+      limit: params.limit,
+    });
+  }
+
+  /**
+   * Retrieves a single list by ID.
+   * @param id - The list ID.
+   * @returns The list.
+   */
+  async get(id: string): Promise<List> {
+    return this.http.get<List>(`/api/v1/lists/${id}`);
+  }
+
+  /**
+   * Creates a new named list.
+   * @param request - The list creation payload.
+   * @returns The created list.
+   */
+  async create(request: CreateListRequest): Promise<List> {
+    return this.http.post<List>('/api/v1/lists', request);
+  }
+
+  /**
+   * Updates an existing list by ID.
+   * @param id - The list ID.
+   * @param request - The update payload.
+   * @returns The updated list.
+   */
+  async update(id: string, request: UpdateListRequest): Promise<List> {
+    return this.http.put<List>(`/api/v1/lists/${id}`, request);
+  }
+
+  /**
+   * Deletes a list by ID.
+   * @param id - The list ID.
+   */
+  async delete(id: string): Promise<void> {
+    await this.http.delete<unknown>(`/api/v1/lists/${id}`);
+  }
+
+  /**
+   * Adds items to a list.
+   * @param listId - The list ID.
+   * @param request - The items to add.
+   */
+  async addItems(listId: string, request: AddItemsRequest): Promise<void> {
+    await this.http.post<unknown>(`/api/v1/lists/${listId}/items`, request);
+  }
+
+  /**
+   * Bulk-imports items into a list, replacing existing items.
+   * @param listId - The list ID.
+   * @param request - The items to import.
+   */
+  async bulkImport(listId: string, request: BulkImportRequest): Promise<void> {
+    await this.http.post<unknown>(`/api/v1/lists/${listId}/import`, request);
+  }
+}

package/src/resources/phases.ts

@@ -0,0 +1,71 @@
+// ---------------------------------------------------------------------------
+// Phases resource — CRUD
+// ---------------------------------------------------------------------------
+
+import type { HttpClient } from '../client/http.js';
+import type {
+  CreatePhaseRequest,
+  PaginatedResponse,
+  PaginationParams,
+  Phase,
+  UpdatePhaseRequest,
+} from '../types.js';
+
+/**
+ * Resource for pipeline phase management.
+ */
+export class Phases {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  /**
+   * Lists all phases with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of phases.
+   */
+  async list(params: PaginationParams = {}): Promise<PaginatedResponse<Phase>> {
+    return this.http.get<PaginatedResponse<Phase>>('/api/v1/phases', {
+      cursor: params.cursor,
+      limit: params.limit,
+    });
+  }
+
+  /**
+   * Retrieves a single phase by ID.
+   * @param id - The phase ID.
+   * @returns The phase.
+   */
+  async get(id: string): Promise<Phase> {
+    return this.http.get<Phase>(`/api/v1/phases/${id}`);
+  }
+
+  /**
+   * Creates a new phase.
+   * @param request - The phase creation payload.
+   * @returns The created phase.
+   */
+  async create(request: CreatePhaseRequest): Promise<Phase> {
+    return this.http.post<Phase>('/api/v1/phases', request);
+  }
+
+  /**
+   * Updates an existing phase by ID.
+   * @param id - The phase ID.
+   * @param request - The update payload.
+   * @returns The updated phase.
+   */
+  async update(id: string, request: UpdatePhaseRequest): Promise<Phase> {
+    return this.http.put<Phase>(`/api/v1/phases/${id}`, request);
+  }
+
+  /**
+   * Deletes a phase by ID.
+   * @param id - The phase ID.
+   */
+  async delete(id: string): Promise<void> {
+    await this.http.delete<unknown>(`/api/v1/phases/${id}`);
+  }
+}

package/src/resources/rules.ts

@@ -0,0 +1,98 @@
+// ---------------------------------------------------------------------------
+// Rules resource — CRUD + versions
+// ---------------------------------------------------------------------------
+
+import type { HttpClient } from '../client/http.js';
+import type {
+  CreateRuleRequest,
+  PaginatedResponse,
+  PaginationParams,
+  Rule,
+  RuleVersion,
+  UpdateRuleRequest,
+} from '../types.js';
+
+/**
+ * Resource for rule management operations.
+ */
+export class Rules {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  /**
+   * Lists all rules with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of rules.
+   */
+  async list(params: PaginationParams = {}): Promise<PaginatedResponse<Rule>> {
+    return this.http.get<PaginatedResponse<Rule>>('/api/v1/rules', {
+      cursor: params.cursor,
+      limit: params.limit,
+    });
+  }
+
+  /**
+   * Retrieves a single rule by ID.
+   * @param id - The rule ID.
+   * @returns The rule.
+   */
+  async get(id: string): Promise<Rule> {
+    return this.http.get<Rule>(`/api/v1/rules/${id}`);
+  }
+
+  /**
+   * Creates a new rule.
+   * @param request - The rule creation payload.
+   * @returns The created rule.
+   */
+  async create(request: CreateRuleRequest): Promise<Rule> {
+    return this.http.post<Rule>('/api/v1/rules', request);
+  }
+
+  /**
+   * Updates an existing rule by ID.
+   * @param id - The rule ID.
+   * @param request - The update payload.
+   * @returns The updated rule.
+   */
+  async update(id: string, request: UpdateRuleRequest): Promise<Rule> {
+    return this.http.put<Rule>(`/api/v1/rules/${id}`, request);
+  }
+
+  /**
+   * Deletes a rule by ID.
+   * @param id - The rule ID.
+   */
+  async delete(id: string): Promise<void> {
+    await this.http.delete<unknown>(`/api/v1/rules/${id}`);
+  }
+
+  /**
+   * Lists all versions of a rule.
+   * @param ruleId - The rule ID.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of rule versions.
+   */
+  async listVersions(
+    ruleId: string,
+    params: PaginationParams = {},
+  ): Promise<PaginatedResponse<RuleVersion>> {
+    return this.http.get<PaginatedResponse<RuleVersion>>(
+      `/api/v1/rules/${ruleId}/versions`,
+      { cursor: params.cursor, limit: params.limit },
+    );
+  }
+
+  /**
+   * Retrieves a specific version of a rule.
+   * @param ruleId - The rule ID.
+   * @param versionId - The version ID.
+   * @returns The rule version.
+   */
+  async getVersion(ruleId: string, versionId: string): Promise<RuleVersion> {
+    return this.http.get<RuleVersion>(`/api/v1/rules/${ruleId}/versions/${versionId}`);
+  }
+}

package/src/resources/scopes.ts

@@ -0,0 +1,71 @@
+// ---------------------------------------------------------------------------
+// Scopes resource — CRUD
+// ---------------------------------------------------------------------------
+
+import type { HttpClient } from '../client/http.js';
+import type {
+  CreateScopeRequest,
+  PaginatedResponse,
+  PaginationParams,
+  Scope,
+  UpdateScopeRequest,
+} from '../types.js';
+
+/**
+ * Resource for scope management.
+ */
+export class Scopes {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  /**
+   * Lists all scopes with cursor-based pagination.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of scopes.
+   */
+  async list(params: PaginationParams = {}): Promise<PaginatedResponse<Scope>> {
+    return this.http.get<PaginatedResponse<Scope>>('/api/v1/scopes', {
+      cursor: params.cursor,
+      limit: params.limit,
+    });
+  }
+
+  /**
+   * Retrieves a single scope by ID.
+   * @param id - The scope ID.
+   * @returns The scope.
+   */
+  async get(id: string): Promise<Scope> {
+    return this.http.get<Scope>(`/api/v1/scopes/${id}`);
+  }
+
+  /**
+   * Creates a new scope.
+   * @param request - The scope creation payload.
+   * @returns The created scope.
+   */
+  async create(request: CreateScopeRequest): Promise<Scope> {
+    return this.http.post<Scope>('/api/v1/scopes', request);
+  }
+
+  /**
+   * Updates an existing scope by ID.
+   * @param id - The scope ID.
+   * @param request - The update payload.
+   * @returns The updated scope.
+   */
+  async update(id: string, request: UpdateScopeRequest): Promise<Scope> {
+    return this.http.put<Scope>(`/api/v1/scopes/${id}`, request);
+  }
+
+  /**
+   * Deletes a scope by ID.
+   * @param id - The scope ID.
+   */
+  async delete(id: string): Promise<void> {
+    await this.http.delete<unknown>(`/api/v1/scopes/${id}`);
+  }
+}

package/src/resources/scores.ts

@@ -0,0 +1,63 @@
+// ---------------------------------------------------------------------------
+// Scores resource — get, list, set, reset
+// ---------------------------------------------------------------------------
+
+import type { HttpClient } from '../client/http.js';
+import type { PaginatedResponse, PaginationParams, Score, SetScoreRequest } from '../types.js';
+
+/**
+ * Resource for score management.
+ */
+export class Scores {
+  private readonly http: HttpClient;
+
+  constructor(http: HttpClient) {
+    this.http = http;
+  }
+
+  /**
+   * Retrieves a score for a specific scope name and value.
+   * @param scopeName - The scope name (e.g. "customer_id").
+   * @param scopeValue - The scope value (e.g. "12345678900").
+   * @returns The score entry.
+   */
+  async get(scopeName: string, scopeValue: string): Promise<Score> {
+    return this.http.get<Score>(`/api/v1/scores/${scopeName}/${scopeValue}`);
+  }
+
+  /**
+   * Lists scores for a scope name with cursor-based pagination.
+   * @param scopeName - The scope name.
+   * @param params - Optional pagination parameters.
+   * @returns A paginated list of scores.
+   */
+  async list(
+    scopeName: string,
+    params: PaginationParams = {},
+  ): Promise<PaginatedResponse<Score>> {
+    return this.http.get<PaginatedResponse<Score>>(`/api/v1/scores/${scopeName}`, {
+      cursor: params.cursor,
+      limit: params.limit,
+    });
+  }
+
+  /**
+   * Sets a score for a specific scope name and value.
+   * @param scopeName - The scope name.
+   * @param scopeValue - The scope value.
+   * @param request - The score value to set.
+   * @returns The updated score.
+   */
+  async set(scopeName: string, scopeValue: string, request: SetScoreRequest): Promise<Score> {
+    return this.http.put<Score>(`/api/v1/scores/${scopeName}/${scopeValue}`, request);
+  }
+
+  /**
+   * Resets a score to zero for a specific scope name and value.
+   * @param scopeName - The scope name.
+   * @param scopeValue - The scope value.
+   */
+  async reset(scopeName: string, scopeValue: string): Promise<void> {
+    await this.http.delete<unknown>(`/api/v1/scores/${scopeName}/${scopeValue}`);
+  }
+}

package/src/testkit/assertion.ts

@@ -0,0 +1,76 @@
+// ---------------------------------------------------------------------------
+// EventAssertion — chainable assertions on IngestResult
+// Mirrors the Go SDK's testkit.EventAssertion.
+// ---------------------------------------------------------------------------
+
+import type { IngestResult } from '../types.js';
+
+/**
+ * Chains assertions on the result of an event send.
+ * Throws on assertion failure (suitable for test frameworks).
+ */
+export class EventAssertion {
+  private readonly result: IngestResult;
+
+  constructor(result: IngestResult) {
+    this.result = result;
+  }
+
+  /**
+   * Asserts the result has a specific decision action and severity.
+   * @param action - The expected action string (e.g. "block").
+   * @param severity - The expected severity level.
+   * @returns This assertion for chaining.
+   * @throws {Error} If the decision does not match.
+   */
+  expectDecision(action: string, severity: string): this {
+    const decision = this.result.decision;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive runtime guard: API may return unexpected shapes despite type definition
+    if (!decision) {
+      throw new Error(`testkit: expected decision ${action}/${severity}, got no decision`);
+    }
+    if (decision.action !== action) {
+      throw new Error(`testkit: decision action: got "${decision.action}", want "${action}"`);
+    }
+    if (decision.severity !== severity) {
+      throw new Error(`testkit: decision severity: got "${decision.severity}", want "${severity}"`);
+    }
+    return this;
+  }
+
+  /**
+   * Asserts the result has no decision (action is empty or undefined).
+   * @returns This assertion for chaining.
+   * @throws {Error} If a decision is present.
+   */
+  expectNoDecision(): this {
+    const decision = this.result.decision;
+    if (decision.action !== '') {
+      throw new Error(`testkit: expected no decision, got ${decision.action}/${decision.severity}`);
+    }
+    return this;
+  }
+
+  /**
+   * Asserts the transient score equals the expected value.
+   * @param score - The expected score value.
+   * @returns This assertion for chaining.
+   * @throws {Error} If the score does not match.
+   */
+  expectScore(score: number): this {
+    if (this.result.transient_score !== score) {
+      throw new Error(
+        `testkit: score: got ${String(this.result.transient_score)}, want ${String(score)}`,
+      );
+    }
+    return this;
+  }
+
+  /**
+   * Returns the underlying IngestResult for custom assertions.
+   * @returns The raw IngestResult.
+   */
+  raw(): IngestResult {
+    return this.result;
+  }
+}