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

package/src/codegen/graphql-client.test.ts

@@ -1,7 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { buildSchema, introspectionFromSchema, parse, validate } from "graphql";
-import { compile } from "../graphql.ts";
-import { fixtureSDL } from "../graphql.fixture.ts";
+import { buildSchema, introspectionFromSchema } from "graphql";
 import { applyOperation } from "../json-patch.ts";
 import {
   convertGraphQLClient,
@@ -12,35 +10,18 @@ import {
 
 const named = (name: string, kind = "OBJECT") => ({ kind, name });
 const required = (ofType: object) => ({ kind: "NON_NULL", ofType });
-const list = (ofType: object) => ({ kind: "LIST", ofType });
 const field = (name: string, type: object, args: object[] = []) => ({
   name,
   type,
   args,
 });
+
 const fixture = {
   queryType: { name: "Query" },
   mutationType: { name: "Mutation" },
   types: [
     { kind: "SCALAR", name: "String" },
     { kind: "SCALAR", name: "Int" },
-    { kind: "SCALAR", name: "JSON" },
-    {
-      kind: "ENUM",
-      name: "Status",
-      enumValues: [{ name: "ACTIVE" }, { name: "OLD", isDeprecated: true }],
-    },
-    {
-      kind: "INPUT_OBJECT",
-      name: "Filter",
-      inputFields: [
-        {
-          name: "status",
-          type: named("Status", "ENUM"),
-          defaultValue: "ACTIVE",
-        },
-      ],
-    },
     {
       kind: "OBJECT",
       name: "Query",
@@ -48,7 +29,13 @@ const fixture = {
         field("project", required(named("Project")), [
           { name: "id", type: required(named("String", "SCALAR")) },
         ]),
-        field("search", list(named("Search", "UNION"))),
+        field("me", required(named("User"))),
+        field("projects", required(named("ProjectConnection")), [
+          {
+            name: "first",
+            type: named("Int", "SCALAR"),
+          },
+        ]),
       ],
     },
     {
@@ -56,47 +43,57 @@ const fixture = {
       name: "Mutation",
       fields: [
         field("projectCreate", named("Project"), [
-          { name: "filter", type: named("Filter", "INPUT_OBJECT") },
+          { name: "name", type: required(named("String", "SCALAR")) },
         ]),
       ],
     },
     {
       kind: "OBJECT",
       name: "Project",
-      interfaces: [named("Node", "INTERFACE")],
       fields: [
         field("id", required(named("String", "SCALAR"))),
-        field("children", required(list(required(named("Project")))), [
-          {
-            name: "first",
-            type: required(named("Int", "SCALAR")),
-            defaultValue: "20",
-          },
-          { name: "filter", type: named("Filter", "INPUT_OBJECT") },
+        field("name", required(named("String", "SCALAR"))),
+      ],
+    },
+    {
+      kind: "OBJECT",
+      name: "User",
+      fields: [
+        field("email", required(named("String", "SCALAR"))),
+        field("name", named("String", "SCALAR")),
+        field("projects", required(named("ProjectConnection")), [
+          { name: "first", type: named("Int", "SCALAR") },
         ]),
-        {
-          ...field("legacy", named("String", "SCALAR")),
-          isDeprecated: true,
-          deprecationReason: "Use id",
-        },
       ],
     },
     {
       kind: "OBJECT",
-      name: "Service",
-      fields: [field("id", required(named("String", "SCALAR")))],
+      name: "ProjectConnection",
+      fields: [
+        field(
+          "edges",
+          required({ kind: "LIST", ofType: named("ProjectEdge") }),
+        ),
+        field("pageInfo", required(named("PageInfo"))),
+      ],
     },
     {
-      kind: "INTERFACE",
-      name: "Node",
-      fields: [field("id", required(named("String", "SCALAR")))],
-      possibleTypes: [named("Project")],
+      kind: "OBJECT",
+      name: "ProjectEdge",
+      fields: [
+        field("cursor", required(named("String", "SCALAR"))),
+        field("node", required(named("Project"))),
+      ],
     },
     {
-      kind: "UNION",
-      name: "Search",
-      possibleTypes: [named("Project"), named("Service")],
+      kind: "OBJECT",
+      name: "PageInfo",
+      fields: [
+        field("endCursor", named("String", "SCALAR")),
+        field("hasNextPage", required(named("Boolean", "SCALAR"))),
+      ],
     },
+    { kind: "SCALAR", name: "Boolean" },
   ],
 };
 
@@ -104,283 +101,119 @@ const options = {
   transportImport: "./transport.ts",
   requirementsImport: "./transport.ts",
   requirementsType: "Requirements",
-  operationAliases: { createProject: "projectCreate" },
+  sdkName: "Railway",
 };
 
-describe("GraphQL-native compiler", () => {
-  test("root helpers allocate safe unique names without hiding schema operations", () => {
-    const source = buildSchema(`
-      type Query {
-        query: String report: String schema: String transport: String G: String
-        catchTags: String delete: String Scalars: String Selection: String
-        same: String mutationSame: String
-      }
-      type Mutation { same: String }
-    `);
-    const model = convertGraphQLClient(introspectionFromSchema(source));
-    const output = generateGraphQLClient(model, {
-      ...options,
-      operationAliases: {
-        default: "delete",
-        deleteField: "delete",
-        transport: "report",
-        readReport: "report",
-      },
-    });
-    expect(output).toContain(
-      'export const queryQuery = client.operation("query", "query");',
-    );
-    expect(output).toContain(
-      'export const queryReport = client.operation("query", "report");',
-    );
-    expect(output).toContain(
-      'export const queryTransport = client.operation("query", "transport");',
-    );
-    expect(output).toContain(
-      'export const queryDelete = client.operation("query", "delete");',
-    );
-    expect(output).toContain(
-      'export const queryScalars = client.operation("query", "Scalars");',
-    );
-    expect(output).toContain(
-      'export const mutationSame2 = client.operation("mutation", "same");',
-    );
-    expect(output).toContain("export const deleteField = queryDelete;");
-    expect(output).toContain("export const readReport = queryReport;");
-    expect(output).not.toContain("export const default =");
-    expect(
-      [...output.matchAll(/export const ([A-Za-z_$][\w$]*) =/g)].map(
-        (match) => match[1],
-      ),
-    ).toEqual(expect.arrayContaining(["query", "report", "queryCatchTags"]));
-    const declarations = [
-      ...output.matchAll(/export (?:const|class|type) ([A-Za-z_$][\w$]*)/g),
-    ].map((match) => match[1]);
-    expect(new Set(declarations).size).toBe(declarations.length);
-    expect(output.match(/client\.operation\(/g)).toHaveLength(12);
-    expect(() =>
-      new Bun.Transpiler({ loader: "ts" }).transformSync(output),
-    ).not.toThrow();
-    expect(
-      generateGraphQLClient(model, {
-        ...options,
-        operationAliases: {
-          default: "delete",
-          deleteField: "delete",
-          transport: "report",
-          readReport: "report",
-        },
-      }),
-    ).toBe(output);
-  });
-
-  test("schema type names and patched error tags cannot shadow generated support symbols", () => {
-    const model = convertGraphQLClient(
-      introspectionFromSchema(
-        buildSchema(`
-      type Query { data: Schema }
-      type Schema { selection: Selection }
-      type Selection { id: ID! }
-    `),
-      ),
-    );
-    for (const tag of ["Schema", "catchTags", "class"]) {
-      applyOperation(model, {
-        op: "add",
-        path: `/errors/${tag}`,
-        value: { matchers: [{ code: tag }] },
-      });
-      applyOperation(model, {
-        op: "add",
-        path: "/types/Query/fields/data/errors/-",
-        value: tag,
-      });
-    }
+describe("GraphQL Query SDK generator", () => {
+  test("emits TypeMeta, interfaces, and named roots on the SDK object", () => {
+    const model = convertGraphQLClient(fixture);
     const output = generateGraphQLClient(model, options);
+    expect(output).toContain("export interface Project");
+    expect(output).toContain("export interface User");
     expect(output).toContain(
-      'export class SchemaError extends S.TaggedError<SchemaError>()("Schema", G.errorFields)',
+      'export const Project: TypeMeta = { name: "Project", fields: {} };',
     );
+    expect(output).toContain("export const Railway = {");
     expect(output).toContain(
-      'export class catchTagsError extends S.TaggedError<catchTagsError>()("catchTags", G.errorFields)',
+      'root("query", "me", User, undefined, undefined, globalErrors)',
     );
+    expect(output).toContain('root("query", "project", Project');
+    expect(output).toContain('rootConnection("query", "projects", Project');
     expect(output).toContain(
-      'export class classError extends S.TaggedError<classError>()("class", G.errorFields)',
+      "Query<ReadonlyArray<Project>, RailwayGlobalError>",
     );
-    expect(output).toContain('"Schema": SchemaError;');
-    expect(output).toContain('"Schema": {');
-    expect(output).toContain('"Selection": {');
+    expect(output).toContain(
+      'connectionField("projects", Project, { first: "Int" })',
+    );
+    expect(output).toContain('root("mutation", "projectCreate", Project');
+    // Nullable GraphQL types include null; non-null ones do not.
+    expect(output).toContain("readonly name: string | null;");
+    expect(output).toContain("readonly email: string;");
+    expect(output).toContain("Query<Project | null, RailwayGlobalError>");
+    expect(output).toContain("args?: { readonly first?: number | null }");
+    expect(output).toContain('from "@distilled.cloud/core/graphql"');
     expect(() =>
       new Bun.Transpiler({ loader: "ts" }).transformSync(output),
     ).not.toThrow();
   });
 
-  test("real introspection round-trips abstract fragments, recursive selections and defaulted required arguments", () => {
-    const schema = buildSchema(
-      fixtureSDL.replaceAll("first: Int = 20", "first: Int! = 20"),
-    );
-    const model = convertGraphQLClient(introspectionFromSchema(schema));
-    const compiled = compile(model, "query", {
-      node: {
-        where: { id: "node-id" },
-        select: {
-          id: true,
-          __typename: true,
-          __on: {
-            Project: {
-              services: { select: { edges: { node: { id: true } } } },
-            },
-            Service: { status: true, project: { parent: { name: true } } },
-          },
+  test("emits error classes and scopes them to roots", () => {
+    const model = convertGraphQLClient(fixture);
+    for (const operation of [
+      {
+        op: "add" as const,
+        path: "/errors/RailwayNotFound",
+        value: {
+          description: "Missing.",
+          category: "notFound",
+          matchers: [{ code: "NOT_FOUND" }],
         },
       },
-      search: {
-        where: { text: "query" },
-        select: {
-          __typename: true,
-          __on: { Project: { name: true }, Service: { status: true } },
+      {
+        op: "add" as const,
+        path: "/errors/RailwayRateLimited",
+        value: {
+          category: "throttling",
+          retryable: true,
+          matchers: [{ code: "RATE_LIMITED" }],
         },
       },
-    });
-    expect(validate(schema, parse(compiled.query))).toEqual([]);
-    expect(compiled.query).not.toContain("first:");
-    expect(model.types.Project!.fields!.services!.args.first).toEqual({
-      type: "Int!",
-      defaultValue: "20",
-    });
-    expect(model.types.ProjectFilter!.inputFields!.statuses).toEqual({
-      type: "[Status!]",
-      defaultValue: "[ACTIVE]",
-    });
-    const output = generateGraphQLClient(model, options);
-    expect(output).toContain('"first"?: Scalars["Int"]');
-    expect(output).toContain('"Node": "Project" | "Service"');
-    expect(output).toContain('"SearchResult": "Project" | "Service"');
-  });
-
-  test("required input fields with defaults are omittable but other required fields stay required", () => {
-    const schema = buildSchema(`
-      input Paging { limit: Int! = 20, owner: ID!, statuses: [String!]! = [] }
-      type Query { names(paging: Paging!): [String!]! }
-    `);
-    const model = convertGraphQLClient(introspectionFromSchema(schema));
-    const output = generateGraphQLClient(model, options);
-    expect(output).toContain('"limit"?: Scalars["Int"]');
-    expect(output).toContain('"owner": Scalars["ID"]');
-    expect(output).toContain('"statuses"?: ReadonlyArray<Scalars["String"]>');
-    const compiled = compile(model, "query", {
-      names: { where: { paging: { owner: "account" } } },
-    });
-    expect(Object.values(compiled.variables)).toEqual([{ owner: "account" }]);
-    expect(validate(schema, parse(compiled.query))).toEqual([]);
-    expect(() =>
-      compile(model, "query", { names: { where: { paging: {} } } }),
-    ).toThrow("owner is required");
-  });
-
-  test("provider scalar overrides stay aligned in runtime metadata and generated scalar types", () => {
-    const schema = buildSchema(
-      `scalar DateTime scalar JSON type Query { date: DateTime! blob: JSON! }`,
-    );
-    const model = convertGraphQLClient(introspectionFromSchema(schema), {
-      scalars: { DateTime: "string" },
-    });
-    const output = generateGraphQLClient(model, options);
-    expect(model.types.DateTime!.scalar).toBe("string");
-    expect(model.types.JSON!.scalar).toBe("unknown");
-    expect(output).toContain('"DateTime": string;');
-    expect(output).toContain('"JSON": unknown;');
-    expect(
-      validate(
-        schema,
-        parse(compile(model, "query", { date: true, blob: true }).query),
-      ),
-    ).toEqual([]);
-  });
-
-  test("preserves nested required arguments, defaults, recursion, union/interface members and deprecated fields", () => {
-    const model = convertGraphQLClient({ data: { __schema: fixture } });
-    expect(model.types.Project!.fields!.children).toEqual({
-      type: "[Project!]!",
-      args: {
-        first: { type: "Int!", defaultValue: "20" },
-        filter: { type: "Filter" },
+      {
+        op: "add" as const,
+        path: "/globalErrors/-",
+        value: "RailwayRateLimited",
       },
-      errors: [],
-    });
-    expect(model.types.Project!.interfaces).toEqual(["Node"]);
-    expect(model.types.Node!.possibleTypes).toEqual(["Project"]);
-    expect(model.types.Search!.possibleTypes).toEqual(["Project", "Service"]);
-    expect(model.types.Project!.fields!.legacy!.deprecated).toBe("Use id");
-    expect(model.types.Status!.enumValues).toEqual(["ACTIVE", "OLD"]);
-    expect(model.types.Filter!.inputFields!.status!.defaultValue).toBe(
-      "ACTIVE",
-    );
-    expect(model.types.JSON!.scalar).toBe("unknown");
-    validateGraphQLModel(model);
-  });
-
-  test("field errors patch the one model used by emitted type unions and runtime classification", () => {
-    const model = convertGraphQLClient(fixture);
-    applyOperation(model, {
-      op: "add",
-      path: "/errors/ChildrenUnavailable",
-      value: {
-        category: "server",
-        matchers: [{ code: "CHILDREN_UNAVAILABLE" }],
+      {
+        op: "add" as const,
+        path: "/types/Query/fields/project/errors/-",
+        value: "RailwayNotFound",
       },
-    });
-    applyOperation(model, {
-      op: "add",
-      path: "/types/Project/fields/children/errors/-",
-      value: "ChildrenUnavailable",
-    });
+    ])
+      applyOperation(model, operation);
     const output = generateGraphQLClient(model, options);
     expect(output).toContain(
-      '"children": G.Field<{ "first"?: Scalars["Int"]; "filter"?: Inputs["Filter"] | null }, "[Project!]!", "ChildrenUnavailable">;',
+      'export class RailwayNotFound extends S.TaggedError<RailwayNotFound>()("RailwayNotFound", errorFields).pipe(Category.withNotFoundError) {}',
     );
     expect(output).toContain(
-      'export class ChildrenUnavailable extends S.TaggedError<ChildrenUnavailable>()("ChildrenUnavailable", G.errorFields).pipe(Category.withServerError)',
+      "Category.withThrottlingError, Category.withRetryable({ throttling: true })",
     );
-    expect(output).toContain('"errors":["ChildrenUnavailable"]');
-    expect(output).toContain('"matchers":[{"code":"CHILDREN_UNAVAILABLE"}]');
     expect(output).toContain(
-      'export const projectCreate = client.operation("mutation", "projectCreate");',
+      'errorSpec(RailwayRateLimited, "RailwayRateLimited", [{"code":"RATE_LIMITED"}], { retryable: true, global: true })',
     );
-    expect(output).toContain("export const createProject = projectCreate;");
-  });
-
-  test("generation has no fixed depth projection or artificial output optionality", () => {
-    const output = generateGraphQLClient(
-      convertGraphQLClient(fixture),
-      options,
+    expect(output).toContain(
+      "export type RailwayGlobalError = RailwayRateLimited;",
+    );
+    expect(output).toContain(
+      "Query<Project, RailwayNotFound | RailwayGlobalError>",
     );
-    expect(output).toContain('"Project": {');
-    expect(output).toContain('"Search": "Project" | "Service";');
-    expect(output).toContain('"Node": "Project";');
-    expect(output).toContain('"id": G.Field<{  }, "String!", never>;');
-    expect(output).not.toContain('"id"?: G.Field');
-    expect(output).not.toContain("maxDepth");
+    expect(output).toContain("[RailwayNotFoundSpec, ...globalErrors]");
+    expect(output).toContain("Query<User, RailwayGlobalError>");
+    expect(() =>
+      new Bun.Transpiler({ loader: "ts" }).transformSync(output),
+    ).not.toThrow();
   });
 
-  test("unknown coordinates, incomplete references and stale patches fail immediately", () => {
+  test("unknown coordinates fail validateGraphQLModel", () => {
     const model = convertGraphQLClient(fixture);
     applyOperation(model, {
       op: "add",
-      path: "/types/Project/fields/children/errors/-",
+      path: "/types/Project/fields/id/errors/-",
       value: "MissingError",
     });
     expect(() => validateGraphQLModel(model)).toThrow(
-      "Project.children: unknown GraphQL error MissingError",
+      "Project.id: unknown GraphQL error MissingError",
     );
     expect(() => graphqlTypeString({ kind: "NON_NULL" })).toThrow(
       "Incomplete GraphQL NON_NULL",
     );
-    expect(() =>
-      applyOperation(model, {
-        op: "replace",
-        path: "/types/Project/fields/removed/errors",
-        value: [],
-      }),
-    ).toThrow();
+  });
+
+  test("SDL round-trip through convert still produces a model", () => {
+    const source = buildSchema(`
+      type Query { ping: String }
+    `);
+    const model = convertGraphQLClient(introspectionFromSchema(source));
+    expect(model.queryType).toBe("Query");
+    expect(model.types.Query?.fields?.ping?.type).toBe("String");
   });
 });