@step-forge/step-forge 0.0.7-beta.6 → 0.0.7

package/test/thenCompilationTests.ts

@@ -0,0 +1,207 @@
+import { thenBuilder } from "../src/then";
+import {
+  SampleGivenState,
+  SampleThenState,
+  SampleWhenState,
+} from "./testUtils";
+
+// Simplest possible example
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .step(() => {
+    return {
+      i: { j: "result" },
+    };
+  });
+
+// Simple dependency on given state example
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .dependencies({
+    given: {
+      a: "required",
+    },
+  })
+  .step(({ given }) => {
+    return {
+      i: { j: `Result with ${given.a}` },
+    };
+  });
+
+// Simple dependency on when state example
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .dependencies({
+    when: {
+      d: "required",
+    },
+  })
+  .step(({ when }) => {
+    return {
+      i: { j: `Result with ${when.d}` },
+    };
+  });
+
+// Simple dependency on then state example
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .dependencies({
+    then: {
+      g: "required",
+    },
+  })
+  .step(({ then }) => {
+    return {
+      i: { j: `Result with ${then.g}` },
+    };
+  });
+
+// Simple variables example
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement((v1: string, v2: number) => `Then we should see ${v1} ${v2} times`)
+  .step(({ variables: [v1, v2] }) => {
+    return {
+      i: { j: `Result ${v1} ${v2}` },
+    };
+  });
+
+// Complex example with all dependencies
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement((v1: string, v2: number) => `Then we should see ${v1} ${v2} times`)
+  .dependencies({
+    given: {
+      a: "required",
+      b: "optional",
+    },
+    when: {
+      d: "required",
+      e: "optional",
+    },
+    then: {
+      g: "required",
+      h: "optional",
+    },
+  })
+  .step(
+    ({
+      variables: [v1, v2],
+      given: { a, b },
+      when: { d, e },
+      then: { g, h },
+    }) => {
+      return {
+        i: { j: `Result ${v1} ${v2} with ${a} ${b} ${d} ${e} ${g} ${h}` },
+      };
+    }
+  );
+
+// ----- Should not compile section ----
+
+// @ts-expect-error - Should not compile without a statement
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>().step(() => {
+  return {
+    i: { j: "result" },
+  };
+});
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement(() => "Then we should see something")
+  // @ts-expect-error - Should not compile since no variables are declared
+  .step(({ variables: [v1, v2] }) => {
+    return {
+      i: { j: `Result ${v1} ${v2}` },
+    };
+  });
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  // @ts-expect-error - Should not compile since no variables are declared
+  .step(({ variables: [v1, v2] }) => {
+    return {
+      i: { j: `Result ${v1} ${v2}` },
+    };
+  });
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement(
+    (v1: string, v2: number, v3: boolean) =>
+      `Then we should see ${v1} ${v2} ${v3}`
+  )
+  // @ts-expect-error - Should not compile since the number of variables exceeds the number declared
+  .step(({ variables: [v1, v2, v3, v4] }) => {
+    return {
+      i: { j: `Result ${v1} ${v2} ${v3} ${v4}` },
+    };
+  });
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .dependencies({ given: { a: "required" } })
+  .step(({ given }) => {
+    return {
+      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
+      i: { j: `Result ${given.b}` },
+    };
+  });
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .dependencies({ when: { d: "required" } })
+  .step(({ when }) => {
+    return {
+      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
+      i: { j: `Result ${when.f}` },
+    };
+  });
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .dependencies({ then: { g: "required" } })
+  .step(({ then }) => {
+    return {
+      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
+      i: { j: `Result ${then.i}` },
+    };
+  });
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .dependencies({ given: { a: "optional" } })
+  .step(({ given }) => {
+    // @ts-expect-error - Should not compile since a is optional and can be undefined
+    const strictA: string = given.a;
+    return {
+      i: { j: `Result ${strictA}` },
+    };
+  });
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .dependencies({ when: { e: "optional" } })
+  .step(({ when }) => {
+    // @ts-expect-error - Should not compile since e is optional and can be undefined
+    const strictE: string = when.e;
+    return {
+      i: { j: `Result ${strictE}` },
+    };
+  });
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  .dependencies({ then: { h: "optional" } })
+  .step(({ then }) => {
+    // @ts-expect-error - Should not compile since h is optional and can be undefined
+    const strictH: string = then.h;
+    return {
+      i: { j: `Result ${strictH}` },
+    };
+  });
+
+thenBuilder<SampleGivenState, SampleWhenState, SampleThenState>()
+  .statement("Then we should see something")
+  // @ts-expect-error - Should not compile since the return type is not a partial of then state
+  .step(() => {
+    return {
+      a: "hello",
+    };
+  });

package/test/whenCompilationTests.ts

