@pgflow/dsl 0.0.5-prealpha.2

package/src/dsl.ts

@@ -0,0 +1,318 @@
+import { validateRuntimeOptions, validateSlug } from './utils.ts';
+
+// ========================
+// CORE TYPE DEFINITIONS
+// ========================
+
+// JSON type enforcement so we can serialize the results to JSONB columns
+export type Json =
+  | string
+  | number
+  | boolean
+  | null
+  | Json[]
+  | { [key: string]: Json | undefined };
+
+// Used to flatten the types of a union of objects for readability
+export type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+// ========================
+// FLOW COMPONENT TYPES
+// ========================
+
+// Input Types
+export type AnyInput = Json;
+export type AnyOutput = Json;
+
+// Step Types
+export type EmptySteps = Record<never, never>;
+export type AnySteps = Record<string, AnyOutput>; // Could use unknown if needed
+
+// Dependency Types
+export type EmptyDeps = Record<never, never[]>;
+export type DefaultDeps = Record<string, string[]>;
+export type AnyDeps = Record<string, string[]>;
+
+// ========================
+// FLOW TYPE VARIANTS
+// ========================
+
+/**
+ * Represents a Flow that has not steps nor deps defined yet
+ */
+export type EmptyFlow = Flow<AnyInput, EmptySteps, EmptyDeps>;
+
+/**
+ * Represents any Flow with flexible input, steps, and dependencies.
+ * This type is intentionally more permissive to allow for better type inference
+ * in utility types like StepOutput.
+ */
+export type AnyFlow = Flow<any, any, any>;
+
+// ========================
+// UTILITY TYPES (with proper constraints)
+// ========================
+
+/**
+ * Extracts the input type from a Flow
+ * @template TFlow - The Flow type to extract from
+ */
+export type ExtractFlowInput<TFlow extends AnyFlow> = TFlow extends Flow<
+  infer TI,
+  infer _TS,
+  infer _TD
+>
+  ? TI
+  : never;
+
+/**
+ * Extracts the steps type from a Flow
+ * @template TFlow - The Flow type to extract from
+ */
+export type ExtractFlowSteps<TFlow extends AnyFlow> = TFlow extends Flow<
+  infer _TI,
+  infer TS,
+  infer _TD
+>
+  ? TS
+  : never;
+
+/**
+ * Extracts the dependencies type from a Flow
+ * @template TFlow - The Flow type to extract from
+ */
+export type ExtractFlowDeps<TFlow extends AnyFlow> = TFlow extends Flow<
+  infer _TI,
+  infer _TS,
+  infer TD
+>
+  ? TD
+  : never;
+
+/**
+ * Extracts the dependencies type from a Flow
+ * @template TFlow - The Flow type to extract from
+ */
+type StepDepsOf<
+  TFlow extends AnyFlow,
+  TStepSlug extends string
+> = TStepSlug extends keyof ExtractFlowDeps<TFlow>
+  ? ExtractFlowDeps<TFlow>[TStepSlug][number] // The string slugs that TStepSlug depends on
+  : never;
+
+// Utility type to extract the output type of a step handler from a Flow
+// Usage:
+//   StepOutput<typeof flow, 'step1'>
+export type StepOutput<
+  TFlow extends AnyFlow,
+  TStepSlug extends string
+> = TStepSlug extends keyof ExtractFlowSteps<TFlow>
+  ? ExtractFlowSteps<TFlow>[TStepSlug]
+  : never;
+
+/**
+ * This ensures that:
+ * 1. The run input is always included
+ * 2. Only declared dependencies are included
+ * 3. No extra properties are allowed
+ * Utility type to extract the input type for a specific step in a flow
+ */
+export type StepInput<TFlow extends AnyFlow, TStepSlug extends string> = {
+  run: ExtractFlowInput<TFlow>;
+} & {
+  [K in Extract<
+    keyof ExtractFlowSteps<TFlow>,
+    StepDepsOf<TFlow, TStepSlug>
+  >]: ExtractFlowSteps<TFlow>[K];
+};
+
+// Runtime options interface
+export interface RuntimeOptions {
+  maxAttempts?: number;
+  baseDelay?: number;
+  timeout?: number;
+}
+
+// Define the StepDefinition interface with integrated options
+export interface StepDefinition<
+  TInput extends AnyInput,
+  TOutput extends AnyOutput
+> {
+  slug: string;
+  handler: (input: TInput) => TOutput | Promise<TOutput>;
+  dependencies: string[];
+  options: RuntimeOptions;
+}
+
+// Utility type to merge two object types and preserve required properties
+type MergeObjects<T1 extends object, T2 extends object> = T1 & T2;
+
+// Flow class definition
+export class Flow<
+  TFlowInput extends AnyInput = AnyInput,
+  Steps extends AnySteps = EmptySteps,
+  StepDependencies extends AnyDeps = EmptyDeps
+> {
+  /**
+   * Store step definitions with their proper types
+   *
+   * This is typed as a generic record because TypeScript cannot track the exact relationship
+   * between step slugs and their corresponding input/output types at the container level.
+   * Type safety is enforced at the method level when adding or retrieving steps.
+   */
+  private stepDefinitions: Record<string, StepDefinition<AnyInput, AnyOutput>>;
+  private stepOrder: string[];
+  public readonly slug: string;
+  public readonly options: RuntimeOptions;
+
+  constructor(
+    config: Simplify<{ slug: string } & RuntimeOptions>,
+    stepDefinitions: Record<string, StepDefinition<AnyInput, AnyOutput>> = {},
+    stepOrder: string[] = []
+  ) {
+    // Extract slug and options separately
+    const { slug, ...options } = config;
+
+    // Validate the slug
+    validateSlug(slug);
+
+    // Validate runtime options (optional for Flow level)
+    validateRuntimeOptions(options, { optional: true });
+
+    this.slug = slug;
+    this.options = options;
+    this.stepDefinitions = stepDefinitions;
+    // Defensive copy of stepOrder
+    this.stepOrder = [...stepOrder];
+  }
+
+  /**
+   * Get a specific step definition by slug with proper typing
+   * @throws Error if the step with the given slug doesn't exist
+   */
+  getStepDefinition<SlugType extends keyof Steps & keyof StepDependencies>(
+    slug: SlugType
+  ): StepDefinition<
+    Simplify<
+      {
+        run: TFlowInput;
+      } & {
+        [K in StepDependencies[SlugType][number]]: K extends keyof Steps
+          ? Steps[K]
+          : never;
+      }
+    >,
+    Steps[SlugType]
+  > {
+    // Check if the slug exists in stepDefinitions using a more explicit pattern
+    if (!(slug in this.stepDefinitions)) {
+      throw new Error(
+        `Step "${String(slug)}" does not exist in flow "${this.slug}"`
+      );
+    }
+
+    // Use a type assertion directive to tell TypeScript that this is safe
+    // @ts-expect-error The type system cannot track that this.stepDefinitions[slug] has the correct type
+    // but we know it's safe because we only add steps through the strongly-typed `step` method
+    return this.stepDefinitions[slug as string];
+  }
+
+  // SlugType extends keyof Steps & keyof StepDependencies
+  step<
+    Slug extends string,
+    Deps extends Extract<keyof Steps, string> = never,
+    RetType extends AnyOutput = AnyOutput
+  >(
+    opts: Simplify<{ slug: Slug; dependsOn?: Deps[] } & RuntimeOptions>,
+    handler: (
+      input: Simplify<
+        {
+          run: TFlowInput;
+        } & {
+          [K in Deps]: K extends keyof Steps ? Steps[K] : never;
+        }
+      >
+    ) => RetType | Promise<RetType>
+  ): Flow<
+    TFlowInput,
+    Steps & { [K in Slug]: Awaited<RetType> },
+    StepDependencies & { [K in Slug]: Deps[] }
+  > {
+    type NewSteps = MergeObjects<Steps, { [K in Slug]: Awaited<RetType> }>;
+    type NewDependencies = MergeObjects<
+      StepDependencies,
+      { [K in Slug]: Deps[] }
+    >;
+
+    const slug = opts.slug as Slug;
+
+    // Validate the step slug
+    validateSlug(slug);
+
+    if (this.stepDefinitions[slug]) {
+      throw new Error(`Step "${slug}" already exists in flow "${this.slug}"`);
+    }
+
+    const dependencies = opts.dependsOn || [];
+    // Validate dependencies - check if all referenced steps exist
+    if (dependencies.length > 0) {
+      for (const dep of dependencies) {
+        if (!this.stepDefinitions[dep as string]) {
+          throw new Error(`Step "${slug}" depends on undefined step "${dep}"`);
+        }
+      }
+    }
+
+    // Extract RuntimeOptions from opts
+    const options: RuntimeOptions = {};
+    if (opts.maxAttempts !== undefined) options.maxAttempts = opts.maxAttempts;
+    if (opts.baseDelay !== undefined) options.baseDelay = opts.baseDelay;
+    if (opts.timeout !== undefined) options.timeout = opts.timeout;
+
+    // Validate runtime options (optional for step level)
+    validateRuntimeOptions(options, { optional: true });
+
+    // Preserve the exact type of the handler
+    const newStepDefinition: StepDefinition<
+      Simplify<
+        {
+          run: TFlowInput;
+        } & {
+          [K in Deps]: K extends keyof Steps ? Steps[K] : never;
+        }
+      >,
+      RetType
+    > = {
+      slug,
+      handler: handler as (
+        input: Simplify<
+          {
+            run: TFlowInput;
+          } & {
+            [K in Deps]: K extends keyof Steps ? Steps[K] : never;
+          }
+        >
+      ) => RetType | Promise<RetType>,
+      dependencies: dependencies as string[],
+      options,
+    };
+
+    const newStepDefinitions = {
+      ...this.stepDefinitions,
+      [slug]: newStepDefinition,
+    };
+
+    // Create a new stepOrder array with the new slug appended
+    const newStepOrder = [...this.stepOrder, slug];
+
+    // Create a new flow with the same slug and options but with updated type parameters
+    // We need to use type assertions here because TypeScript cannot track the exact relationship
+    // between the specific step definition types and the generic Flow type parameters
+    // This is safe because we're constructing the newStepDefinitions in a type-safe way above
+    return new Flow<TFlowInput, NewSteps, NewDependencies>(
+      { slug: this.slug, ...this.options },
+      newStepDefinitions as Record<string, StepDefinition<AnyInput, AnyOutput>>,
+      newStepOrder
+    ) as Flow<TFlowInput, NewSteps, NewDependencies>;
+  }
+}

