@step-forge/step-forge 0.0.6 → 0.0.7-beta.1

package/src/when.ts

@@ -1,118 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import {
-  EmptyDependencies,
-  EmptyObject,
-  GetFunctionArgs,
-  isString,
-  RequiredOrOptional,
-  StepType,
-} from "./builderTypeUtils";
-import { addStep } from "./common";
-
-const whenDependencies =
-  <
-    Statement extends (...args: any[]) => string,
-    ResolvedStepType extends StepType,
-    Variables,
-    GivenState,
-    WhenState,
-  >(
-    statement: Statement,
-    stepType: ResolvedStepType
-  ) =>
-  <
-    GivenDeps extends RequiredOrOptional<GivenState>,
-    WhenDeps extends RequiredOrOptional<WhenState>,
-  >(dependencies: {
-    given?: GivenDeps;
-    when?: WhenDeps;
-  }) => {
-    type RestrictedGivenState = {
-      [K in keyof GivenState as K extends keyof GivenDeps
-        ? K
-        : never]: GivenDeps[K] extends "optional"
-        ? GivenState[K] | undefined
-        : GivenState[K];
-    };
-    type RestrictedWhenState = {
-      [K in keyof WhenState as K extends keyof WhenDeps
-        ? K
-        : never]: WhenDeps[K] extends "optional"
-        ? WhenState[K] | undefined
-        : WhenState[K];
-    };
-    type Dependencies = {
-      given: GivenDeps;
-      when: WhenDeps;
-      then: EmptyObject;
-    };
-    const fullDependencies: Dependencies = {
-      given: dependencies.given ?? ({} as GivenDeps),
-      when: dependencies.when ?? ({} as WhenDeps),
-      then: {},
-    };
-    return {
-      step: addStep<
-        ResolvedStepType,
-        Statement,
-        Dependencies,
-        Variables,
-        GivenState,
-        WhenState,
-        never,
-        RestrictedGivenState,
-        RestrictedWhenState,
-        never
-      >(statement, stepType, fullDependencies),
-    };
-  };
-
-const whenStatement =
-  <ResolvedStepType extends StepType, GivenState, WhenState>(
-    stepType: ResolvedStepType
-  ) =>
-  <Statement extends ((...args: [...any]) => string) | string>(
-    statement: Statement
-  ) => {
-    let normalizedStatement: Statement extends string
-      ? () => string
-      : Statement;
-    if (isString(statement)) {
-      normalizedStatement = (() => statement) as any;
-    } else {
-      normalizedStatement = statement as any;
-    }
-    type NormalizedStatement = typeof normalizedStatement;
-
-    type Variables = Statement extends string ? [] : GetFunctionArgs<Statement>;
-    const dependencyFunc = whenDependencies<
-      NormalizedStatement,
-      ResolvedStepType,
-      Variables,
-      GivenState,
-      WhenState
-    >(normalizedStatement, stepType);
-    const stepFunc = addStep<
-      ResolvedStepType,
-      NormalizedStatement,
-      EmptyDependencies,
-      Variables,
-      GivenState,
-      WhenState,
-      never,
-      never,
-      never,
-      never
-    >(normalizedStatement, stepType);
-    return {
-      dependencies: dependencyFunc,
-      step: stepFunc,
-    };
-  };
-
-export const whenBuilder = <GivenState, WhenState>() => {
-  return {
-    statement: whenStatement<"when", GivenState, WhenState>("when"),
-  };
-};

package/src/world.js

@@ -1,51 +0,0 @@
-import _ from "lodash";
-function mergeCustomizer(objValue, srcValue) {
-    if (_.isArray(objValue)) {
-        return objValue.concat(srcValue);
-    }
-    else if (objValue && !_.isPlainObject(objValue) && objValue !== srcValue) {
-        throw new Error(`Merge would have destroyed previous value ${objValue} with ${srcValue}`);
-    }
-    return objValue;
-}
-export const createMergeableState = (state) => {
-    return {
-        ...state,
-        merge: (newState) => {
-            state = _.merge({ ...state }, newState, mergeCustomizer);
-        },
-    };
-};
-export class BasicWorld {
-    givenState = {};
-    whenState = {};
-    thenState = {};
-    get given() {
-        return {
-            ...this.givenState,
-            merge: (newState) => {
-                this.givenState = _.merge({ ...this.givenState }, newState, mergeCustomizer);
-            },
-        };
-    }
-    get when() {
-        return {
-            ...this.whenState,
-            merge: (newState) => {
-                this.whenState = _.merge({ ...this.whenState }, newState, mergeCustomizer);
-            },
-        };
-    }
-    get then() {
-        return {
-            ...this.thenState,
-            merge: (newState) => {
-                this.thenState = _.merge({ ...this.thenState }, newState, mergeCustomizer);
-            },
-        };
-    }
-}
-export const createBasicWorld = () => {
-    return new BasicWorld();
-};
-//# sourceMappingURL=world.js.map