@@ -0,0 +1,157 @@
+import { whenBuilder } from "../src/when";
+import { SampleGivenState, SampleWhenState } from "./testUtils";
+
+// Simplest possible example
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement("When a user does something")
+  .step(() => {
+    return {
+      e: "action",
+    };
+  });
+
+// Simple dependency on given state example
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement("When a user does something")
+  .dependencies({
+    given: {
+      a: "required",
+    },
+  })
+  .step(({ given }) => {
+    return {
+      e: `Action with ${given.a}`,
+    };
+  });
+
+// Simple dependency on when state example
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement("When a user does something")
+  .dependencies({
+    when: {
+      d: "required",
+    },
+  })
+  .step(({ when }) => {
+    return {
+      e: `Action with ${when.d}`,
+    };
+  });
+
+// Simple variables example
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement((v1: string, v2: number) => `When a user does ${v1} ${v2} times`)
+  .step(({ variables: [v1, v2] }) => {
+    return {
+      e: `Action ${v1} ${v2}`,
+    };
+  });
+
+// Complex example with both dependencies
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement((v1: string, v2: number) => `When a user does ${v1} ${v2} times`)
+  .dependencies({
+    given: {
+      a: "required",
+      b: "optional",
+    },
+    when: {
+      d: "required",
+      e: "optional",
+    },
+  })
+  .step(({ variables: [v1, v2], given: { a, b }, when: { d, e } }) => {
+    return {
+      e: `Action ${v1} ${v2} with ${a} ${b} ${d} ${e}`,
+    };
+  });
+
+// ----- Should not compile section ----
+
+// @ts-expect-error - Should not compile without a statement
+whenBuilder<SampleGivenState, SampleWhenState>().step(() => {
+  return {
+    a: "action",
+  };
+});
+
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement(() => "When a user does something")
+  // @ts-expect-error - Should not compile since no variables are declared
+  .step(({ variables: [v1, v2] }) => {
+    return {
+      a: `Action ${v1} ${v2}`,
+    };
+  });
+
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement("When a user does something")
+  // @ts-expect-error - Should not compile since no variables are declared
+  .step(({ variables: [v1, v2] }) => {
+    return {
+      a: `Action ${v1} ${v2}`,
+    };
+  });
+
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement(
+    (v1: string, v2: number, v3: boolean) =>
+      `When a user does ${v1} ${v2} ${v3}`
+  )
+  // @ts-expect-error - Should not compile since the number of variables exceeds the number declared
+  .step(({ variables: [v1, v2, v3, v4] }) => {
+    return {
+      a: `Action ${v1} ${v2} ${v3} ${v4}`,
+    };
+  });
+
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement("When a user does something")
+  .dependencies({ given: { a: "required" } })
+  .step(({ given }) => {
+    return {
+      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
+      e: `Action ${given.b}`,
+    };
+  });
+
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement("When a user does something")
+  .dependencies({ when: { d: "required" } })
+  .step(({ when }) => {
+    return {
+      // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
+      e: `Action ${when.f}`,
+    };
+  });
+
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement("When a user does something")
+  .dependencies({ given: { a: "optional" } })
+  .step(({ given }) => {
+    // @ts-expect-error - Should not compile since a is optional and can be undefined
+    const strictA: string = given.a;
+    return {
+      e: `Action ${strictA}`,
+    };
+  });
+
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement("When a user does something")
+  .dependencies({ when: { e: "optional" } })
+  .step(({ when }) => {
+    // @ts-expect-error - Should not compile since a is optional and can be undefined
+    const strictE: string = when.e;
+    return {
+      f: [strictE.length],
+    };
+  });
+
+whenBuilder<SampleGivenState, SampleWhenState>()
+  .statement("When a user does something")
+  // @ts-expect-error - Should not compile since the return type is not a partial of when state
+  .step(() => {
+    return {
+      a: "hello",
+    };
+  });

package/ts-node-esm-register.js

@@ -0,0 +1,8 @@
+import { register } from "ts-node";
+
+register({
+  project: "./tsconfig.cucumber.json",
+  esm: true,
+  experimentalSpecifierResolution: "node",
+  transpileOnly: true,
+});

package/tsconfig.cucumber.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "allowJs": true,
+    "esModuleInterop": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "moduleDetection": "force"
+  },
+  "include": ["features/**/*.ts", "src/**/*.ts"],
+  "exclude": ["node_modules", "src/vite-env.d.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "rootDir": ".",
+    "paths": {
+      "@/*": ["./src/*"],
+      "@@/*": ["./*"]
+    },
+    "target": "ESNext",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ESNext", "DOM"],
+    "moduleResolution": "Node",
+    "strict": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": ["node"],
+    "declaration": true,
+    "declarationDir": "./build/dist/types"
+  },
+  "include": ["src"],
+  "exclude": ["**/*.test.ts", "node_modules", "test/**", ".history/**"]
+}