package/src/example-flow.ts

@@ -0,0 +1,67 @@
+import { Flow } from './dsl.ts';
+
+// Provide a type for the input of the Flow
+type Input = {
+  url: string;
+};
+
+export const AnalyzeWebsite = new Flow<Input>({
+  slug: 'analyze_website',
+  maxAttempts: 3,
+  baseDelay: 5,
+  timeout: 10,
+})
+  .step(
+    { slug: 'website' },
+    async (input) => await scrapeWebsite(input.run.url)
+  )
+  .step(
+    { slug: 'sentiment', dependsOn: ['website'], timeout: 30, maxAttempts: 5 },
+    async (input) => await analyzeSentiment(input.website.content)
+  )
+  .step(
+    { slug: 'summary', dependsOn: ['website'] },
+    async (input) => await summarizeWithAI(input.website.content)
+  )
+  .step(
+    { slug: 'saveToDb', dependsOn: ['sentiment', 'summary'] },
+    async (input) => {
+      const results = await saveToDb({
+        websiteUrl: input.run.url,
+        sentiment: input.sentiment.score,
+        summary: input.summary.aiSummary,
+      });
+      return results.status;
+    }
+  );
+
+/***********************************************************************
+ ****** functions *******************************************************
+ ***********************************************************************/
+
+async function scrapeWebsite(url: string) {
+  return {
+    content: `Lorem ipsum ${url.length}`,
+  };
+}
+
+const analyzeSentiment = async (_content: string) => {
+  return {
+    score: Math.random(),
+  };
+};
+const summarizeWithAI = async (content: string) => {
+  return {
+    aiSummary: `Lorem ipsum ${content.length}`,
+  };
+};
+
+const saveToDb = async (_input: {
+  websiteUrl: string;
+  sentiment: number;
+  summary: string;
+}) => {
+  return {
+    status: 'success',
+  };
+};

