@griffin-app/griffin-ts 0.1.0

package/dist/secrets.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Secret reference types and utilities for griffin DSL.
+ *
+ * Secrets are referenced by provider and path, and resolved at runtime
+ * by the plan executor using configured secret providers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secret = secret;
+exports.isSecretRef = isSecretRef;
+/**
+ * Create a secret reference for use in endpoint headers or body.
+ *
+ * @param path - Provider-qualified path in format "provider:path"
+ *   Examples:
+ *   - "env:API_KEY" - Environment variable
+ *   - "aws:prod/api-key" - AWS Secrets Manager
+ *   - "vault:secret/data/api" - HashiCorp Vault
+ *   - "doppler:backend/prod/API_KEY" - Doppler
+ *
+ * @param options - Optional version pinning or field extraction
+ *
+ * @example
+ * ```typescript
+ * builder.addEndpoint("call", {
+ *   method: GET,
+ *   path: "/api/data",
+ *   headers: {
+ *     "Authorization": secret("aws:prod/api-key"),
+ *     "X-API-Key": secret("env:LOCAL_API_KEY"),
+ *   },
+ * })
+ * ```
+ */
+function secret(path, options) {
+    const colonIndex = path.indexOf(":");
+    if (colonIndex === -1) {
+        throw new Error(`Secret path must include provider: "provider:path" (e.g., "aws:my-secret", "env:API_KEY"). Got: "${path}"`);
+    }
+    if (colonIndex === 0) {
+        throw new Error(`Secret path must have a provider name before the colon. Got: "${path}"`);
+    }
+    if (colonIndex === path.length - 1) {
+        throw new Error(`Secret path must have a reference after the colon. Got: "${path}"`);
+    }
+    const provider = path.slice(0, colonIndex);
+    const ref = path.slice(colonIndex + 1);
+    return {
+        $secret: {
+            provider,
+            ref,
+            ...(options?.version !== undefined && { version: options.version }),
+            ...(options?.field !== undefined && { field: options.field }),
+        },
+    };
+}
+/**
+ * Type guard to check if a value is a secret reference.
+ */
+function isSecretRef(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const obj = value;
+    if (!("$secret" in obj) ||
+        typeof obj.$secret !== "object" ||
+        obj.$secret === null) {
+        return false;
+    }
+    const secretData = obj.$secret;
+    return (typeof secretData.provider === "string" &&
+        typeof secretData.ref === "string");
+}
+//# sourceMappingURL=secrets.js.map

package/dist/secrets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.js","sourceRoot":"","sources":["../src/secrets.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AA4CH,wBAgCC;AAKD,kCAmBC;AAhFD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,SAAgB,MAAM,CAAC,IAAY,EAAE,OAAuB;IAC1D,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAErC,IAAI,UAAU,KAAK,CAAC,CAAC,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CACb,oGAAoG,IAAI,GAAG,CAC5G,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CACb,iEAAiE,IAAI,GAAG,CACzE,CAAC;IACJ,CAAC;IAED,IAAI,UAAU,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACnC,MAAM,IAAI,KAAK,CACb,4DAA4D,IAAI,GAAG,CACpE,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;IAC3C,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;IAEvC,OAAO;QACL,OAAO,EAAE;YACP,QAAQ;YACR,GAAG;YACH,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC;YACnE,GAAG,CAAC,OAAO,EAAE,KAAK,KAAK,SAAS,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC;SAC9D;KACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,WAAW,CAAC,KAAc;IACxC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,GAAG,GAAG,KAAgC,CAAC;IAC7C,IACE,CAAC,CAAC,SAAS,IAAI,GAAG,CAAC;QACnB,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ;QAC/B,GAAG,CAAC,OAAO,KAAK,IAAI,EACpB,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,UAAU,GAAG,GAAG,CAAC,OAAkC,CAAC;IAC1D,OAAO,CACL,OAAO,UAAU,CAAC,QAAQ,KAAK,QAAQ;QACvC,OAAO,UAAU,CAAC,GAAG,KAAK,QAAQ,CACnC,CAAC;AACJ,CAAC"}

