improve(anyware): extensions (#1264)

This PR brings extensions to anyware. The HTTP and Memory transports are moved to being anyware extensions now. The next step is to lift them one level up into Graffle extensions. This will require the ability to statically apply anyware extensions (should be fairly simple).

Author: jasonkuhrt

examples/__outputs__/20_output/output_preset__standard-graphql.output.txt

@@ -13,14 +13,14 @@ ContextualError: There was an error in the core implementation of hook "exchange
   context: { hookName: 'exchange', source: 'implementation' },
   [cause]: TypeError: Failed to parse URL from ...
       at new Request (node:internal/deps/undici/undici:XX:XX)
-      at Object.run (/some/path/to/RequestPipeline.ts:XX:XX:27)
+      at Object.run (/some/path/to/httpTransport.ts:XX:XX:27)
       ... 6 lines matching cause stack trace ...
       at async Module.run (/some/path/to/run.ts:XX:XX:10)
       at async Object.send (/some/path/to/gql.ts:XX:XX:26) {
     [cause]: TypeError: Invalid URL
         at new URL (node:internal/url:XX:XX)
         at new Request (node:internal/deps/undici/undici:XX:XX)
-        at Object.run (/some/path/to/RequestPipeline.ts:XX:XX:27)
+        at Object.run (/some/path/to/httpTransport.ts:XX:XX:27)
         at Object.run (/some/path/to/builder.ts:XX:XX:53)
         at runStep (/some/path/to/runStep.ts:XX:XX:37)
         at runPipeline (/some/path/to/runPipeline.ts:XX:XX:8)

src/lib/anyware/Extension/Builder.ts

@@ -0,0 +1,31 @@
+import type { ConfigManager } from '../../config-manager/__.js'
+import type { Overload } from '../Overload/__.js'
+import type { Pipeline } from '../Pipeline/__.js'
+
+export interface Builder<
+  $PipelineContext extends Pipeline.Context = Pipeline.Context,
+  $Context extends Context = Context,
+> {
+  context: $Context
+  /**
+   * TODO
+   */
+  overload: <$OverloadBuilder extends Overload.Builder<$PipelineContext>>(
+    overloadBuilder: Overload.BuilderCallback<$PipelineContext, $OverloadBuilder>,
+  ) => Builder<
+    $PipelineContext,
+    ConfigManager.AppendAtKey<
+      $Context,
+      'overloads',
+      $OverloadBuilder['context']
+    >
+  >
+}
+
+export interface Context {
+  overloads: Overload.BuilderContext[]
+}
+
+export interface ContextEmpty extends Context {
+  overloads: []
+}

src/lib/anyware/Extension/Extension.ts

@@ -0,0 +1,25 @@
+import { __ } from '../../prelude.js'
+import { Overload } from '../Overload/__.js'
+import type { Pipeline } from '../Pipeline/__.js'
+import type { Builder, Context, ContextEmpty } from './Builder.js'
+
+export * from './Builder.js'
+
+export const create: Create = () => {
+  const context: Context = {
+    overloads: [],
+  }
+
+  const builder: Builder = {
+    context,
+    overload: (builderCallback) => {
+      const overload = builderCallback({ create: Overload.create })
+      context.overloads.push(overload.context)
+      return builder as any
+    },
+  }
+
+  return builder as any
+}
+
+type Create = <$PipelineContext extends Pipeline.Context>() => Builder<$PipelineContext, ContextEmpty>

src/lib/anyware/Extension/__.ts

@@ -0,0 +1 @@
+export * as Extension from './Extension.js'

src/lib/anyware/Overload/Builder.ts

@@ -0,0 +1,103 @@
+import type { ConfigManager } from '../../config-manager/__.js'
+import type { Tuple } from '../../prelude.js'
+import type { Pipeline } from '../Pipeline/__.js'
+import type { Step } from '../Step.js'
+
+export interface Builder<
+  $RootContext extends Pipeline.Context = Pipeline.Context,
+  $Context extends BuilderContext = BuilderContextEmpty,
+> {
+  context: $Context
+  /**
+   * TODO
+   */
+  step: BuilderStep<$RootContext, $Context>
+  /**
+   * TODO
+   */
+  extendInput: <$InputExtension extends object>() => Builder<
+    $RootContext,
+    ConfigManager.UpdateOneKey<$Context, 'input', $InputExtension>
+  >
+  /**
+   * TODO
+   */
+  stepWithExtendedInput: <$InputExtension extends object>() => BuilderStep<
+    $RootContext,
+    $Context,
+    $InputExtension
+  >
+}
+
+interface BuilderStep<
+  $RootContext extends Pipeline.Context,
+  $Context extends BuilderContext,
+  $InputExtension extends object = {},
+> {
+  <
+    $Name extends $RootContext['steps'][number]['name'],
+    $Slots extends undefined | Step.Slots = undefined,
+    $Input =
+      & InferStepInput<
+        $Context,
+        Extract<$RootContext['steps'][number], { name: $Name }>,
+        Tuple.PreviousItem<$RootContext['steps'], { name: $Name }>
+      >
+      & $InputExtension,
+    $Output = unknown,
+  >(
+    name: $Name,
+    spec: {
+      slots?: $Slots
+      run: (input: $Input, slots: $Slots) => $Output
+    },
+  ): Builder<
+    $RootContext,
+    ConfigManager.UpdateOneKey<
+      $Context,
+      'steps',
+      & $Context['steps']
+      & {
+        [_ in $Name]: {
+          name: $Name
+          input: $Input
+          output: Awaited<$Output>
+          slots: ConfigManager.OrDefault2<$Slots, {}>
+        }
+      }
+    >
+  >
+}
+
+// dprint-ignore
+type InferStepInput<
+  $OverloadContext extends BuilderContext,
+  $CurrentStep extends Step,
+  $PreviousStep extends Step | undefined,
+> =
+  $PreviousStep extends Step
+    ? $PreviousStep['name'] extends keyof $OverloadContext['steps']
+      ? $OverloadContext['steps'][$PreviousStep['name']]['output']
+      :
+        & $CurrentStep['input']
+        & $OverloadContext['input']
+        & { [_ in $OverloadContext['discriminant'][0]]: $OverloadContext['discriminant'][1] }
+      :
+        & $CurrentStep['input']
+        & $OverloadContext['input']
+        & { [_ in $OverloadContext['discriminant'][0]]: $OverloadContext['discriminant'][1] }
+
+export interface BuilderContext {
+  discriminant: DiscriminantSpec
+  input: object
+  steps: Record<string, Step>
+}
+
+export type DiscriminantSpec = readonly [string, DiscriminantPropertyValue]
+
+export type DiscriminantPropertyValue = string | number | symbol
+
+interface BuilderContextEmpty extends BuilderContext {
+  input: {}
+  steps: {}
+}

src/lib/anyware/Overload/Overload.ts

@@ -0,0 +1,49 @@
+import type { Pipeline } from '../Pipeline/__.js'
+import type { Step } from '../Step.js'
+import type { Overload } from './__.js'
+import type { Builder, BuilderContext, DiscriminantSpec } from './Builder.js'
+
+export * from './Builder.js'
+
+export const create: Create = (parameters) => {
+  const context_: Omit<BuilderContext, 'input'> = {
+    discriminant: parameters.discriminant,
+    steps: {},
+  }
+  const context = context_ as BuilderContext
+
+  const builder: Builder = {
+    context,
+    extendInput: () => builder as any,
+    stepWithExtendedInput: () => builder.step as any,
+    step: (name, spec) => {
+      context.steps[name] = {
+        name,
+        ...spec,
+      } as unknown as Step
+      return builder as any
+    },
+  }
+
+  return builder as any
+}
+
+export type Create<$RootContext extends Pipeline.Context = Pipeline.Context> = <
+  const $DiscriminantSpec extends DiscriminantSpec,
+>(
+  parameters: { discriminant: $DiscriminantSpec },
+) => Builder<
+  $RootContext,
+  {
+    discriminant: $DiscriminantSpec
+    input: {}
+    steps: {}
+  }
+>
+
+export type BuilderCallback<
+  $Context extends Pipeline.Context,
+  $OverloadBuilder extends Builder<$Context>,
+> = (
+  overloadBuilder: { create: Overload.Create<$Context> },
+) => $OverloadBuilder

src/lib/anyware/Overload/__.ts

@@ -0,0 +1 @@
+export * as Overload from './Overload.js'

src/lib/anyware/Pipeline/builder.test-d.ts

@@ -126,10 +126,13 @@ describe(`overload`, () => {
         [{ discriminant: d; input: {}; steps: {} }]
       >()
     })
-    test(`overload constructor with input and discriminant`, () => {
-      expectTypeOf(b0.overload(o => o.createWithInput<{ x: 1 }>()({ discriminant: d })).context.overloads)
-        .toMatchTypeOf<[{ discriminant: d; input: { x: 1 }; steps: {} }]>()
-    })
+  })
+
+  // overload extends input
+
+  test(`overload constructor with input and discriminant`, () => {
+    expectTypeOf(b0.overload(o => o.create({ discriminant: d }).extendInput<{ x: 1 }>()).context.overloads)
+      .toMatchTypeOf<[{ discriminant: d; input: { x: 1 }; steps: {} }]>()
   })
 
   // step