package/src/index.ts

@@ -0,0 +1 @@
+export * from './dsl.ts';

package/src/utils.ts

@@ -0,0 +1,84 @@
+/**
+ * Validates a slug string according to the following rules:
+ * - Cannot start with a number
+ * - Cannot start with an underscore
+ * - Cannot contain spaces
+ * - Cannot contain special characters like /, :, ?, #
+ * - Cannot be longer than 128 characters
+ *
+ * @param slug The slug string to validate
+ * @throws Error if the slug is invalid
+ */
+export function validateSlug(slug: string): void {
+  if (slug.length > 128) {
+    throw new Error(`Slug cannot be longer than 128 characters`);
+  }
+
+  if (/^\d/.test(slug)) {
+    throw new Error(`Slug cannot start with a number`);
+  }
+
+  if (/^_/.test(slug)) {
+    throw new Error(`Slug cannot start with an underscore`);
+  }
+
+  if (/\s/.test(slug)) {
+    throw new Error(`Slug cannot contain spaces`);
+  }
+
+  if (/[/:#\-?]/.test(slug)) {
+    throw new Error(
+      `Slug cannot contain special characters like /, :, ?, #, -`
+    );
+  }
+}
+
+/**
+ * Options for validating runtime options
+ */
+export interface ValidateRuntimeOptionsOpts {
+  optional?: boolean;
+}
+
+/**
+ * Validates runtime options according to the following rules:
+ * - maxAttempts should be >= 1
+ * - baseDelay should be >= 1
+ * - timeout should be >= 3
+ *
+ * @param options The runtime options to validate
+ * @param opts Configuration options for validation
+ * @param opts.optional If true, allows options to be null or undefined
+ * @throws Error if any runtime option is invalid
+ */
+export function validateRuntimeOptions(
+  options: { maxAttempts?: number; baseDelay?: number; timeout?: number },
+  opts: ValidateRuntimeOptionsOpts = { optional: false }
+): void {
+  const { maxAttempts, baseDelay, timeout } = options;
+
+  // If optional is true, skip validation for undefined/null values
+  if (maxAttempts !== undefined && maxAttempts !== null) {
+    if (maxAttempts < 1) {
+      throw new Error('maxAttempts must be greater than or equal to 1');
+    }
+  } else if (!opts.optional) {
+    throw new Error('maxAttempts is required');
+  }
+
+  if (baseDelay !== undefined && baseDelay !== null) {
+    if (baseDelay < 1) {
+      throw new Error('baseDelay must be greater than or equal to 1');
+    }
+  } else if (!opts.optional) {
+    throw new Error('baseDelay is required');
+  }
+
+  if (timeout !== undefined && timeout !== null) {
+    if (timeout < 3) {
+      throw new Error('timeout must be greater than or equal to 3');
+    }
+  } else if (!opts.optional) {
+    throw new Error('timeout is required');
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,26 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
+    "emitDeclarationOnly": false,
+    "types": ["node", "vite/client"],
+    "allowImportingTsExtensions": true
+  },
+  "include": ["src/**/*.ts"],
+  "references": [],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/tsconfig.spec.json

@@ -0,0 +1,35 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/vitest",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ],
+    "allowImportingTsExtensions": true
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts",
+    "__tests__/**/*.ts"
+  ],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/typecheck.log

@@ -0,0 +1,120 @@
+
+> nx run dsl:typecheck
+
+> tsc --build --emitDeclarationOnly --pretty --verbose
+
+[9:57:14 PM] Projects in this build: 
+    * tsconfig.lib.json
+    * tsconfig.spec.json
+    * tsconfig.json
+
+[9:57:14 PM] Project 'tsconfig.lib.json' is up to date because newest input 'src/dsl.ts' is older than output 'dist/tsconfig.lib.tsbuildinfo'
+
+[9:57:14 PM] Project 'tsconfig.spec.json' is out of date because buildinfo file 'out-tsc/vitest/tsconfig.spec.tsbuildinfo' indicates that program needs to report errors.
+
+[9:57:14 PM] Building project '/home/jumski/Code/pgflow-dev/pgflow/pkgs/dsl/tsconfig.spec.json'...
+
+__tests__/types/dsl-types.test-d.ts:112:37 - error TS2344: Type 'Flow<{ input: string; }, EmptySteps & { step1: { value: number; text: string; }; } & { step2: { flag: true; }; } & { step3: "plain string"; }, EmptyDeps & { step1: never[]; } & { ...; } & { ...; }>' does not satisfy the constraint 'AnyFlow'.
+  The types returned by 'getStepDefinition(...)' are incompatible between these types.
+    Type 'StepDefinition<{ [x: string]: any; run: { input: string; }; }, any>' is not assignable to type 'StepDefinition<{ [x: string]: Json; run: Json; }, Json>'.
+      Type '{ [x: string]: Json; run: Json; }' is not assignable to type '{ [x: string]: any; run: { input: string; }; }'.
+        Types of property 'run' are incompatible.
+          Type 'Json' is not assignable to type '{ input: string; }'.
+            Type 'null' is not assignable to type '{ input: string; }'.
+
+112       type Step1Output = StepOutput<typeof flow, 'step1'>;
+                                        ~~~~~~~~~~~
+
+__tests__/types/dsl-types.test-d.ts:113:49 - error TS2344: Type '{ value: number; text: string; }' does not satisfy the constraint '"Expected: ..., Actual: never"'.
+
+113       expectTypeOf<Step1Output>().toMatchTypeOf<{
+                                                    ~
+114         value: number;
+    ~~~~~~~~~~~~~~~~~~~~~~
+115         text: string;
+    ~~~~~~~~~~~~~~~~~~~~~
+116       }>();
+    ~~~~~~~
+
+__tests__/types/dsl-types.test-d.ts:118:37 - error TS2344: Type 'Flow<{ input: string; }, EmptySteps & { step1: { value: number; text: string; }; } & { step2: { flag: true; }; } & { step3: "plain string"; }, EmptyDeps & { step1: never[]; } & { ...; } & { ...; }>' does not satisfy the constraint 'AnyFlow'.
+  The types returned by 'getStepDefinition(...)' are incompatible between these types.
+    Type 'StepDefinition<{ [x: string]: any; run: { input: string; }; }, any>' is not assignable to type 'StepDefinition<{ [x: string]: Json; run: Json; }, Json>'.
+      Type '{ [x: string]: Json; run: Json; }' is not assignable to type '{ [x: string]: any; run: { input: string; }; }'.
+        Types of property 'run' are incompatible.
+          Type 'Json' is not assignable to type '{ input: string; }'.
+            Type 'null' is not assignable to type '{ input: string; }'.
+
+118       type Step2Output = StepOutput<typeof flow, 'step2'>;
+                                        ~~~~~~~~~~~
+
+__tests__/types/dsl-types.test-d.ts:119:49 - error TS2344: Type '{ flag: boolean; }' does not satisfy the constraint '"Expected: ..., Actual: never"'.
+
+119       expectTypeOf<Step2Output>().toMatchTypeOf<{ flag: boolean }>();
+                                                    ~~~~~~~~~~~~~~~~~
+
+__tests__/types/dsl-types.test-d.ts:121:37 - error TS2344: Type 'Flow<{ input: string; }, EmptySteps & { step1: { value: number; text: string; }; } & { step2: { flag: true; }; } & { step3: "plain string"; }, EmptyDeps & { step1: never[]; } & { ...; } & { ...; }>' does not satisfy the constraint 'AnyFlow'.
+  The types returned by 'getStepDefinition(...)' are incompatible between these types.
+    Type 'StepDefinition<{ [x: string]: any; run: { input: string; }; }, any>' is not assignable to type 'StepDefinition<{ [x: string]: Json; run: Json; }, Json>'.
+      Type '{ [x: string]: Json; run: Json; }' is not assignable to type '{ [x: string]: any; run: { input: string; }; }'.
+        Types of property 'run' are incompatible.
+          Type 'Json' is not assignable to type '{ input: string; }'.
+            Type 'null' is not assignable to type '{ input: string; }'.
+
+121       type Step3Output = StepOutput<typeof flow, 'step3'>;
+                                        ~~~~~~~~~~~
+
+__tests__/types/dsl-types.test-d.ts:122:49 - error TS2344: Type 'string' does not satisfy the constraint '"Expected: string, Actual: never"'.
+
+122       expectTypeOf<Step3Output>().toMatchTypeOf<string>();
+                                                    ~~~~~~
+
+__tests__/types/dsl-types.test-d.ts:124:43 - error TS2344: Type 'Flow<{ input: string; }, EmptySteps & { step1: { value: number; text: string; }; } & { step2: { flag: true; }; } & { step3: "plain string"; }, EmptyDeps & { step1: never[]; } & { ...; } & { ...; }>' does not satisfy the constraint 'AnyFlow'.
+  The types returned by 'getStepDefinition(...)' are incompatible between these types.
+    Type 'StepDefinition<{ [x: string]: any; run: { input: string; }; }, any>' is not assignable to type 'StepDefinition<{ [x: string]: Json; run: Json; }, Json>'.
+      Type '{ [x: string]: Json; run: Json; }' is not assignable to type '{ [x: string]: any; run: { input: string; }; }'.
+        Types of property 'run' are incompatible.
+          Type 'Json' is not assignable to type '{ input: string; }'.
+            Type 'null' is not assignable to type '{ input: string; }'.
+
+124       type NonExistentOutput = StepOutput<typeof flow, 'nonExistentStep'>;
+                                              ~~~~~~~~~~~
+
+__tests__/types/dsl-types.test-d.ts:144:43 - error TS2344: Type 'Flow<{ id: number; }, EmptySteps & { complexStep: { data: { items: { id: number; name: string; }[]; metadata: { count: number; lastUpdated: string; }; }; }; }, EmptyDeps & { complexStep: never[]; }>' does not satisfy the constraint 'AnyFlow'.
+  The types returned by 'getStepDefinition(...)' are incompatible between these types.
+    Type 'StepDefinition<{ [x: string]: any; run: { id: number; }; }, any>' is not assignable to type 'StepDefinition<{ [x: string]: Json; run: Json; }, Json>'.
+      Type '{ [x: string]: Json; run: Json; }' is not assignable to type '{ [x: string]: any; run: { id: number; }; }'.
+        Types of property 'run' are incompatible.
+          Type 'Json' is not assignable to type '{ id: number; }'.
+            Type 'null' is not assignable to type '{ id: number; }'.
+
+144       type ComplexStepOutput = StepOutput<typeof complexFlow, 'complexStep'>;
+                                              ~~~~~~~~~~~~~~~~~~
+
+__tests__/types/dsl-types.test-d.ts:145:55 - error TS2344: Type '{ data: { items: { id: number; name: string; }[]; metadata: { count: number; lastUpdated: string; }; }; }' does not satisfy the constraint '"Expected: ..., Actual: never"'.
+
+145       expectTypeOf<ComplexStepOutput>().toMatchTypeOf<{
+                                                          ~
+146         data: {
+    ~~~~~~~~~~~~~~~
+... 
+152         };
+    ~~~~~~~~~~
+153       }>();
+    ~~~~~~~
+
+
+Found 9 errors.
+
+
+
+
+ NX   Running target typecheck for project dsl failed
+
+Failed tasks:
+
+- dsl:typecheck
+
+Hint: run the command with --verbose for more details.
+
+View structured, searchable error logs at https://nx.app/runs/7SrNf6iuVJ
+