package/dist/sequential-builder.d.ts

@@ -0,0 +1,127 @@
+import { type EndpointConfig, type WaitDuration } from "./builder";
+import { Frequency, TestPlanV1 } from "./schema";
+import { type SerializedAssertion, type StateProxy } from "./assertions";
+type RawPlan = Omit<TestPlanV1, "id" | "environment">;
+/**
+ * Callback type for building assertions with type-safe state access
+ */
+export type AssertionCallback<NodeNames extends string> = (state: StateProxy<NodeNames>) => SerializedAssertion[];
+/**
+ * SequentialTestBuilder provides a simplified DSL for creating linear test flows.
+ * Edges are automatically created based on the order nodes are added.
+ * No manual edge management required - just add steps in sequence.
+ *
+ * @template NodeNames - Union of all registered node names for type-safe state access
+ */
+export interface SequentialTestBuilder<NodeNames extends string = never> {
+    /**
+     * Adds an endpoint request to the sequence.
+     *
+     * @param name - Unique name for this node
+     * @param config - Endpoint configuration
+     * @returns Updated builder with node name registered
+     *
+     * @example
+     * ```typescript
+     * builder.request("create_user", {
+     *   method: POST,
+     *   path: "/api/v1/users",
+     *   response_format: Json,
+     *   body: { name: "Test User" }
+     * })
+     * ```
+     */
+    request<Name extends string>(name: Name, config: EndpointConfig): SequentialTestBuilder<NodeNames | Name>;
+    /**
+     * Adds a wait/delay to the sequence.
+     *
+     * @param name - Unique name for this node
+     * @param duration - How long to wait
+     * @returns Updated builder with node name registered
+     *
+     * @example
+     * ```typescript
+     * builder.wait("pause", Wait.seconds(5))
+     * // or with raw milliseconds:
+     * builder.wait("pause", 5000)
+     * ```
+     */
+    wait<Name extends string>(name: Name, duration: WaitDuration): SequentialTestBuilder<NodeNames | Name>;
+    /**
+     * Adds assertions to the sequence using a callback with type-safe state access.
+     *
+     * The callback receives a state proxy that provides autocomplete for all registered
+     * node names and allows building rich JsonPath-based assertions.
+     *
+     * @param callback - Function that receives state proxy and returns assertions
+     * @returns Updated builder (no new node name registered - uses auto-generated name)
+     *
+     * @example
+     * ```typescript
+     * builder.assert((state) => [
+     *   Assert(state["create_user"].status).equals(201),
+     *   Assert(state["create_user"].body["data"]["id"]).not.isNull(),
+     *   Assert(state["create_user"].headers["content-type"]).contains("application/json"),
+     * ])
+     * ```
+     */
+    assert(callback: AssertionCallback<NodeNames>): SequentialTestBuilder<NodeNames>;
+    /**
+     * Builds the final test plan.
+     * Automatically connects all nodes in sequence: START → node1 → node2 → ... → END
+     *
+     * @returns The completed TestPlan
+     */
+    build(): RawPlan;
+}
+/**
+ * Creates a sequential test builder for simple linear test flows.
+ *
+ * Unlike createGraphBuilder, this builder automatically manages edges
+ * based on the order in which nodes are added. Perfect for straightforward
+ * sequential tests where you don't need complex branching logic.
+ *
+ * @param config - Test configuration
+ * @param config.name - Name of the test
+ * @param config.frequency - Optional frequency for scheduled execution
+ * @param config.locations - Optional array of location identifiers where this test should run
+ * @returns A new SequentialTestBuilder instance
+ *
+ * @example
+ * ```typescript
+ * import { createTestBuilder, POST, GET, Json, Frequency, Assert } from "griffin-ts";
+ *
+ * const plan = createTestBuilder({
+ *   name: "create-and-verify-user",
+ *   frequency: Frequency.every(5).minute(),
+ *   locations: ["us-east-1", "eu-west-1"]
+ * })
+ *   .request("create_user", {
+ *     method: POST,
+ *     path: "/api/v1/users",
+ *     response_format: Json,
+ *     body: { name: "Test User", email: "test@example.com" }
+ *   })
+ *   .assert((state) => [
+ *     Assert(state["create_user"].status).equals(201),
+ *     Assert(state["create_user"].body["data"]["id"]).not.isNull(),
+ *   ])
+ *   .request("get_user", {
+ *     method: GET,
+ *     path: "/api/v1/users/123",
+ *     response_format: Json
+ *   })
+ *   .assert((state) => [
+ *     Assert(state["get_user"].status).equals(200),
+ *     Assert(state["get_user"].body["data"]["name"]).equals("Test User"),
+ *   ])
+ *   .build();
+ * ```
+ */
+export declare function createTestBuilder(config: {
+    name: string;
+    frequency?: Frequency;
+    locations?: string[];
+}): SequentialTestBuilder;
+export {};
+//# sourceMappingURL=sequential-builder.d.ts.map