package/src/world.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"world.js","sourceRoot":"","sources":["world.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,QAAQ,CAAC;AAUvB,SAAS,eAAe,CAAC,QAAiB,EAAE,QAAiB;IAC3D,IAAI,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxB,OAAO,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IACnC,CAAC;SAAM,IAAI,QAAQ,IAAI,CAAC,CAAC,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC3E,MAAM,IAAI,KAAK,CACb,6CAA6C,QAAQ,SAAS,QAAQ,EAAE,CACzE,CAAC;IACJ,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,KAAoB,EACI,EAAE;IAC1B,OAAO;QACL,GAAG,KAAK;QACR,KAAK,EAAE,CAAC,QAAoB,EAAE,EAAE;YAC9B,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,EAAE,EAAE,QAAQ,EAAE,eAAe,CAAC,CAAC;QAC3D,CAAC;KACF,CAAC;AACJ,CAAC,CAAC;AAQF,MAAM,OAAO,UAAU;IACb,UAAU,GAAsB,EAAE,CAAC;IACnC,SAAS,GAAqB,EAAE,CAAC;IACjC,SAAS,GAAqB,EAAE,CAAC;IAEzC,IAAW,KAAK;QACd,OAAO;YACL,GAAG,IAAI,CAAC,UAAU;YAClB,KAAK,EAAE,CAAC,QAAwB,EAAE,EAAE;gBAClC,IAAI,CAAC,UAAU,GAAG,CAAC,CAAC,KAAK,CACvB,EAAE,GAAG,IAAI,CAAC,UAAU,EAAE,EACtB,QAAQ,EACR,eAAe,CAChB,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC;IAED,IAAW,IAAI;QACb,OAAO;YACL,GAAG,IAAI,CAAC,SAAS;YACjB,KAAK,EAAE,CAAC,QAAuB,EAAE,EAAE;gBACjC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,CACtB,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,EACrB,QAAQ,EACR,eAAe,CAChB,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC;IAED,IAAW,IAAI;QACb,OAAO;YACL,GAAG,IAAI,CAAC,SAAS;YACjB,KAAK,EAAE,CAAC,QAAuB,EAAE,EAAE;gBACjC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,KAAK,CACtB,EAAE,GAAG,IAAI,CAAC,SAAS,EAAE,EACrB,QAAQ,EACR,eAAe,CAChB,CAAC;YACJ,CAAC;SACF,CAAC;IACJ,CAAC;CACF;AAED,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAI9B,EAAE;IACF,OAAO,IAAI,UAAU,EAAqB,CAAC;AAC7C,CAAC,CAAC"}

package/src/world.ts

@@ -1,90 +0,0 @@
-import _ from "lodash";
-
-export type WorldState<State> = {
-  readonly [K in keyof State]?: State[K];
-};
-
-export type MergeableWorldState<T> = WorldState<T> & {
-  merge: (newState: Partial<T>) => void;
-};
-
-function mergeCustomizer(objValue: unknown, srcValue: unknown) {
-  if (_.isArray(objValue)) {
-    return objValue.concat(srcValue);
-  } else if (objValue && !_.isPlainObject(objValue) && objValue !== srcValue) {
-    throw new Error(
-      `Merge would have destroyed previous value ${objValue} with ${srcValue}`
-    );
-  }
-  return objValue;
-}
-
-export const createMergeableState = <T>(
-  state: WorldState<T>
-): MergeableWorldState<T> => {
-  return {
-    ...state,
-    merge: (newState: Partial<T>) => {
-      state = _.merge({ ...state }, newState, mergeCustomizer);
-    },
-  };
-};
-
-export type MergeableWorld<Given, When, Then> = {
-  given: MergeableWorldState<Given>;
-  when: MergeableWorldState<When>;
-  then: MergeableWorldState<Then>;
-};
-
-export class BasicWorld<Given, When, Then> {
-  private givenState: WorldState<Given> = {};
-  private whenState: WorldState<When> = {};
-  private thenState: WorldState<Then> = {};
-
-  public get given(): MergeableWorldState<Given> {
-    return {
-      ...this.givenState,
-      merge: (newState: Partial<Given>) => {
-        this.givenState = _.merge(
-          { ...this.givenState },
-          newState,
-          mergeCustomizer
-        );
-      },
-    };
-  }
-
-  public get when(): MergeableWorldState<When> {
-    return {
-      ...this.whenState,
-      merge: (newState: Partial<When>) => {
-        this.whenState = _.merge(
-          { ...this.whenState },
-          newState,
-          mergeCustomizer
-        );
-      },
-    };
-  }
-
-  public get then(): MergeableWorldState<Then> {
-    return {
-      ...this.thenState,
-      merge: (newState: Partial<Then>) => {
-        this.thenState = _.merge(
-          { ...this.thenState },
-          newState,
-          mergeCustomizer
-        );
-      },
-    };
-  }
-}
-
-export const createBasicWorld = <Given, When, Then>(): MergeableWorld<
-  Given,
-  When,
-  Then
-> => {
-  return new BasicWorld<Given, When, Then>();
-};

