tests(ts-client): refactor to one default schema

src/client/ResultSet/ResultSet.test-d.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/ban-types */
 
 import { expectTypeOf, test } from 'vitest'
-import type { Index } from '../../../tests/ts/_/schema/generated/Index.js'
-import type * as Schema from '../../../tests/ts/_/schema/generated/SchemaBuildtime.js'
+import type { Index } from '../../../tests/_/schema/generated/Index.js'
+import type * as Schema from '../../../tests/_/schema/generated/SchemaBuildtime.js'
 import type { SelectionSet } from '../SelectionSet/__.js'
 import type { ResultSet } from './__.js'
 
@@ -51,10 +51,10 @@ test(`general`, () => {
   expectTypeOf<RS<{ objectNonNull: { __typename: true } }>>().toEqualTypeOf<{ objectNonNull: { __typename: "Object1" } }>()
 
   // Union
-  expectTypeOf<RS<{ fooBarUnion: { __typename: true } }>>().toEqualTypeOf<{ fooBarUnion: null | { __typename: "Foo" } | { __typename: "Bar" } }>()
-  expectTypeOf<RS<{ fooBarUnion: { onFoo: { __typename: true } } }>>().toEqualTypeOf<{ fooBarUnion: null | {} | { __typename: "Foo" } }>()
-  expectTypeOf<RS<{ fooBarUnion: { onFoo: { id: true } } }>>().toEqualTypeOf<{ fooBarUnion: null | {} | { id: null|string } }>()
-  expectTypeOf<RS<{ fooBarUnion: { __typename: true; onFoo: { id: true } } }>>().toEqualTypeOf<{ fooBarUnion: null | { __typename: "Bar" } | { __typename: "Foo"; id: null|string } }>()
+  expectTypeOf<RS<{ unionFooBar: { __typename: true } }>>().toEqualTypeOf<{ unionFooBar: null | { __typename: "Foo" } | { __typename: "Bar" } }>()
+  expectTypeOf<RS<{ unionFooBar: { onFoo: { __typename: true } } }>>().toEqualTypeOf<{ unionFooBar: null | {} | { __typename: "Foo" } }>()
+  expectTypeOf<RS<{ unionFooBar: { onFoo: { id: true } } }>>().toEqualTypeOf<{ unionFooBar: null | {} | { id: null|string } }>()
+  expectTypeOf<RS<{ unionFooBar: { __typename: true; onFoo: { id: true } } }>>().toEqualTypeOf<{ unionFooBar: null | { __typename: "Bar" } | { __typename: "Foo"; id: null|string } }>()
   // with Args
   expectTypeOf<RS<{ unionFooBarWithArgs: { $: { id: `abc` }, onFoo: { id: true } } }>>().toEqualTypeOf<{ unionFooBarWithArgs: null | {} | { id: null|string } }>()
 
@@ -82,7 +82,7 @@ test(`general`, () => {
   expectTypeOf<RS<{ id_as: true }>>().toEqualTypeOf<{ id_as: ResultSet.Errors.UnknownFieldName<'id_as', Schema.Root.Query> }>()
   expectTypeOf<RS<{ id_as_$: true }>>().toEqualTypeOf<{ id_as_$: ResultSet.Errors.UnknownFieldName<'id_as_$', Schema.Root.Query> }>()
   // union fragment
-  expectTypeOf<RS<{ fooBarUnion: { onFoo: { id_as_id2: true } } }>>().toEqualTypeOf<{ fooBarUnion: null | {} | { id2: null|string } }>()
+  expectTypeOf<RS<{ unionFooBar: { onFoo: { id_as_id2: true } } }>>().toEqualTypeOf<{ unionFooBar: null | {} | { id2: null|string } }>()
 
   // Directive @include
   // On scalar non-nullable

src/client/SelectionSet/SelectionSet.test-d.ts

@@ -1,5 +1,5 @@
 import { assertType, expectTypeOf, test } from 'vitest'
-import type { Index } from '../../../tests/ts/_/schema/generated/Index.js'
+import type { Index } from '../../../tests/_/schema/generated/Index.js'
 import type { SelectionSet } from './__.js'
 
 type Q = SelectionSet.Query<Index>
@@ -52,15 +52,15 @@ test(`Query`, () => {
   assertType<Q>({ object: { a2: true } })
 
   // Union
-  assertType<Q>({ fooBarUnion: { __typename: true } })
-  assertType<Q>({ fooBarUnion: { onFoo: { __typename: true } } })
-  assertType<Q>({ fooBarUnion: { onFoo: { id: true } } })
+  assertType<Q>({ unionFooBar: { __typename: true } })
+  assertType<Q>({ unionFooBar: { onFoo: { __typename: true } } })
+  assertType<Q>({ unionFooBar: { onFoo: { id: true } } })
   // @ts-expect-error no b
-  assertType<Q>({ fooBarUnion: { onFoo: { id2: true } } })
-  assertType<Q>({ fooBarUnion: { onBar: { __typename: true } } })
-  assertType<Q>({ fooBarUnion: { onBar: { int: true } } })
+  assertType<Q>({ unionFooBar: { onFoo: { id2: true } } })
+  assertType<Q>({ unionFooBar: { onBar: { __typename: true } } })
+  assertType<Q>({ unionFooBar: { onBar: { int: true } } })
   // @ts-expect-error no a
-  assertType<Q>({ fooBarUnion: { onBar: { int2: true } } })
+  assertType<Q>({ unionFooBar: { onBar: { int2: true } } })
 
   // Union fragments Case
   assertType<Q>({ lowerCaseUnion: { onLowerCaseObject: { id: true }, onLowerCaseObject2: { int: true } } })
@@ -112,7 +112,7 @@ test(`Query`, () => {
   assertType<Q>({ object: { $skip: true, string: true } })
   // assertType<S>({ scalars: skip().select({ a: true }) })
   // on fragment
-  assertType<Q>({ fooBarUnion: { onBar: { $skip: true, int: true } } })
+  assertType<Q>({ unionFooBar: { onBar: { $skip: true, int: true } } })
   // @include
   assertType<Q>({ string: { $include: true } })
   assertType<Q>({ string: { $include: false } })
@@ -224,7 +224,7 @@ test(`Query`, () => {
   // @ts-expect-error no directives on scalars field
   assertType<Q>({ scalars: { $scalars: { $skip: true } } })
   // union fragment
-  assertType<Q>({ fooBarUnion: { onBar: { $scalars: true } } })
+  assertType<Q>({ unionFooBar: { onBar: { $scalars: true } } })
   assertType<Q>({ unionFooBarWithArgs: { $: { id: `abc` }, onBar: { $scalars: true } } })
 
   // assertType<S>({ scalars: select() })

src/client/SelectionSet/__snapshots__/toGraphQLDocumentString.test.ts.snap

@@ -811,13 +811,13 @@ exports[`other > Query 9`] = `
 exports[`union > Query 1`] = `
 "
 {
-  "fooBarUnion": {
+  "unionFooBar": {
     "__typename": true
   }
 }
 --------------
 {
-  fooBarUnion {
+  unionFooBar {
     __typename
   }
 }
@@ -827,15 +827,15 @@ exports[`union > Query 1`] = `
 exports[`union > Query 2`] = `
 "
 {
-  "fooBarUnion": {
+  "unionFooBar": {
     "onBar": {
       "int": true
     }
   }
 }
 --------------
 {
-  fooBarUnion {
+  unionFooBar {
     ... on Bar {
       int
     }
@@ -847,7 +847,7 @@ exports[`union > Query 2`] = `
 exports[`union > Query 3`] = `
 "
 {
-  "fooBarUnion": {
+  "unionFooBar": {
     "onBar": {
       "$skip": true,
       "int": true
@@ -856,7 +856,7 @@ exports[`union > Query 3`] = `
 }
 --------------
 {
-  fooBarUnion {
+  unionFooBar {
     ... on Bar @skip(if: true) {
       int
     }

src/client/SelectionSet/toGraphQLDocumentString.test.ts

@@ -1,6 +1,6 @@
 import { parse, print } from 'graphql'
 import { describe, expect, test } from 'vitest'
-import type { Index } from '../../../tests/ts/_/schema/generated/Index.js'
+import type { Index } from '../../../tests/_/schema/generated/Index.js'
 import type { SelectionSet } from './__.js'
 import { toGraphQLDocumentSelectionSet } from './toGraphQLDocumentString.js'
 
@@ -23,10 +23,10 @@ const prepareResult = (ss: Q) => {
 
 describe(`union`, () => {
   test.each([
-    s({ fooBarUnion: { __typename: true } }),
-    s({ fooBarUnion: { onBar: { int: true } } }),
-    s({ fooBarUnion: { onBar: { $skip: true, int: true } } }),
-    // s({ fooBarUnion: { onBar: {} } }), // todo should be static type error
+    s({ unionFooBar: { __typename: true } }),
+    s({ unionFooBar: { onBar: { int: true } } }),
+    s({ unionFooBar: { onBar: { $skip: true, int: true } } }),
+    // s({ unionFooBar: { onBar: {} } }), // todo should be static type error
   ])(`Query`, (ss) => {
     expect(prepareResult(ss)).toMatchSnapshot()
   })

src/client/client.customScalar.test.ts

@@ -1,16 +1,15 @@
 /* eslint-disable */
 import { beforeEach, describe, expect, test } from 'vitest'
 import { db } from '../../tests/_/db.js'
+import { $Index as schemaIndex } from '../../tests/_/schema/generated/SchemaRuntime.js'
 import { setupMockServer } from '../../tests/raw/__helpers.js'
-// import type { Index } from '../../tests/ts/_/schema/generated/Index.js'
-import { $Index as schemaIndex } from '../../tests/ts/_/schema/generated/SchemaRuntime.js'
 import { create } from './client.js'
 
 const ctx = setupMockServer()
 const date0Encoded = db.date0.toISOString()
 const date1Encoded = db.date1.toISOString()
 
-const client = () => create({ name: 'MigrateMe', schema: ctx.url, schemaIndex })
+const client = () => create({ schema: ctx.url, schemaIndex })
 
 describe(`output`, () => {
   test(`query field`, async () => {
@@ -80,7 +79,6 @@ describe(`input`, () => {
   })
   const clientExpected = (expectedDocument: (document: any) => void) => {
     const client = create({
-      name: 'MigrateMe',
       schema: ctx.url,
       schemaIndex,
       hooks: {

src/client/client.returnMode.test-d.ts

@@ -3,8 +3,8 @@ import { ExecutionResult } from 'graphql'
 import { ObjMap } from 'graphql/jsutils/ObjMap.js'
 import { describe } from 'node:test'
 import { expectTypeOf, test } from 'vitest'
+import { $Index as schemaIndex } from '../../tests/_/schema/generated/SchemaRuntime.js'
 import { schema } from '../../tests/_/schema/schema.js'
-import { $Index as schemaIndex } from '../../tests/ts/_/schema/generated/SchemaRuntime.js'
 import { create } from './client.js'
 
 // dprint-ignore

src/client/client.test.ts

@@ -1,15 +1,14 @@
-/* eslint-disable */
 import { expect, test } from 'vitest'
+import { $Index as schemaIndex } from '../../tests/_/schema/generated/SchemaRuntime.js'
 import { setupMockServer } from '../../tests/raw/__helpers.js'
-import { $Index as schemaIndex } from '../../tests/ts/_/schema/generated/SchemaRuntime.js'
 import { create } from './client.js'
 
 const ctx = setupMockServer()
-const data = { fooBarUnion: { int: 1 } }
+const data = { unionFooBar: { int: 1 } }
 
-const client = () => create({ name: 'MigrateMe', schema: ctx.url, schemaIndex })
+const client = () => create({ schema: ctx.url, schemaIndex })
 
 test.todo(`query`, async () => {
   const mockRes = ctx.res({ body: { data } }).spec.body!
-  expect(await client().query.$batch({ fooBarUnion: { onBar: { int: true } } })).toEqual(mockRes.data)
+  expect(await client().query.$batch({ unionFooBar: { onBar: { int: true } } })).toEqual(mockRes.data)
 })