package/dist/sequential-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequential-builder.d.ts","sourceRoot":"","sources":["../src/sequential-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAiC,SAAS,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAChF,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AAEtB,KAAK,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,aAAa,CAAC,CAAC;AAEtD;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,SAAS,SAAS,MAAM,IAAI,CACxD,KAAK,EAAE,UAAU,CAAC,SAAS,CAAC,KACzB,mBAAmB,EAAE,CAAC;AAE3B;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB,CAAC,SAAS,SAAS,MAAM,GAAG,KAAK;IACrE;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,IAAI,SAAS,MAAM,EACzB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,cAAc,GACrB,qBAAqB,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;OAaG;IACH,IAAI,CAAC,IAAI,SAAS,MAAM,EACtB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,YAAY,GACrB,qBAAqB,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CACJ,QAAQ,EAAE,iBAAiB,CAAC,SAAS,CAAC,GACrC,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAEpC;;;;;OAKG;IACH,KAAK,IAAI,OAAO,CAAC;CAClB;AAqGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB,GAAG,qBAAqB,CAExB"}

package/dist/sequential-builder.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTestBuilder = createTestBuilder;
+const builder_1 = require("./builder");
+const constants_1 = require("./constants");
+const schema_1 = require("./schema");
+const assertions_1 = require("./assertions");
+/**
+ * Internal implementation class for SequentialTestBuilder.
+ */
+class SequentialTestBuilderImpl {
+    config;
+    nodes = [];
+    nodeNames = [];
+    nodeCounter = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Generates a unique auto-generated node name
+     */
+    generateNodeName() {
+        return `step_${this.nodeCounter++}`;
+    }
+    request(name, config) {
+        const node = (0, builder_1.Endpoint)(config);
+        this.nodes.push({ ...node, id: name });
+        this.nodeNames.push(name);
+        return this;
+    }
+    wait(name, duration) {
+        const node = (0, builder_1.Wait)(duration);
+        this.nodes.push({ ...node, id: name });
+        this.nodeNames.push(name);
+        return this;
+    }
+    assert(callback) {
+        const stateProxy = (0, assertions_1.createStateProxy)(this.nodeNames);
+        const serializedAssertions = callback(stateProxy);
+        const nodeName = this.generateNodeName();
+        const node = (0, builder_1.Assertion)(serializedAssertions);
+        this.nodes.push({ ...node, id: nodeName });
+        this.nodeNames.push(nodeName);
+        return this;
+    }
+    build() {
+        const { name, frequency, locations } = this.config;
+        const edges = [];
+        // If no nodes, return empty plan with just START->END
+        if (this.nodes.length === 0) {
+            return {
+                name,
+                frequency,
+                locations,
+                version: schema_1.TEST_PLAN_VERSION,
+                nodes: [],
+                edges: [{ from: constants_1.START, to: constants_1.END }],
+            };
+        }
+        // Connect START to first node
+        edges.push({ from: constants_1.START, to: this.nodes[0].id });
+        // Connect consecutive nodes
+        for (let i = 0; i < this.nodes.length - 1; i++) {
+            edges.push({
+                from: this.nodes[i].id,
+                to: this.nodes[i + 1].id,
+            });
+        }
+        // Connect last node to END
+        edges.push({ from: this.nodes[this.nodes.length - 1].id, to: constants_1.END });
+        return {
+            name,
+            version: schema_1.TEST_PLAN_VERSION,
+            frequency,
+            locations,
+            nodes: this.nodes,
+            edges,
+        };
+    }
+}
+/**
+ * Creates a sequential test builder for simple linear test flows.
+ *
+ * Unlike createGraphBuilder, this builder automatically manages edges
+ * based on the order in which nodes are added. Perfect for straightforward
+ * sequential tests where you don't need complex branching logic.
+ *
+ * @param config - Test configuration
+ * @param config.name - Name of the test
+ * @param config.frequency - Optional frequency for scheduled execution
+ * @param config.locations - Optional array of location identifiers where this test should run
+ * @returns A new SequentialTestBuilder instance
+ *
+ * @example
+ * ```typescript
+ * import { createTestBuilder, POST, GET, Json, Frequency, Assert } from "griffin-ts";
+ *
+ * const plan = createTestBuilder({
+ *   name: "create-and-verify-user",
+ *   frequency: Frequency.every(5).minute(),
+ *   locations: ["us-east-1", "eu-west-1"]
+ * })
+ *   .request("create_user", {
+ *     method: POST,
+ *     path: "/api/v1/users",
+ *     response_format: Json,
+ *     body: { name: "Test User", email: "test@example.com" }
+ *   })
+ *   .assert((state) => [
+ *     Assert(state["create_user"].status).equals(201),
+ *     Assert(state["create_user"].body["data"]["id"]).not.isNull(),
+ *   ])
+ *   .request("get_user", {
+ *     method: GET,
+ *     path: "/api/v1/users/123",
+ *     response_format: Json
+ *   })
+ *   .assert((state) => [
+ *     Assert(state["get_user"].status).equals(200),
+ *     Assert(state["get_user"].body["data"]["name"]).equals("Test User"),
+ *   ])
+ *   .build();
+ * ```
+ */
+function createTestBuilder(config) {
+    return new SequentialTestBuilderImpl(config);
+}
+//# sourceMappingURL=sequential-builder.js.map

