@griffin-app/griffin-ts 0.1.7 → 0.1.9

package/ASSERTIONS_QUICK_REF.md

@@ -8,13 +8,16 @@
 ])
 ```
 
-## Accessors
+## Accessors (Subjects)
 
 | Accessor   | Description          | Example                                 |
 | ---------- | -------------------- | --------------------------------------- |
-| `.body`    | Response body (JSON) | `state["node"].body["data"]["id"]`      |
+| `.body`    | Response body        | `state["node"].body["data"]["id"]`      |
 | `.headers` | Response headers     | `state["node"].headers["content-type"]` |
 | `.status`  | HTTP status code     | `state["node"].status`                  |
+| `.latency` | Request latency (ms) | `state["node"].latency`                 |
+
+**Note:** For body assertions, the response type is automatically detected and defaults to JSON. Path traversal uses JSONPath for JSON responses.
 
 ## Array Access
 
@@ -75,6 +78,14 @@ Assert(state["node"].status).lessThan(400); // Any success
 Assert(state["node"].status).not.equals(500); // Not server error
 ```
 
+### Latency Checks
+
+```typescript
+Assert(state["node"].latency).lessThan(500); // Response time under 500ms
+Assert(state["node"].latency).lessThanOrEqual(1000); // Max 1 second
+Assert(state["node"].latency).greaterThan(0); // Sanity check
+```
+
 ### Existence Checks
 
 ```typescript
@@ -151,6 +162,7 @@ TypeScript provides autocomplete and errors:
 | Task              | Code                                                     |
 | ----------------- | -------------------------------------------------------- |
 | Status is 200     | `Assert(state["n"].status).equals(200)`                  |
+| Latency < 500ms   | `Assert(state["n"].latency).lessThan(500)`               |
 | Body field exists | `Assert(state["n"].body["x"]).not.isNull()`              |
 | String contains   | `Assert(state["n"].body["msg"]).contains("ok")`          |
 | Number in range   | `Assert(state["n"].body["age"]).greaterThanOrEqual(18)`  |

package/README.md

@@ -36,27 +36,27 @@ griffin provides two builder APIs:
 The sequential builder automatically connects steps in order - no need to manage edges manually.
 
 ```typescript
-import { GET, createTestBuilder, JSON, Frequency } from "griffin-ts";
+import { GET, createTestBuilder, JSON, Frequency, Assert } from "griffin-ts";
 
 const plan = createTestBuilder({
   name: "health-check",
-  frequency: Frequency.every(1).minute(),
+  endpoint_host: "https://api.example.com",
 })
