@distilled.cloud/core 1.0.0-rc.3 → 1.0.0-rc.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@distilled.cloud/core",
-  "version": "1.0.0-rc.3",
+  "version": "1.0.0-rc.4",
   "repository": {
     "type": "git",
     "url": "https://github.com/alchemy-run/distilled",
@@ -31,12 +31,12 @@
     "build": "tsc -b"
   },
   "devDependencies": {
-    "@effect/platform-bun": ">=4.0.0-beta.102 || >=4.0.0",
+    "@effect/platform-bun": ">=4.0.0-beta.104 || >=4.0.0",
     "@types/bun": "latest",
     "@types/node": "latest",
-    "effect": ">=4.0.0-beta.102 || >=4.0.0"
+    "effect": ">=4.0.0-beta.104 || >=4.0.0"
   },
   "peerDependencies": {
-    "effect": ">=4.0.0-beta.102 || >=4.0.0"
+    "effect": ">=4.0.0-beta.104 || >=4.0.0"
   }
 }

package/src/category.ts

@@ -9,7 +9,7 @@
  * ```ts
  * import * as Category from "@distilled.cloud/core/category";
  *
- * export class Unauthorized extends Schema.TaggedErrorClass<Unauthorized>()(
+ * export class Unauthorized extends Schema.TaggedError<Unauthorized>()(
  *   "Unauthorized",
  *   { message: Schema.String },
  * ).pipe(Category.withAuthError) {}
@@ -92,7 +92,7 @@ export interface RetryableInfo {
  *
  * @example
  * ```ts
- * export class MyError extends Schema.TaggedErrorClass<MyError>()(
+ * export class MyError extends Schema.TaggedError<MyError>()(
  *   "MyError",
  *   { message: Schema.String },
  * ).pipe(Category.withCategory(Category.AuthError)) {}
@@ -123,13 +123,13 @@ export const withCategory =
  * @example
  * ```ts
  * // Standard retryable error
- * export class TransientError extends Schema.TaggedErrorClass<TransientError>()(
+ * export class TransientError extends Schema.TaggedError<TransientError>()(
  *   "TransientError",
  *   { message: Schema.String },
  * ).pipe(Category.withRetryable()) {}
  *
  * // Throttling error (uses longer backoff)
- * export class RateLimitError extends Schema.TaggedErrorClass<RateLimitError>()(
+ * export class RateLimitError extends Schema.TaggedError<RateLimitError>()(
  *   "RateLimitError",
  *   { message: Schema.String },
  * ).pipe(Category.withRetryable({ throttling: true })) {}

package/src/codegen/emit.ts

@@ -9,7 +9,7 @@
  *     .annotate({ identifier: "X" })
  *     as any as S.Schema<X>;                      // no inference needed
  *
- * plus closed-alias string-union enums, `S.TaggedErrorClass` error classes, and
+ * plus closed-alias string-union enums, `S.TaggedError` error classes, and
  * `API.make(() => ({ … }))` operation consts. The helpers here own those
  * shared skeletons; providers own the content strings (member pipes, trait
  * calls, config fields). Emitted output is normalized by oxfmt afterwards,
@@ -120,7 +120,7 @@ export interface ErrorClassOptions {
 }
 
 /**
- * `export class X extends /*@__PURE__*​/ S.TaggedErrorClass<X>()("X", { … }) {}`
+ * `export class X extends /*@__PURE__*​/ S.TaggedError<X>()("X", { … }) {}`
  *
  * The PURE markers are what make an unused error class droppable. A class
  * whose heritage clause is an unannotated call can never be tree-shaken —
@@ -130,12 +130,12 @@ export interface ErrorClassOptions {
  *
  * `wrap` needs its own marker as well as the inner one: a pure call's
  * ARGUMENTS are still evaluated, so annotating only
- * `T.applyErrorMatchers(S.TaggedErrorClass…(…), […])` leaves the inner call
+ * `T.applyErrorMatchers(S.TaggedError…(…), […])` leaves the inner call
  * holding the class alive. Verified against esbuild in both directions.
  */
 export const errorClass = (o: ErrorClassOptions): string => {
   const annotations = o.annotations ? `,\n${o.annotations}` : "";
-  const cls = `${PURE}S.TaggedErrorClass<${o.name}>()(${q(o.tag ?? o.name)}, {\n${o.fields.join("\n")}\n}${annotations})${o.pipes ?? ""}`;
+  const cls = `${PURE}S.TaggedError<${o.name}>()(${q(o.tag ?? o.name)}, {\n${o.fields.join("\n")}\n}${annotations})${o.pipes ?? ""}`;
   const body = o.wrap ? `${PURE}${o.wrap(cls)}` : cls;
   return `export class ${o.name} extends ${body} {}\n`;
 };

package/src/codegen/generator.ts

@@ -1030,14 +1030,26 @@ export const generateService = (
     // No items path: `.items()` is a page passthrough at runtime, so an
     // item IS a whole response.
     if (!itemsPath) return tsRef(outputId);
-    let def = shapes[outputId];
+    let id: string = outputId;
+    // Whether the path crossed a list on the way down (`"edges.node"` on a
+    // Relay connection). When it did, the path itself is what fans out, so
+    // the value it lands on IS one item — it needn't be a list again.
+    let fannedOut = false;
     for (const segment of itemsPath.split(".")) {
+      let def: any = shapes[id];
+      if (def?.type === "list") {
+        id = def.member.target as string;
+        def = shapes[id];
+        fannedOut = true;
+      }
       if (def?.type !== "structure") return undefined;
       const info = memberInfos(def).find((m) => m.tsName === segment);
       if (!info) return undefined;
-      def = shapes[info.target];
+      id = info.target;
     }
-    return def?.type === "list" ? tsRef(def.member.target) : undefined;
+    const last: any = shapes[id];
+    if (last?.type === "list") return tsRef(last.member.target);
+    return fannedOut ? tsRef(id) : undefined;
   };
 
   const emitOperation =