package/test/givenCompilationTests.ts

@@ -1,130 +0,0 @@
-import { givenBuilder } from "../src/given";
-import { SampleGivenState } from "./testUtils";
-
-// Simplest possible example
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  .step(() => {
-    return {
-      a: "user",
-    };
-  });
-
-// Simple dependency example
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  .dependencies({
-    given: {
-      a: "required",
-    },
-  })
-  .step(({ given }) => {
-    return {
-      b: `I love ${given.a}`,
-    };
-  });
-
-// Simple variables example
-givenBuilder<SampleGivenState>()
-  .statement((v1: string, v2: number) => `Given a user ${v1} ${v2}`)
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      b: `I love ${v1} ${v2}`,
-    };
-  });
-
-// Complex example
-givenBuilder<SampleGivenState>()
-  .statement((v1: string, v2: number) => `Given a user ${v1} ${v2}`)
-  .dependencies({
-    given: {
-      a: "required",
-      b: "optional",
-      c: "required",
-    },
-  })
-  .step(({ variables: [v1, v2], given: { a, b, c } }) => {
-    return {
-      b: `I love ${v1} ${v2} ${a} ${b} ${c}`,
-    };
-  });
-
-// ----- Should not compile section ----
-
-// @ts-expect-error - Should not compile without a statement
-givenBuilder<SampleGivenState>().step(() => {
-  return {
-    a: "user",
-  };
-});
-
-givenBuilder<SampleGivenState>()
-  .statement(() => "Given a user")
-  // @ts-expect-error - Should not compile since no variables are declared
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      a: `I love ${v1} ${v2}`,
-    };
-  });
-
-// TODO: Currently resolves variables to `any[]` which is incorrect
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  // @ts-expect-error - Should not compile since no variables are declared
-  .step(({ variables: [v1, v2] }) => {
-    return {
-      a: `I love ${v1} ${v2}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement(
-    (v1: string, v2: number, v3: boolean) => `Given a user ${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: `I love ${v1} ${v2} ${v3} ${v4}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  .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
-      b: `I love ${given.b}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement("a user")
-  // @ts-expect-error - Should not compile if we attempt to access a part of state that was not declared as a dependency
-  .dependencies({ when: { a: "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
-      b: `I love ${when.c}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  .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 {
-      b: `I love ${strictA}`,
-    };
-  });
-
-givenBuilder<SampleGivenState>()
-  .statement("Given a user")
-  // @ts-expect-error - Should not compile since the return type is not a partial of given state
-  .step(() => {
-    return {
-      f: "hello",
-    };
-  });

package/test/testUtils.ts

@@ -1,30 +0,0 @@
-import { createBasicWorld } from "../src/world";
-
-export const sampleGivenState = {
-  a: "stuff",
-  b: "things",
-  c: 3,
-};
-export type SampleGivenState = typeof sampleGivenState;
-
-export const sampleWhenState = {
-  d: 1,
-  e: "other stuff",
-  f: [3, 4, 5],
-};
-export type SampleWhenState = typeof sampleWhenState;
-
-export const sampleThenState = {
-  g: 1,
-  h: 2,
-  i: { j: "k" },
-};
-export type SampleThenState = typeof sampleThenState;
-
-export const sampleWorld = createBasicWorld<
-  SampleGivenState,
-  SampleWhenState,
-  SampleThenState
->();
-
-export type SampleWorld = typeof sampleWorld;

package/test/thenCompilationTests.ts

@@ -1,207 +0,0 @@
-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",
-    };
-  });