package/dist/sequential-builder.js.map

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

package/dist/shared.d.ts

@@ -0,0 +1,8 @@
+import { TSchema, TSchemaOptions, TUnsafe, Static, Type } from "typebox";
+export declare function Ref<T extends TSchema>(t: T, options?: TSchemaOptions): TUnsafe<Static<T>>;
+export declare class TUnionOneOf<Types extends TSchema[] = TSchema[]> extends Type.Base<TSchema[]> {
+    oneOf: Types;
+    constructor(oneOf: Types);
+}
+export declare function UnionOneOf(oneOf: TSchema[]): TUnionOneOf;
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,cAAc,EACd,OAAO,EACP,MAAM,EAEN,IAAI,EACL,MAAM,SAAS,CAAC;AAIjB,wBAAgB,GAAG,CAAC,CAAC,SAAS,OAAO,EACnC,CAAC,EAAE,CAAC,EACJ,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAMpB;AAED,qBAAa,WAAW,CAAC,KAAK,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,CAAE,SAAQ,IAAI,CAAC,IAAI,CAC7E,OAAO,EAAE,CACV;IACQ,KAAK,EAAE,KAAK,CAAC;gBACR,KAAK,EAAE,KAAK;CAIzB;AACD,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,WAAW,CAExD"}

package/dist/shared.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TUnionOneOf = void 0;
+exports.Ref = Ref;
+exports.UnionOneOf = UnionOneOf;
+const typebox_1 = require("typebox");
+function Ref(t, options = {}) {
+    const id = t.$id;
+    if (!id) {
+        throw new Error("missing ID on schema");
+    }
+    return (0, typebox_1.Unsafe)({ ...t, $ref: id, $id: undefined, ...options });
+}
+class TUnionOneOf extends typebox_1.Type.Base {
+    oneOf;
+    constructor(oneOf) {
+        super();
+        this.oneOf = oneOf;
+    }
+}
+exports.TUnionOneOf = TUnionOneOf;
+function UnionOneOf(oneOf) {
+    return new TUnionOneOf(oneOf);
+}
+//export interface TUnionOneOf<Types extends TSchema[] = TSchema[]> extends TSchema {
+//  '~kind': 'UnionOneOf'
+//  //static: { [K in keyof Types]: Static<Types[K]> }[number]
+//  oneOf: Types
+//}
+//
+//export function UnionOneOf<Types extends TSchema[]>(oneOf: [...Types], options: TSchemaOptions = {}) {
+//  return { ...options, ["~kind"]: 'UnionOneOf', oneOf } as TUnionOneOf<Types>
+//
+//  ///return Memory.Create({ '~kind': 'UnionOneOf' }, { oneOf }, options) as never
+//}
+//# sourceMappingURL=shared.js.map

