@griffin-app/griffin-ts 0.1.9 → 0.1.11

package/src/migrations.ts

@@ -0,0 +1,120 @@
+/**
+ * Migration framework for test plan versioning.
+ * Provides functions to migrate plans between different schema versions.
+ */
+
+import { CURRENT_PLAN_VERSION, SUPPORTED_PLAN_VERSIONS } from "./schema.js";
+import type { ResolvedPlan, ResolvedPlanV1 } from "./schema.js";
+
+/**
+ * Type representing a migration function from one version to another
+ */
+type MigrationFn<From = unknown, To = unknown> = (plan: From) => To;
+
+/**
+ * Registry of all available migrations between versions
+ * Key format: "fromVersion->toVersion"
+ */
+const migrations: Record<string, MigrationFn<any, any>> = {
+  // Future migrations will be added here
+  // Example: "1.0->2.0": migrateV1ToV2,
+};
+
+/**
+ * Get the next version in the supported versions list
+ */
+function getNextVersion(currentVersion: string): string {
+  const versions = SUPPORTED_PLAN_VERSIONS as readonly string[];
+  const currentIndex = versions.indexOf(currentVersion);
+
+  if (currentIndex === -1) {
+    throw new Error(`Unsupported plan version: ${currentVersion}`);
+  }
+
+  if (currentIndex === versions.length - 1) {
+    throw new Error(
+      `No migration path available from version ${currentVersion}`,
+    );
+  }
+
+  return versions[currentIndex + 1];
+}
+
+/**
+ * Migrate a plan from its current version to a target version
+ *
+ * @param plan - Plan to migrate (must have a version field)
+ * @param targetVersion - Target version to migrate to
+ * @returns Migrated plan at target version
+ * @throws Error if no migration path exists
+ */
+export function migratePlan<T>(
+  plan: { version: string },
+  targetVersion: string,
+): T {
+  let current: any = plan;
+
+  // Already at target version
+  if (current.version === targetVersion) {
+    return current as T;
+  }
+
+  // Migrate step by step through versions
+  while (current.version !== targetVersion) {
+    const nextVersion = getNextVersion(current.version);
+    const migrationKey = `${current.version}->${nextVersion}`;
+    const migrate = migrations[migrationKey];
+
+    if (!migrate) {
+      throw new Error(
+        `No migration path from version ${current.version} to ${nextVersion}`,
+      );
+    }
+
+    current = migrate(current);
+  }
+
+  return current as T;
+}
+
+/**
+ * Migrate a plan to the latest supported version
+ *
+ * @param plan - Plan to migrate (must have a version field)
+ * @returns Plan migrated to latest version
+ */
+export function migrateToLatest(plan: { version: string }): ResolvedPlan {
+  return migratePlan<ResolvedPlan>(plan, CURRENT_PLAN_VERSION);
+}
+
+/**
+ * Check if a plan version is supported
+ *
+ * @param version - Version string to check
+ * @returns True if version is supported
+ */
+export function isSupportedVersion(version: string): boolean {
+  return SUPPORTED_PLAN_VERSIONS.includes(version as any);
+}
+
+/**
+ * Get all supported plan versions
+ */
+export function getSupportedVersions(): readonly string[] {
+  return SUPPORTED_PLAN_VERSIONS;
+}
+
+/**
+ * Example migration function template (for future use)
+ *
+ * Uncomment and modify when creating v2.0:
+ *
+ * function migrateV1ToV2(plan: ResolvedPlanV1): ResolvedPlanV2 {
+ *   return {
+ *     ...plan,
+ *     version: "2.0",
+ *     // Add/modify fields as needed for v2.0
+ *     newField: "default value",
+ *   };
+ * }
+ */

package/src/schema-exports.ts