@@ -171,7 +174,7 @@ describe(`overload`, () => {
   test(`can extend input type`, () => {
     expectTypeOf(
       b0.step(`a`).overload(o =>
-        o.create({ discriminant: d }).stepWithInputExtension<{ ex: 1 }>()(`a`, {
+        o.create({ discriminant: d }).stepWithExtendedInput<{ ex: 1 }>()(`a`, {
           run: (input) => {
             expectTypeOf(input).toEqualTypeOf<initialInput & dObject & { ex: 1 }>()
           },
@@ -242,11 +245,11 @@ describe(`overload`, () => {
 
   // Overloads Merging Into Pipeline
 
-  test(`overload inputs become a pipeline union input`, () => {
+  test(`overload input extensions become a pipeline union input`, () => {
     const p = b0
       .step(`a`)
-      .overload(o => o.createWithInput<{ ol1: 1 }>()({ discriminant: d }))
-      .overload(o => o.createWithInput<{ ol2: 2 }>()({ discriminant: d2 }))
+      .overload(o => o.create({ discriminant: d }).extendInput<{ ol1: 1 }>())
+      .overload(o => o.create({ discriminant: d2 }).extendInput<{ ol2: 2 }>())
       .done()
     expectTypeOf(p.input).toMatchTypeOf<
       | (initialInput & dObject & { ol1: 1 })