@distilled.cloud/core 1.0.0-rc.11 → 1.0.0-rc.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@distilled.cloud/core",
-  "version": "1.0.0-rc.11",
+  "version": "1.0.0-rc.13",
   "repository": {
     "type": "git",
     "url": "https://github.com/alchemy-run/distilled",
@@ -28,13 +28,13 @@
     }
   },
   "devDependencies": {
-    "@effect/platform-bun": ">=4.0.0-rc.115 || >=4.0.0",
+    "@effect/platform-bun": "^4.0.0",
     "@types/bun": "1.3.14",
     "@types/node": "26.2.0",
-    "effect": ">=4.0.0-rc.115 || >=4.0.0"
+    "effect": "^4.0.0"
   },
   "peerDependencies": {
-    "effect": ">=4.0.0-rc.115 || >=4.0.0"
+    "effect": "^4.0.0"
   },
   "dependencies": {
     "graphql": "16.11.0"

package/src/api.ts

@@ -11,10 +11,10 @@ import type * as Stream from "effect/Stream";
 import { SingleShotGen } from "effect/Utils";
 import * as Pagination from "./pagination.ts";
 import { makeDefault, type Policy as RetryPolicy } from "./retry.ts";
-import * as HttpClient from "effect/unstable/http/HttpClient";
-import type * as HttpClientError from "effect/unstable/http/HttpClientError";
-import type * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
-import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import * as HttpClient from "effect/http/HttpClient";
+import type * as HttpClientError from "effect/http/HttpClientError";
+import type * as HttpClientRequest from "effect/http/HttpClientRequest";
+import type * as HttpClientResponse from "effect/http/HttpClientResponse";
 
 //#region Protocol
 

package/src/category.ts

@@ -20,7 +20,7 @@
  */
 import * as Effect from "effect/Effect";
 import * as Predicate from "effect/Predicate";
-import * as HttpClientError from "effect/unstable/http/HttpClientError";
+import * as HttpClientError from "effect/http/HttpClientError";
 
 // ============================================================================
 // Error Category Constants

package/src/codegen/boolean-string-enums.test.ts

@@ -123,6 +123,108 @@ describe("booleanStringEnums", () => {
 });
 
 describe("generateService", () => {
+  test("member schema overrides retain nullability, query bindings and protocol traits", () => {
+    const { code } = generateService(
+      model({
+        "ns#Example": {
+          type: "service",
+          version: "1",
+          operations: [{ target: "ns#GetThing" }],
+        },
+        "ns#GetThing": {
+          type: "operation",
+          input: { target: "ns#Input" },
+          output: { target: "smithy.api#Unit" },
+          traits: { "smithy.api#http": { method: "GET", uri: "/things" } },
+        },
+        "ns#Input": {
+          type: "structure",
+          members: {
+            secret: {
+              target: "smithy.api#String",
+              traits: {
+                "smithy.api#httpQuery": "secret",
+                "smithy.api#sensitive": {},
+                "ns#nullable": {},
+              },
+            },
+          },
+        },
+      }),
+      {
+        nullableTrait: "ns#nullable",
+        memberSchema: (member, ref) =>
+          `S.Union([${ref(member.target)}, S.Redacted(${ref(member.target)})])`,
+        memberTraitPipes: { "smithy.api#sensitive": "T.SensitiveValue" },
+        operationDecl: {
+          contextType: "ExampleOpContext",
+          commonErrorType: "ExampleOpError",
+          commonErrorClasses: [],
+          protocol: "ExampleProtocol",
+          retry: "Retry.Retry",
+        },
+      },
+    );
+    expect(code).toContain(
+      '"secret": S.optional(S.NullOr(S.Union([S.String, S.Redacted(S.String)])).pipe(T.Query(), T.SensitiveValue({})))',
+    );
+  });
+
+  test("service-free schemas preserve Codec annotations across structures, collections and raw outputs", () => {
+    const input = model({
+      "ns#Example": {
+        type: "service",
+        version: "1",
+        operations: [{ target: "ns#GetThing" }],
+      },
+      "ns#GetThing": {
+        type: "operation",
+        input: { target: "ns#Input" },
+        output: { target: "ns#Output" },
+        traits: { "smithy.api#http": { method: "GET", uri: "/things" } },
+      },
+      "ns#Input": {
+        type: "structure",
+        members: { list: { target: "ns#List" }, map: { target: "ns#Map" } },
+      },
+      "ns#List": { type: "list", member: { target: "smithy.api#String" } },
+      "ns#Map": {
+        type: "map",
+        key: { target: "smithy.api#String" },
+        value: { target: "smithy.api#String" },
+      },
+      "ns#Output": {
+        type: "structure",
+        members: { body: { target: "ns#List", traits: { "ns#raw": {} } } },
+      },
+    });
+    const spec = {
+      extraBindings: [
+        {
+          trait: "ns#raw",
+          binding: "rawResponse",
+          pipe: "T.RawResponse()",
+          rootPipe: "T.RawResponseRoot()",
+        },
+      ],
+      operationDecl: {
+        contextType: "ExampleOpContext",
+        commonErrorType: "ExampleOpError",
+        commonErrorClasses: [],
+        protocol: "ExampleProtocol",
+        retry: "Retry.Retry",
+      },
+    } as const;
+    const { code } = generateService(input, { ...spec, schemaType: "Codec" });
+    for (const name of ["Input", "List", "Map", "Output"]) {
+      expect(code).toContain(`as any as S.Codec<${name}>`);
+    }
+    expect(code).not.toContain("S.Schema<");
+    expect(generateService(input, spec).code).toContain(
+      "as any as S.Schema<Input>",
+    );
+  });
+
   test("emits a boolean piped through T.StringEncoded()", () => {
     const { code } = generateService(
       model({
@@ -166,3 +268,48 @@ describe("generateService", () => {
     expect(code).not.toContain('"true" | "false"');
   });
 });
+
+describe("nested structures", () => {
+  const nested = (sharedWithResponse: boolean) =>
+    model({
+      "com.example.x#GetThing": {
+        type: "operation",
+        input: { target: "com.example.x#GetThingRequest" },
+        output: { target: "com.example.x#GetThingResponse" },
+      },
+      "com.example.x#GetThingRequest": {
+        type: "structure",
+        traits: { "smithy.api#input": {} },
+        members: { profile: { target: "com.example.x#Profile" } },
+      },
+      "com.example.x#GetThingResponse": {
+        type: "structure",
+        traits: { "smithy.api#output": {} },
+        members: sharedWithResponse
+          ? { profile: { target: "com.example.x#Profile" } }
+          : {},
+      },
+      "com.example.x#Profile": {
+        type: "structure",
+        members: { dynamicMemoryEnabled: { target: "com.example.x#Flag" } },
+      },
+      "com.example.x#Flag": boolEnum,
+    });
+
+  test("retargets a member of a structure only requests reach", () => {
+    const m = nested(false);
+    expect(booleanStringEnums(m)).toEqual({ members: 1, lists: 0 });
+    const member =
+      m.shapes["com.example.x#Profile"].members.dynamicMemoryEnabled;
+    expect(member.target).toBe("smithy.api#Boolean");
+    expect(member.traits[STRING_ENCODED_TRAIT]).toEqual({});
+  });
+
+  test("leaves a structure a response also delivers", () => {
+    const m = nested(true);
+    expect(booleanStringEnums(m)).toEqual({ members: 0, lists: 0 });
+    expect(
+      m.shapes["com.example.x#Profile"].members.dynamicMemoryEnabled.target,
+    ).toBe("com.example.x#Flag");
+  });
+});

package/src/codegen/boolean-string-enums.ts

@@ -10,17 +10,17 @@
  * {@link generateService} runs this pass over the loaded model before
  * emitting: REQUEST members of such an enum are retargeted to a real
  * `smithy.api#Boolean` and stamped {@link STRING_ENCODED_TRAIT}, which the
- * generator emits as `T.StringEncoded()` and the protocol's `buildRequest`
- * honors by sending the value's string spelling. The TS surface becomes
- * `boolean` with the wire unchanged. The model on disk keeps the string
- * enum the description documents.
+ * generator emits as `T.StringEncoded()` and the protocol honors by sending
+ * the value's string spelling. The TS surface becomes `boolean` with the
+ * wire unchanged. The model on disk keeps the string enum the description
+ * documents.
  *
  * Deliberately narrow:
  *
- *   • request shapes only (`smithy.api#input`) — a response member would
- *     need the mirror-image decode, which the protocol does not do;
- *   • a list member is retargeted only when EVERY reference to that list
- *     comes from a request shape, so a shared list is never rewritten;
+ *   • request-only shapes — an operation input, or a structure or list the
+ *     inputs reach and no output or error does. A member a response can
+ *     deliver would need the mirror-image decode, which the protocol does
+ *     not do, so a shape used both ways keeps its documented string type;
  *   • the enum must be exactly `{"true", "false"}` — a three-value enum
  *     that happens to include them is left alone.
  */
@@ -56,40 +56,97 @@ const booleanEnumIds = (shapes: Record<string, any>): Set<string> => {
   return out;
 };
 
-const isRequestShape = (shape: any): boolean =>
-  shape?.type === "structure" && "smithy.api#input" in (shape.traits ?? {});
+/** Every shape id a shape points at: members, list/map entries, mixins. */
+const targetsOf = (shape: any): string[] => {
+  const out: string[] = [];
+  for (const member of Object.values<any>(shape?.members ?? {})) {
+    if (member?.target) out.push(member.target);
+  }
+  for (const key of ["member", "value", "key"] as const) {
+    const target = shape?.[key]?.target;
+    if (target) out.push(target);
+  }
+  for (const mixin of shape?.mixins ?? []) {
+    if (mixin?.target) out.push(mixin.target);
+  }
+  return out;
+};
+
+const reachable = (
+  shapes: Record<string, any>,
+  roots: ReadonlyArray<string | undefined>,
+): Set<string> => {
+  const seen = new Set<string>();
+  const stack = roots.filter((r): r is string => r !== undefined);
+  while (stack.length > 0) {
+    const id = stack.pop()!;
+    if (seen.has(id) || shapes[id] === undefined) continue;
+    seen.add(id);
+    stack.push(...targetsOf(shapes[id]));
+  }
+  return seen;
+};
+
+/**
+ * Shapes an operation input reaches that no output or error does. Operation
+ * I/O is the spine; the `smithy.api#input`/`#output`/`#error` traits cover
+ * models whose shapes are not wired through an operation, and a structure
+ * the inputs never reach counts as a response root — unreachable from a
+ * request, it can only describe something the API hands back.
+ */
+const requestOnlyShapes = (shapes: Record<string, any>): Set<string> => {
+  const requestRoots: Array<string | undefined> = [];
+  const responseRoots: Array<string | undefined> = [];
+  for (const [id, shape] of Object.entries<any>(shapes)) {
+    if (shape?.type === "operation") {
+      requestRoots.push(shape.input?.target);
+      responseRoots.push(shape.output?.target);
+      for (const error of shape.errors ?? []) responseRoots.push(error?.target);
+      continue;
+    }
+    const traits = shape?.traits ?? {};
+    if ("smithy.api#input" in traits) requestRoots.push(id);
+    if ("smithy.api#output" in traits || "smithy.api#error" in traits) {
+      responseRoots.push(id);
+    }
+  }
+  const fromRequests = reachable(shapes, requestRoots);
+  for (const [id, shape] of Object.entries<any>(shapes)) {
+    if (shape?.type === "structure" && !fromRequests.has(id)) {
+      responseRoots.push(id);
+    }
+  }
+  const fromResponses = reachable(shapes, responseRoots);
+  const out = new Set<string>();
+  for (const id of fromRequests) {
+    if (!fromResponses.has(id)) out.add(id);
+  }
+  return out;
+};
 
 export const booleanStringEnums = (model: any): BooleanStringEnumResult => {
   const shapes: Record<string, any> = model?.shapes ?? {};
   const boolEnums = booleanEnumIds(shapes);
   if (boolEnums.size === 0) return { members: 0, lists: 0 };
 
-  // Lists of a boolean enum, and whether anything outside a request shape
-  // refers to them (a shared list keeps its documented string type).
+  const requestOnly = requestOnlyShapes(shapes);
   const boolLists = new Set<string>();
   for (const [id, shape] of Object.entries(shapes)) {
-    if (shape?.type === "list" && boolEnums.has(shape.member?.target)) {
+    if (
+      shape?.type === "list" &&
+      boolEnums.has(shape.member?.target) &&
+      requestOnly.has(id)
+    ) {
       boolLists.add(id);
     }
   }
-  const sharedLists = new Set<string>();
-  for (const shape of Object.values(shapes)) {
-    if (isRequestShape(shape)) continue;
-    for (const member of Object.values<any>(shape?.members ?? {})) {
-      if (boolLists.has(member?.target)) sharedLists.add(member.target);
-    }
-    if (boolLists.has(shape?.member?.target)) {
-      sharedLists.add(shape.member.target);
-    }
-  }
 
   let members = 0;
   const retargeted = new Set<string>();
-  for (const shape of Object.values<any>(shapes)) {
-    if (!isRequestShape(shape)) continue;
+  for (const [id, shape] of Object.entries<any>(shapes)) {
+    if (shape?.type !== "structure" || !requestOnly.has(id)) continue;
     for (const member of Object.values<any>(shape.members ?? {})) {
-      const isList =
-        boolLists.has(member?.target) && !sharedLists.has(member.target);
+      const isList = boolLists.has(member?.target);
       if (!boolEnums.has(member?.target) && !isList) continue;
       if (isList) {
         retargeted.add(member.target);

package/src/codegen/cli.ts

@@ -14,8 +14,8 @@ import { BunRuntime, BunServices } from "@effect/platform-bun";
 import { Console, Effect } from "effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Path from "effect/Path";
-import { Flag } from "effect/unstable/cli";
-import { Command } from "effect/unstable/cli";
+import { Flag } from "effect/cli";
+import { Command } from "effect/cli";
 import { barrel } from "./emit.ts";
 import { formatGenerated } from "./format.ts";
 import { generateService, type SdkSpec } from "./generator.ts";

package/src/codegen/generator.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, test } from "bun:test";
+import { generateService, type SdkSpec } from "./generator.ts";
+
+const primitiveUnionModel = (kind: "enum" | "intEnum", request: boolean) => ({
+  smithy: "2.0",
+  shapes: {
+    "com.example.union#Example": {
+      type: "service",
+      version: "2024-01-01",
+      operations: [{ target: "com.example.union#GetValue" }],
+    },
+    "com.example.union#GetValue": {
+      type: "operation",
+      input: { target: "com.example.union#Request" },
+      output: { target: "com.example.union#Response" },
+      traits: { "smithy.api#http": { method: "POST", uri: "/value" } },
+    },
+    "com.example.union#Request": {
+      type: "structure",
+      traits: { "smithy.api#input": {} },
+      members: request ? { value: { target: "com.example.union#Value" } } : {},
+    },
+    "com.example.union#Response": {
+      type: "structure",
+      members: { value: { target: "com.example.union#Value" } },
+    },
+    "com.example.union#Mode": {
+      type: kind,
+      members: {
+        STOP: {
+          target: "smithy.api#Unit",
+          traits: { "smithy.api#enumValue": kind === "enum" ? "stop" : 1 },
+        },
+      },
+    },
+    "com.example.union#Value": {
+      type: "union",
+      members: {
+        mode: { target: "com.example.union#Mode" },
+        legacy: { target: "smithy.api#Boolean" },
+      },
+    },
+  },
+});
+
+const spec: SdkSpec = {
+  unionStyle: "primitive",
+  operationDecl: {
+    contextType: "ExampleContext",
+    commonErrorType: "ExampleError",
+    commonErrorClasses: [],
+    protocol: "ExampleProtocol",
+    retry: "Retry.Retry",
+  },
+};
+
+describe("operation protocol overrides", () => {
+  for (const retry of [undefined, "Retry.Retry"]) {
+    for (const overridden of [false, true]) {
+      test(`${overridden ? "overridden" : "default"} protocol with ${retry ? "configured" : "disabled"} retries`, () => {
+        const { code } = generateService(primitiveUnionModel("enum", false), {
+          ...spec,
+          operationDecl: {
+            contextType: "ExampleContext",
+            commonErrorType: "ExampleError",
+            commonErrorClasses: [],
+            protocol: "ExampleProtocol",
+            retry,
+            overrides: () =>
+              overridden
+                ? { contextType: "PublicContext", protocol: "PublicProtocol" }
+                : undefined,
+          },
+        });
+        expect(code).toContain(
+          `  protocol: ${overridden ? "PublicProtocol" : "ExampleProtocol"},`,
+        );
+        expect(code).toContain(
+          `  ${overridden ? "PublicContext" : "ExampleContext"}\n>`,
+        );
+        if (retry) expect(code).toContain(`  retry: ${retry},`);
+        else expect(code).not.toContain("  retry:");
+      });
+    }
+  }
+});
+
+describe("primitive union generation", () => {
+  for (const kind of ["enum", "intEnum"] as const) {
+    for (const request of [false, true]) {
+      test(`${kind}/Boolean stays open when ${request ? "request-reachable" : "response-only"}`, () => {
+        const { code } = generateService(
+          primitiveUnionModel(kind, request),
+          spec,
+        );
+        const primitive = kind === "enum" ? "string" : "number";
+        expect(code).toContain(
+          `export type Value = Mode | (${primitive} & {}) | boolean;`,
+        );
+        expect(code).toContain(
+          "export const Value: S.Codec<Value> = /*@__PURE__*/ S.Union([Mode, S.Boolean]);",
+        );
+        expect(code).toContain(
+          kind === "enum"
+            ? "export const Mode = S.String;"
+            : "export const Mode = S.Number;",
+        );
+        expect(code).not.toContain("export type Value = Mode | boolean;");
+      });
+    }
+  }
+
+  test("opaque-cases retains its existing primitive union codec", () => {
+    const { code } = generateService(primitiveUnionModel("enum", false), {
+      ...spec,
+      unionStyle: "opaque-cases",
+    });
+    expect(code).toContain("export type Value = Mode | boolean;");
+    expect(code).toContain(
+      "export const Value = /*@__PURE__*/ S.Unknown.pipe(T.UnionCases([[],[]]));",
+    );
+    expect(code).not.toContain("S.Union([Mode, S.Boolean])");
+  });
+
+  test("primitive union emission requires an explicit style", () => {
+    expect(() =>
+      generateService(primitiveUnionModel("enum", false), {
+        ...spec,
+        unionStyle: undefined,
+      }),
+    ).toThrow("no union emission configured for shape com.example.union#Value");
+  });
+
+  test("primitive style rejects object cases", () => {
+    const model = primitiveUnionModel("enum", false);
+    model.shapes["com.example.union#Value"].members.mode.target =
+      "com.example.union#Request";
+    expect(() => generateService(model, spec)).toThrow(
+      "no union emission configured for shape com.example.union#Value",
+    );
+  });
+
+  test("custom union emission retains precedence", () => {
+    const { code } = generateService(primitiveUnionModel("enum", false), {
+      ...spec,
+      union: ({ name }) => [`export type ${name} = CustomUnion;`],
+    });
+    expect(code).toContain("export type Value = CustomUnion;");
+    expect(code).not.toContain("S.Union([Mode, S.Boolean])");
+  });
+});