-  .request({
+  .endpoint("health", {
     method: GET,
     response_format: JSON,
     path: "/health",
   })
-  .assert([
-    { type: "status", expected: 200 },
-    { type: "body", expected: { status: "ok" } },
+  .assert((state) => [
+    Assert(state["health"].status).equals(200),
+    Assert(state["health"].body["status"]).equals("ok"),
   ])
-  .build();
+  .build({ frequency: Frequency.every(1).minute() });
 
 export default plan;
 ```
 
-#### Sequential Example with Waits
+#### Sequential Example with Waits and Assertions
 
 ```typescript
 import {
@@ -66,30 +66,35 @@ import {
   JSON,
   Frequency,
   Wait,
+  Assert,
 } from "griffin-ts";
 
 const plan = createTestBuilder({
   name: "create-and-verify-user",
-  frequency: Frequency.every(5).minute(),
+  endpoint_host: "https://api.example.com",
 })
-  .request({
+  .endpoint("create_user", {
     method: POST,
     response_format: JSON,
     path: "/api/v1/users",
     body: { name: "Test User", email: "test@example.com" },
   })
-  .assert([{ type: "status", expected: 201 }])
+  .assert((state) => [
+    Assert(state["create_user"].status).equals(201),
+    Assert(state["create_user"].body["id"]).not.isNull(),
+  ])
   .wait(Wait.seconds(2))
-  .request({
+  .endpoint("get_user", {
     method: GET,
     response_format: JSON,
     path: "/api/v1/users/test@example.com",
   })
-  .assert([
-    { type: "status", expected: 200 },
-    { type: "body.name", expected: "Test User" },
+  .assert((state) => [
+    Assert(state["get_user"].status).equals(200),
+    Assert(state["get_user"].body["name"]).equals("Test User"),
+    Assert(state["get_user"].latency).lessThan(500),
   ])
-  .build();
+  .build({ frequency: Frequency.every(5).minute() });
 
 export default plan;
 ```
@@ -103,45 +108,41 @@ import {
   GET,
   POST,
   createGraphBuilder,
-  Endpoint,
-  Assertion,
-  WaitNode,
   JSON,
   START,
   END,
   Frequency,
   Wait,
+  Assert,
 } from "griffin-ts";
 
 const plan = createGraphBuilder({
   name: "foo-bar-check",
-  frequency: Frequency.every(1).minute(),
+  endpoint_host: "https://api.example.com",
 })
-  .addNode(
-    "create_foo",
-    Endpoint({
-      method: POST,
-      response_format: JSON,
-      path: "/api/v1/foo",
-      body: { name: "test", value: 42 },
-    }),
-  )
-  .addNode(
-    "get_foo",
-    Endpoint({
-      method: GET,
-      response_format: JSON,
-      path: "/api/v1/foo/1",
-    }),
-  )
-  .addNode("wait_between", WaitNode(Wait.seconds(2)))
-  .addNode("check_status", Assertion([{ type: "status", expected: 200 }]))
+  .addHttpRequest("create_foo", {
+    method: POST,
+    response_format: JSON,
+    path: "/api/v1/foo",
+    body: { name: "test", value: 42 },
+  })
+  .addWait("wait_between", Wait.seconds(2))
+  .addHttpRequest("get_foo", {
+    method: GET,
+    response_format: JSON,
+    path: "/api/v1/foo/1",
+  })
+  .addAssertion("check_response", (state) => [
+    Assert(state["get_foo"].status).equals(200),
+    Assert(state["get_foo"].body["value"]).equals(42),
+    Assert(state["get_foo"].latency).lessThan(1000),
+  ])
   .addEdge(START, "create_foo")
   .addEdge("create_foo", "wait_between")
   .addEdge("wait_between", "get_foo")
-  .addEdge("get_foo", "check_status")
-  .addEdge("check_status", END)
-  .build();
+  .addEdge("get_foo", "check_response")
+  .addEdge("check_response", END)
+  .build({ frequency: Frequency.every(1).minute() });
 
 export default plan;
 ```
@@ -153,13 +154,20 @@ griffin supports secure secret management for API keys, tokens, and other creden
 #### With Sequential Builder
 
 ```typescript
-import { GET, createTestBuilder, JSON, Frequency, secret } from "griffin-ts";
+import {
+  GET,
+  createTestBuilder,
+  JSON,
+  Frequency,
+  secret,
+  Assert,
+} from "griffin-ts";
 
 const plan = createTestBuilder({
   name: "authenticated-check",
-  frequency: Frequency.every(5).minute(),
+  endpoint_host: "https://api.example.com",
 })
-  .request({
+  .endpoint("protected", {
     method: GET,
     response_format: JSON,
     path: "/api/protected",
@@ -176,8 +184,8 @@ const plan = createTestBuilder({
       apiKey: secret("env:API_KEY"),
     },
   })
-  .assert([{ type: "status", expected: 200 }])
-  .build();
+  .assert((state) => [Assert(state["protected"].status).equals(200)])
+  .build({ frequency: Frequency.every(5).minute() });
 
 export default plan;
 ```
@@ -188,36 +196,34 @@ export default plan;
 import {
   GET,
   createGraphBuilder,
-  Endpoint,
-  Assertion,
   JSON,
   START,
   END,
   Frequency,
   secret,
+  Assert,
 } from "griffin-ts";
 
 const plan = createGraphBuilder({
   name: "authenticated-check",
-  frequency: Frequency.every(5).minute(),
+  endpoint_host: "https://api.example.com",
 })
-  .addNode(
-    "authenticated_request",
-    Endpoint({
-      method: GET,
-      response_format: JSON,
-      path: "/api/protected",
-      headers: {
-        "X-API-Key": secret("env:API_KEY"),
-        Authorization: secret("aws:prod/api-token"),
-      },
-    }),
-  )
-  .addNode("verify", Assertion([{ type: "status", expected: 200 }]))
+  .addHttpRequest("authenticated_request", {
+    method: GET,
+    response_format: JSON,
+    path: "/api/protected",
+    headers: {
+      "X-API-Key": secret("env:API_KEY"),
+      Authorization: secret("aws:prod/api-token"),
+    },
+  })
+  .addAssertion("verify", (state) => [
+    Assert(state["authenticated_request"].status).equals(200),
+  ])
   .addEdge(START, "authenticated_request")
   .addEdge("authenticated_request", "verify")
   .addEdge("verify", END)
-  .build();
+  .build({ frequency: Frequency.every(5).minute() });
 
 export default plan;
 ```
@@ -252,22 +258,47 @@ See the [griffin-runner CONFIG.md](../griffin-runner/CONFIG.md) for configuratio
 
 #### Sequential Builder Methods
 
-- **`.request(config)`**: Add an HTTP endpoint request
-- **`.wait(duration)`**: Add a delay (use `Wait.seconds(n)` or `Wait.minutes(n)`)
-- **`.assert(assertions)`**: Add assertions to validate responses
-- **`.build()`**: Generate the final test plan
+- **`.endpoint(id, config)`**: Add an HTTP endpoint request with a unique identifier
+- **`.wait(duration)`**: Add a delay (use `Wait.seconds(n)`, `Wait.minutes(n)`, or `Wait.milliseconds(n)`)
+- **`.assert(fn)`**: Add assertions using a function that receives the state proxy and returns an array of assertions
+- **`.build(options)`**: Generate the final test plan with frequency configuration
 
 #### Graph Builder Methods
 
-- **`.addNode(name, node)`**: Add a node to the graph using `Endpoint()`, `WaitNode()`, or `Assertion()`
+- **`.addHttpRequest(id, config)`**: Add an endpoint node to the graph
+- **`.addWait(id, duration)`**: Add a wait node to the graph
+- **`.addAssertion(id, fn)`**: Add an assertion node using a function that receives the state proxy
 - **`.addEdge(from, to)`**: Connect two nodes (use `START` and `END` constants for entry/exit)
-- **`.build()`**: Generate the final test plan (validates all nodes are connected)
+- **`.build(options)`**: Generate the final test plan (validates all nodes are connected)
+
+#### Assertions
+
+Use the `Assert()` function with the state proxy to create type-safe assertions:
+
+```typescript
+.assert((state) => [
+  // Status checks
+  Assert(state["node"].status).equals(200),
+
+  // Latency checks
+  Assert(state["node"].latency).lessThan(500),
+
+  // Body assertions (JSONPath automatically detected)
+  Assert(state["node"].body["id"]).not.isNull(),
+  Assert(state["node"].body["name"]).equals("test"),
+
+  // Header assertions
+  Assert(state["node"].headers["content-type"]).contains("json"),
+])
+```
+
+See [ASSERTIONS_QUICK_REF.md](./ASSERTIONS_QUICK_REF.md) for the complete assertion API.
 
 #### General
 
-- **Frequency**: Use `Frequency.every(n).minute()`, `.hour()`, or `.day()` (note the parentheses)
+- **Frequency**: Use `Frequency.every(n).minute()`, `.hour()`, or `.day()` in the `build()` options
 - **Secrets**: Use `secret("provider:path")` to reference secrets that are resolved at runtime
-- **Assertions**: Currently in development - assertion functions are stored but not yet evaluated during execution
+- **Response Types**: JSON (default), XML, and TEXT response formats are supported
 
 ## Output
 

package/dist/assertions.d.ts

@@ -6,82 +6,107 @@
  * - Assert: Builder for creating assertions with fluent API
  * - Support for unary and binary predicates with negation
  */
+import { type Assertion, AssertionSubject, ResponseFormat } from "./schema.js";
 /**
- * Identifies which node and which part of its result we're asserting on
+ * Descriptor for body assertions - supports nested JSONPath access
  */
-export interface PathDescriptor {
+export interface BodyDescriptor {
     nodeId: string;
-    accessor: "body" | "headers" | "status";
+    subject: AssertionSubject.BODY;
     path: string[];
+    responseType: ResponseFormat;
 }
 /**
- * Unary predicates that check a property without comparing to a value
+ * Descriptor for header assertions - single header name, no nesting
  */
-export declare enum UnaryPredicate {
-    IS_NULL = "IS_NULL",
-    IS_NOT_NULL = "IS_NOT_NULL",
-    IS_TRUE = "IS_TRUE",
-    IS_FALSE = "IS_FALSE",
-    IS_EMPTY = "IS_EMPTY",
-    IS_NOT_EMPTY = "IS_NOT_EMPTY"
+export interface HeaderDescriptor {
+    nodeId: string;
+    subject: AssertionSubject.HEADERS;
+    headerName: string;
 }
 /**
- * Binary predicate operators that compare against an expected value
- */
-export declare enum BinaryPredicateOperator {
-    EQUAL = "EQUAL",
-    NOT_EQUAL = "NOT_EQUAL",
-    GREATER_THAN = "GREATER_THAN",
-    LESS_THAN = "LESS_THAN",
-    GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL",
-    LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL",
-    CONTAINS = "CONTAINS",
-    NOT_CONTAINS = "NOT_CONTAINS",
-    STARTS_WITH = "STARTS_WITH",
-    NOT_STARTS_WITH = "NOT_STARTS_WITH",
-    ENDS_WITH = "ENDS_WITH",
-    NOT_ENDS_WITH = "NOT_ENDS_WITH"
+ * Descriptor for status assertions - no path needed
+ */
+export interface StatusDescriptor {
+    nodeId: string;
+    subject: AssertionSubject.STATUS;
+}
+/**
+ * Descriptor for latency assertions - no path needed
+ */
+export interface LatencyDescriptor {
+    nodeId: string;
+    subject: AssertionSubject.LATENCY;
 }
+/**
+ * Union of all assertion descriptors
+ */
+export type AssertionDescriptor = BodyDescriptor | HeaderDescriptor | StatusDescriptor | LatencyDescriptor;
 /**
  * Binary predicate with operator and expected value
  */
-export interface BinaryPredicate {
-    operator: BinaryPredicateOperator;
-    expected: unknown;
+/**
+ * Symbol used to store descriptor metadata in proxy objects
+ */
+declare const DESCRIPTOR_SYMBOL: unique symbol;
+/**
+ * Internal interface for proxy objects that carry a body descriptor
+ */
+interface ProxyWithBodyDescriptor {
+    [DESCRIPTOR_SYMBOL]: BodyDescriptor;
 }
 /**
- * Serialized assertion ready for execution
+ * Internal interface for proxy objects that carry a header descriptor
  */
-export interface SerializedAssertion {
-    nodeId: string;
-    accessor: "body" | "headers" | "status";
-    path: string[];
-    predicate: UnaryPredicate | BinaryPredicate;
+interface ProxyWithHeaderDescriptor {
+    [DESCRIPTOR_SYMBOL]: HeaderDescriptor;
 }
 /**
- * Symbol used to store path metadata in proxy objects
+ * Internal interface for proxy objects that carry a status descriptor
  */
-declare const PATH_SYMBOL: unique symbol;
+interface ProxyWithStatusDescriptor {
+    [DESCRIPTOR_SYMBOL]: StatusDescriptor;
+}
 /**
- * Internal interface for proxy objects that carry path information
+ * Internal interface for proxy objects that carry a latency descriptor
  */
-interface ProxyWithPath {
-    [PATH_SYMBOL]: PathDescriptor;
+interface ProxyWithLatencyDescriptor {
+    [DESCRIPTOR_SYMBOL]: LatencyDescriptor;
 }
 /**
- * Proxy for accessing nested properties within a node result accessor (body, headers, status)
- * Note: The 'at' method is available at runtime but typed as NestedProxy for simplicity
+ * Proxy for accessing nested properties within a body.
+ * Supports arbitrary depth: body["data"]["users"][0]["name"]
+ */
+export type BodyProxy = ProxyWithBodyDescriptor & {
+    [key: string]: BodyProxy;
+};
+/**
+ * Terminal proxy for a single header value. No further nesting allowed.
+ */
+export type HeaderValueProxy = ProxyWithHeaderDescriptor;
+/**
+ * Proxy for accessing header values. Only allows one level of access.
+ * e.g., headers["content-type"] returns a HeaderValueProxy
  */
-export type NestedProxy = ProxyWithPath & {
-    [key: string]: NestedProxy;
+export type HeadersProxy = {
+    [key: string]: HeaderValueProxy;
 };
 /**
- * Proxy for a node result with body, headers, and status accessors
+ * Terminal proxy for status. No further nesting allowed.
+ */
+export type StatusProxy = ProxyWithStatusDescriptor;
+/**
+ * Terminal proxy for latency. No further nesting allowed.
+ */
+export type LatencyProxy = ProxyWithLatencyDescriptor;
+/**
+ * Proxy for a node result with body, headers, status, and latency accessors
  */
 export type NodeResultProxy = {
-    body: NestedProxy;
-    headers: NestedProxy;
-    status: NestedProxy;
+    body: BodyProxy;
+    headers: HeadersProxy;
+    status: StatusProxy;
+    latency: LatencyProxy;
 };
 /**
  * State proxy that maps node names to their result proxies
@@ -96,7 +121,7 @@ export declare function createStateProxy<NodeNames extends string>(nodeNames: No
 export declare class AssertBuilder {
     private descriptor;
     private negated;
-    constructor(descriptor: PathDescriptor);
+    constructor(descriptor: AssertionDescriptor);
     /**
      * Negation modifier - flips the meaning of the subsequent predicate
      *
@@ -105,21 +130,26 @@ export declare class AssertBuilder {
      * Assert(state["node"].body["name"]).not.equals("") // NOT_EQUAL
      */
     get not(): this;
-    isNull(): SerializedAssertion;
-    isDefined(): SerializedAssertion;
-    isTrue(): SerializedAssertion;
-    isFalse(): SerializedAssertion;
-    isEmpty(): SerializedAssertion;
-    equals(expected: unknown): SerializedAssertion;
-    greaterThan(expected: number): SerializedAssertion;
-    lessThan(expected: number): SerializedAssertion;
-    greaterThanOrEqual(expected: number): SerializedAssertion;
-    lessThanOrEqual(expected: number): SerializedAssertion;
-    contains(expected: string): SerializedAssertion;
-    startsWith(expected: string): SerializedAssertion;
-    endsWith(expected: string): SerializedAssertion;
-    private createAssertion;
+    isNull(): Assertion;
+    isDefined(): Assertion;
+    isTrue(): Assertion;
+    isFalse(): Assertion;
+    isEmpty(): Assertion;
+    equals(expected: unknown): Assertion;
+    greaterThan(expected: number): Assertion;
+    lessThan(expected: number): Assertion;
+    greaterThanOrEqual(expected: number): Assertion;
+    lessThanOrEqual(expected: number): Assertion;
+    contains(expected: string): Assertion;
+    startsWith(expected: string): Assertion;
+    endsWith(expected: string): Assertion;
+    private createUnaryAssertion;
+    private createBinaryAssertion;
 }
+/**
+ * Union of all assertable proxy types
+ */
+export type AssertableProxy = BodyProxy | HeaderValueProxy | StatusProxy | LatencyProxy;
 /**
  * Creates an assertion builder from a state proxy reference
  *
@@ -131,6 +161,6 @@ export declare class AssertBuilder {
  * Assert(state["create_user"].status).equals(201)
  * Assert(state["create_user"].headers["content-type"]).contains("application/json")
  */
-export declare function Assert(proxyRef: NestedProxy): AssertBuilder;
+export declare function Assert(proxyRef: AssertableProxy): AssertBuilder;
 export {};
 //# sourceMappingURL=assertions.d.ts.map

package/dist/assertions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"assertions.d.ts","sourceRoot":"","sources":["../src/assertions.ts"],"names":[],"mappings":"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"}