package/dist/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":";;;AAWA,kBASC;AAWD,gCAEC;AAjCD,qCAOiB;AAIjB,SAAgB,GAAG,CACjB,CAAI,EACJ,UAA0B,EAAE;IAE5B,MAAM,EAAE,GAAI,CAAmD,CAAC,GAAG,CAAC;IACpE,IAAI,CAAC,EAAE,EAAE,CAAC;QACR,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;IAC1C,CAAC;IACD,OAAO,IAAA,gBAAM,EAAY,EAAE,GAAG,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC;AAC3E,CAAC;AAED,MAAa,WAAiD,SAAQ,cAAI,CAAC,IAE1E;IACQ,KAAK,CAAQ;IACpB,YAAY,KAAY;QACtB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CACF;AARD,kCAQC;AACD,SAAgB,UAAU,CAAC,KAAgB;IACzC,OAAO,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC;AAED,qFAAqF;AACrF,yBAAyB;AACzB,8DAA8D;AAC9D,gBAAgB;AAChB,GAAG;AACH,EAAE;AACF,wGAAwG;AACxG,+EAA+E;AAC/E,EAAE;AACF,mFAAmF;AACnF,GAAG"}

package/dist/target.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Target reference utilities for griffin DSL.
+ *
+ * Targets are resolved at runtime by the runner based on the execution environment.
+ * This allows the same test to run against different environments (staging, production, etc.)
+ * without changing the test code.
+ */
+import { TargetRef } from "./schema.js";
+/**
+ * Create a target reference for endpoint base URLs.
+ *
+ * The runner will resolve this to the appropriate base URL based on the
+ * execution environment (passed as a per-run parameter).
+ *
+ * @param key - The target identifier (e.g., "billing-service", "api-gateway")
+ * @returns A target reference object
+ *
+ * @example
+ * ```typescript
+ * builder.addNode("billing", Endpoint({
+ *   method: GET,
+ *   path: "/invoices",
+ *   base: target("billing-service"),
+ *   response_format: JSON
+ * }));
+ * ```
+ */
+export declare function target(key: string): TargetRef;
+/**
+ * Type guard to check if a value is a target reference.
+ */
+export declare function isTargetRef(value: unknown): value is TargetRef;
+//# sourceMappingURL=target.d.ts.map

package/dist/target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../src/target.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAa7C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAO9D"}

package/dist/target.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Target reference utilities for griffin DSL.
+ *
+ * Targets are resolved at runtime by the runner based on the execution environment.
+ * This allows the same test to run against different environments (staging, production, etc.)
+ * without changing the test code.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.target = target;
+exports.isTargetRef = isTargetRef;
+/**
+ * Create a target reference for endpoint base URLs.
+ *
+ * The runner will resolve this to the appropriate base URL based on the
+ * execution environment (passed as a per-run parameter).
+ *
+ * @param key - The target identifier (e.g., "billing-service", "api-gateway")
+ * @returns A target reference object
+ *
+ * @example
+ * ```typescript
+ * builder.addNode("billing", Endpoint({
+ *   method: GET,
+ *   path: "/invoices",
+ *   base: target("billing-service"),
+ *   response_format: JSON
+ * }));
+ * ```
+ */
+function target(key) {
+    if (!key || typeof key !== "string") {
+        throw new Error(`Target key must be a non-empty string. Got: ${key}`);
+    }
+    if (key.trim() === "") {
+        throw new Error("Target key cannot be empty or whitespace only");
+    }
+    return {
+        type: "target",
+        key: key.trim(),
+    };
+}
+/**
+ * Type guard to check if a value is a target reference.
+ */
+function isTargetRef(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const obj = value;
+    return obj.type === "target" && typeof obj.key === "string";
+}
+//# sourceMappingURL=target.js.map