@@ -4,7 +4,7 @@
  */
 
 export {
-  // Schema values
+  // Schema values - DSL (what users write)
   SecretRefDataSchema,
   SecretRefSchema,
   StringLiteralSchema,
@@ -19,6 +19,7 @@ export {
   XMLPathSchema,
   TextPathSchema,
   UnaryPredicateSchema,
+  UnaryPredicateOperatorSchema,
   BinaryPredicateOperatorSchema,
   BinaryPredicateSchema,
   AssertionSchema,
@@ -26,6 +27,14 @@ export {
   NodeDSLSchema,
   EdgeSchema,
   PlanDSLSchema,
+  PlanDSLSchemaV1,
+
+  // Schema values - Resolved (what hub/executor use)
+  ResolvedStringSchema,
+  HttpRequestResolvedSchema,
+  NodeResolvedSchema,
+  ResolvedPlanV1Schema,
+  ResolvedPlanSchema,
 
   // Enums (runtime values)
   FrequencyUnit,
@@ -36,5 +45,24 @@ export {
   BinaryPredicateOperator,
 
   // Constants
-  TEST_PLAN_VERSION,
+  CURRENT_PLAN_VERSION,
+  SUPPORTED_PLAN_VERSIONS,
+} from "./schema.js";
+
+// Type exports
+export type {
+  PlanDSL,
+  PlanDSLV1,
+  NodeDSL,
+  HttpRequestDSL,
+  Edge,
+  Frequency,
+  Assertion,
+  Assertions,
+  SecretRef,
+  VariableRef,
+  ResolvedPlan,
+  ResolvedPlanV1,
+  NodeResolved,
+  HttpRequestResolved,
 } from "./schema.js";

package/src/schema.ts

@@ -1,7 +1,9 @@
 import { Type, type Static } from "typebox";
 import { Ref, StringEnum } from "./shared.js";
 
-export const TEST_PLAN_VERSION = "1.0";
+// Version constants
+export const CURRENT_PLAN_VERSION = "1.0";
+export const SUPPORTED_PLAN_VERSIONS = ["1.0"] as const;
 
 // Secret reference schema for values that may contain secrets
 export const SecretRefDataSchema = Type.Object({
@@ -311,21 +313,27 @@ export const EdgeSchema = Type.Object(
   { $id: "Edge" },
 );
 
-export const PlanDSLSchema = Type.Object(
+// Version-specific DSL schemas
+export const PlanDSLSchemaV1 = Type.Object(
   {
     locations: Type.Optional(Type.Array(Type.String())),
     name: Type.String(),
-    version: Type.Literal(TEST_PLAN_VERSION),
+    version: Type.Literal("1.0"),
     frequency: FrequencySchema,
     nodes: Type.Array(NodeDSLSchema),
     edges: Type.Array(EdgeSchema),
   },
   {
-    $id: "PlanDSL",
+    $id: "PlanDSLV1",
   },
 );
 
-export type PlanDSL = Static<typeof PlanDSLSchema>;
+// Union schema for validation (accepts any supported version)
+export const PlanDSLSchema = PlanDSLSchemaV1; // Currently only v1.0, will become union when v2.0 is added
+
+// Type extraction
+export type PlanDSLV1 = Static<typeof PlanDSLSchemaV1>;
+export type PlanDSL = PlanDSLV1; // Currently only v1.0, will become union when v2.0 is added
 export type VariableRef = Static<typeof VariableRefSchema>;
 export type NodeDSL = Static<typeof NodeDSLSchema>;
 export type Edge = Static<typeof EdgeSchema>;
@@ -342,3 +350,59 @@ export type SecretRefData = Static<typeof SecretRefDataSchema>;
 export type StringLiteral = Static<typeof StringLiteralSchema>;
 export type String = Static<typeof StringSchema>;
 export type Frequency = Static<typeof FrequencySchema>;
+
+// ============================================================================
+// Resolved Plan Schemas (after variable resolution, used by hub/executor)
+// ============================================================================
+
+// Union type for resolved values (variables are resolved, only secrets/literals remain)
+export const ResolvedStringSchema = Type.Union([
+  StringLiteralSchema,
+  SecretRefSchema,
+]);
+
+export const HttpRequestResolvedSchema = Type.Object(
+  {
+    id: Type.String(),
+    type: Type.Literal(NodeType.HTTP_REQUEST),
+    method: HttpMethodSchema,
+    path: Type.String(),
+    base: Type.String(),
+    headers: Type.Optional(Type.Record(Type.String(), ResolvedStringSchema)),
+    body: Type.Optional(Type.Any()), // Body can contain nested SecretRefs
+    response_format: ResponseFormatSchema,
+  },
+  { $id: "HttpRequestResolved" },
+);
+
+export const NodeResolvedSchema = Type.Union(
+  [HttpRequestResolvedSchema, WaitSchema, AssertionsSchema],
+  { $id: "NodeResolved" },
+);
+
+// Version-specific resolved plan schemas
+export const ResolvedPlanV1Schema = Type.Object(
+  {
+    project: Type.String(),
+    locations: Type.Optional(Type.Array(Type.String())),
+    id: Type.Readonly(Type.String()),
+    name: Type.String(),
+    version: Type.Literal("1.0"),
+    frequency: FrequencySchema,
+    environment: Type.String({ default: "default" }),
+    nodes: Type.Array(NodeResolvedSchema),
+    edges: Type.Array(EdgeSchema),
+  },
+  {
+    $id: "ResolvedPlanV1",
+  },
+);
+
+// Union of all supported resolved plan versions
+export const ResolvedPlanSchema = ResolvedPlanV1Schema;
+
+// Type exports for resolved plans
+export type ResolvedPlanV1 = Static<typeof ResolvedPlanV1Schema>;
+export type ResolvedPlan = ResolvedPlanV1;
+export type HttpRequestResolved = Static<typeof HttpRequestResolvedSchema>;
+export type NodeResolved = Static<typeof NodeResolvedSchema>;

package/src/sequential-builder.test.ts

@@ -9,7 +9,7 @@ import {
   HttpMethod,
   ResponseFormat,
   NodeType,
-  TEST_PLAN_VERSION,
+  CURRENT_PLAN_VERSION,
 } from "./schema.js";
 
 describe("Sequential Test Builder", () => {
@@ -28,7 +28,7 @@ describe("Sequential Test Builder", () => {
         .build();
 
       expect(plan.name).toBe("simple-check");
-      expect(plan.version).toBe(TEST_PLAN_VERSION);
+      expect(plan.version).toBe(CURRENT_PLAN_VERSION);
       expect(plan.frequency).toEqual({ every: 5, unit: "MINUTE" });
       expect(plan.nodes).toHaveLength(1);
       expect(plan.edges).toEqual([

package/src/sequential-builder.ts

@@ -7,7 +7,7 @@ import {
 } from "./builder.js";
 import { START, END } from "./constants.js";
 import {
-  TEST_PLAN_VERSION,
+  CURRENT_PLAN_VERSION,
   Edge,
   NodeDSL,
   Frequency,
@@ -177,7 +177,7 @@ class SequentialTestBuilderImpl<
         name,
         frequency,
         locations,
-        version: TEST_PLAN_VERSION,
+        version: CURRENT_PLAN_VERSION,
         nodes: [],
         edges: [{ from: START, to: END }],
       };
@@ -199,7 +199,7 @@ class SequentialTestBuilderImpl<
 
     return {
       name,
-      version: TEST_PLAN_VERSION,
+      version: CURRENT_PLAN_VERSION,
       frequency,
       locations,
       nodes: this.nodes,