refactor: Replace TS-based with string-based preprocessed introspection output

.github/workflows/ci.yml

@@ -51,10 +51,10 @@ jobs:
         run: pnpm run lint
 
       - name: Unit Tests
-        run: pnpm multi --include-workspace-root run test --run
+        run: pnpm run test
 
       - name: benchmarks
-        run: pnpm multi --include-workspace-root run bench --run
+        run: pnpm run bench --run
 
       - name: Build
         run: pnpm multi --include-workspace-root run build

packages/internal/package.json

@@ -35,6 +35,7 @@
   "homepage": "https://gql-tada.0no.co/",
   "license": "MIT",
   "scripts": {
+    "test": "vitest test",
     "build": "rollup -c ../../scripts/rollup.config.mjs",
     "clean": "rimraf dist node_modules/.cache",
     "prepublishOnly": "run-s clean build"

packages/internal/src/introspection/__tests__/preprocess.test.ts

@@ -0,0 +1,39 @@
+import { describe, test } from 'vitest';
+
+import * as ts from '../../../../../src/__tests__/tsHarness';
+import simpleIntrospection from '../../../../../src/__tests__/fixtures/simpleIntrospection.json';
+import { preprocessIntrospection } from '../preprocess';
+
+const testTypeHost = test.each([
+  { strictNullChecks: false, noImplicitAny: false },
+  { strictNullChecks: true },
+]);
+
+describe('preprocessIntrospection', () => {
+  testTypeHost('matches `mapIntrospection` output (%o)', (options) => {
+    const introspectionType = preprocessIntrospection(simpleIntrospection as any);
+
+    const virtualHost = ts.createVirtualHost({
+      ...ts.readVirtualModule('expect-type'),
+      'utils.ts': ts.readFileFromRoot('src/utils.ts'),
+      'introspection.ts': ts.readFileFromRoot('src/introspection.ts'),
+      'simpleSchema.ts': ts.readFileFromRoot('src/__tests__/fixtures/simpleSchema.ts'),
+      'output.ts': `export type output = ${introspectionType};`,
+      'index.ts': `
+        import { expectTypeOf } from 'expect-type';
+        import type { simpleSchema } from './simpleSchema';
+        import type { output } from './output';
+
+        expectTypeOf<output>().toMatchTypeOf<simpleSchema>();
+      `,
+    });
+
+    ts.runDiagnostics(
+      ts.createTypeHost({
+        ...options,
+        rootNames: ['index.ts'],
+        host: virtualHost,
+      })
+    );
+  });
+});

packages/internal/src/introspection/index.ts

@@ -0,0 +1,2 @@
+export { preprocessIntrospection } from './preprocess';
+export * from './output';

packages/internal/src/introspection/output.ts

@@ -0,0 +1,58 @@
+import type { IntrospectionQuery } from 'graphql';
+import { minifyIntrospectionQuery } from '@urql/introspection';
+
+import { TadaError } from '../errors';
+import { PREAMBLE_IGNORE, ANNOTATION_DTS, ANNOTATION_TS } from './constants';
+import { preprocessIntrospection } from './preprocess';
+
+const stringifyJson = (input: unknown | string): string =>
+  typeof input === 'string' ? input : JSON.stringify(input, null, 2);
+
+export function minifyIntrospection(introspection: IntrospectionQuery): IntrospectionQuery {
+  return minifyIntrospectionQuery(introspection, {
+    includeDirectives: false,
+    includeEnums: true,
+    includeInputs: true,
+    includeScalars: true,
+  });
+}
+
+interface OutputIntrospectionFileOptions {
+  fileType: '.ts' | '.d.ts' | string;
+  shouldPreprocess?: boolean;
+}
+
+export function outputIntrospectionFile(
+  introspection: IntrospectionQuery | string,
+  opts: OutputIntrospectionFileOptions
+): string {
+  if (/\.d\.ts$/.test(opts.fileType)) {
+    const json =
+      typeof introspection !== 'string' && opts.shouldPreprocess
+        ? preprocessIntrospection(introspection)
+        : stringifyJson(introspection);
+    return [
+      PREAMBLE_IGNORE,
+      ANNOTATION_DTS,
+      `export type introspection = ${json};\n`,
+      "import * as gqlTada from 'gql.tada';\n",
+      "declare module 'gql.tada' {",
+      '  interface setupSchema {',
+      '    introspection: introspection',
+      '  }',
+      '}',
+    ].join('\n');
+  } else if (/\.ts$/.test(opts.fileType)) {
+    const json = stringifyJson(introspection);
+    return [
+      PREAMBLE_IGNORE,
+      ANNOTATION_TS,
+      `const introspection = ${json} as const;\n`,
+      'export { introspection };',
+    ].join('\n');
+  }
+
+  throw new TadaError(
+    `No available introspection format for "${opts.fileType}" (expected ".ts" or ".d.ts")`
+  );
+}

packages/internal/src/introspection/preprocess.ts

@@ -0,0 +1,102 @@
+import type {
+  IntrospectionQuery,
+  IntrospectionType,
+  IntrospectionEnumValue,
+  IntrospectionInputValue,
+  IntrospectionTypeRef,
+  IntrospectionNamedTypeRef,
+  IntrospectionField,
+} from 'graphql';
+
+const printName = (input: string | undefined | null): string => (input ? `'${input}'` : 'never');
+
+const printTypeRef = (typeRef: IntrospectionTypeRef) => {
+  if (typeRef.kind === 'NON_NULL') {
+    return `{ kind: 'NON_NULL'; name: never; ofType: ${printTypeRef(typeRef.ofType)}; }`;
+  } else if (typeRef.kind === 'LIST') {
+    return `{ kind: 'LIST'; name: never; ofType: ${printTypeRef(typeRef.ofType)}; }`;
+  } else {
+    return `{ kind: ${printName(typeRef.kind)}; name: ${printName(typeRef.name)}; ofType: null; }`;
+  }
+};
+
+const printInputFields = (inputFields: readonly IntrospectionInputValue[]) => {
+  let output = '';
+  for (const inputField of inputFields) {
+    if (output) output += ', ';
+    const name = printName(inputField.name);
+    const type = printTypeRef(inputField.type);
+    const defaultValue = inputField.defaultValue ? JSON.stringify(inputField.defaultValue) : 'null';
+    output += `{ name: ${name}; type: ${type}; defaultValue: ${defaultValue} }`;
+  }
+  return `[${output}]`;
+};
+
+const printNamedTypes = (
+  values: readonly (IntrospectionEnumValue | IntrospectionNamedTypeRef)[]
+) => {
+  if (!values.length) return 'never';
+  let output = '';
+  for (const value of values) {
+    if (output) output += ' | ';
+    output += printName(value.name);
+  }
+  return output;
+};
+
+const printFields = (fields: readonly IntrospectionField[]) => {
+  let output = '';
+  for (const field of fields) {
+    const name = printName(field.name);
+    const type = printTypeRef(field.type);
+    output += `${printName(field.name)}: { name: ${name}; type: ${type} }; `;
+  }
+  return `{ ${output}}`;
+};
+
+export const printIntrospectionType = (type: IntrospectionType) => {
+  if (type.kind === 'ENUM') {
+    const values = printNamedTypes(type.enumValues);
+    return `{ kind: 'ENUM'; name: ${printName(type.name)}; type: ${values}; }`;
+  } else if (type.kind === 'INPUT_OBJECT') {
+    const fields = printInputFields(type.inputFields);
+    return `{ kind: 'INPUT_OBJECT'; name: ${printName(type.name)}; inputFields: ${fields}; }`;
+  } else if (type.kind === 'OBJECT') {
+    const fields = printFields(type.fields);
+    return `{ kind: 'OBJECT'; name: ${printName(type.name)}; fields: ${fields}; }`;
+  } else if (type.kind === 'INTERFACE') {
+    const name = printName(type.name);
+    const fields = printFields(type.fields);
+    const possibleTypes = printNamedTypes(type.possibleTypes);
+    return `{ kind: 'INTERFACE'; name: ${name}; fields: ${fields}; possibleTypes: ${possibleTypes}; }`;
+  } else if (type.kind === 'UNION') {
+    const name = printName(type.name);
+    const possibleTypes = printNamedTypes(type.possibleTypes);
+    return `{ kind: 'UNION'; name: ${name}; fields: {}; possibleTypes: ${possibleTypes}; }`;
+  } else if (type.kind === 'SCALAR') {
+    return 'unknown';
+  } else {
+    return 'never';
+  }
+};
+
+export function preprocessIntrospection({ __schema: schema }: IntrospectionQuery): string {
+  const queryName = printName(schema.queryType.name);
+  const mutationName = printName(schema.mutationType && schema.mutationType.name);
+  const subscriptionName = printName(schema.subscriptionType && schema.subscriptionType.name);
+
+  let evaluatedTypes = '';
+  for (const type of schema.types) {
+    const typeStr = printIntrospectionType(type);
+    if (evaluatedTypes) evaluatedTypes += '\n';
+    evaluatedTypes += `    ${printName(type.name)}: ${typeStr};`;
+  }
+
+  return (
+    '{\n' +
+    `  query: ${queryName};\n` +
+    `  mutation: ${mutationName};\n` +
+    `  subscription: ${subscriptionName};\n` +
+    `  types: {\n${evaluatedTypes}\n  };\n}`
+  );
+}