package/dist/target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.js","sourceRoot":"","sources":["../src/target.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG;;AAuBH,wBAaC;AAKD,kCAOC;AA5CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,MAAM,CAAC,GAAW;IAChC,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CAAC,+CAA+C,GAAG,EAAE,CAAC,CAAC;IACxE,CAAC;IAED,IAAI,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAC;IACnE,CAAC;IAED,OAAO;QACL,IAAI,EAAE,QAAQ;QACd,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE;KAChB,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,WAAW,CAAC,KAAc;IACxC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,GAAG,GAAG,KAAgC,CAAC;IAC7C,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ,IAAI,OAAO,GAAG,CAAC,GAAG,KAAK,QAAQ,CAAC;AAC9D,CAAC"}

package/dist/type-exports.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Static types derived from TypeBox schemas.
+ * Import from "griffin/types" for TypeScript type checking.
+ */
+export type { TargetRef, Endpoint, Frequency, Wait, BinaryPredicate, JSONAssertion, XMLAssertion, TextAssertion, Assertion, Assertions, Node, Edge, TestPlanV1, } from "./schema.js";
+//# sourceMappingURL=type-exports.d.ts.map

package/dist/type-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-exports.d.ts","sourceRoot":"","sources":["../src/type-exports.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EACV,SAAS,EACT,QAAQ,EACR,SAAS,EACT,IAAI,EACJ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,aAAa,EACb,SAAS,EACT,UAAU,EACV,IAAI,EACJ,IAAI,EACJ,UAAU,GACX,MAAM,aAAa,CAAC"}

package/dist/type-exports.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Static types derived from TypeBox schemas.
+ * Import from "griffin/types" for TypeScript type checking.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=type-exports.js.map

package/dist/type-exports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-exports.js","sourceRoot":"","sources":["../src/type-exports.ts"],"names":[],"mappings":";AAAA;;;GAGG"}

package/dist/wait.d.ts

@@ -0,0 +1,9 @@
+export declare const WaitDuration: {
+    minutes: (value: number) => {
+        minutes: number;
+    };
+    seconds: (value: number) => {
+        seconds: number;
+    };
+};
+//# sourceMappingURL=wait.d.ts.map

package/dist/wait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.d.ts","sourceRoot":"","sources":["../src/wait.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;qBACN,MAAM;;;qBACN,MAAM;;;CACxB,CAAC"}

package/dist/wait.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WaitDuration = void 0;
+exports.WaitDuration = {
+    minutes: (value) => ({ minutes: value }),
+    seconds: (value) => ({ seconds: value }),
+};
+//# sourceMappingURL=wait.js.map

package/dist/wait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.js","sourceRoot":"","sources":["../src/wait.ts"],"names":[],"mappings":";;;AAAa,QAAA,YAAY,GAAG;IAC1B,OAAO,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAChD,OAAO,EAAE,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;CACjD,CAAC"}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@griffin-app/griffin-ts",
+  "version": "0.1.0",
+  "description": "TypeScript DSL for defining griffin API tests",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./schema": {
+      "types": "./dist/schema-exports.d.ts",
+      "default": "./dist/schema-exports.js"
+    },
+    "./types": {
+      "types": "./dist/type-exports.d.ts",
+      "default": "./dist/type-exports.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "griffin",
+    "api",
+    "testing",
+    "dsl"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.3",
+    "vitest": "^4.0.17"
+  },
+  "dependencies": {
+    "ts-edge": "^1.0.4",
+    "typebox": "^1.0.78"
+  }
+}