wip

Author: spion

examples/typescript-node-big-schema/src/zeus/typedDocumentNode.ts

@@ -2,22 +2,42 @@ import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
 import gql from 'graphql-tag';
 import { GraphQLTypes, InputType, ValueTypes, Zeus } from './index';
 
-// Note: turns out the generated query does NOT have any params :|
-// type ParamsType<SRC> = SRC extends [infer Params, infer Result] ? Params : { [K in keyof SRC]: ParamsType<SRC[K]> };
-
-// type PayloadType<SRC, DST> = MapType<SRC, IsPayload<DST>>;
-
-export function createTypedQuery<Z extends ValueTypes['query_root']>(
-  query: Z,
+export function tq<Z extends ValueTypes['query_root']>(
+  query: Z | ValueTypes['query_root'],
 ): TypedDocumentNode<InputType<GraphQLTypes['query_root'], Z>, {}> {
-  const zeusQuery = Zeus('query', query);
-  const gqlQuery = gql(zeusQuery);
+  return gql(Zeus('query', query));
+}
+
+export function tm<Z extends ValueTypes['mutation_root']>(
+  mutation: Z,
+): TypedDocumentNode<InputType<GraphQLTypes['mutation_root'], Z>, {}> {
+  return gql(Zeus('mutation', mutation));
+}
 
-  return gqlQuery;
+export function ts<Z extends ValueTypes['subscription_root']>(
+  mutation: Z,
+): TypedDocumentNode<InputType<GraphQLTypes['subscription_root'], Z>, {}> {
+  return gql(Zeus('mutation', mutation));
 }
 
+tq({
+  aggregateBookings: [
+    {
+      where: {
+        bookerName: { _eq: '5' },
+      },
+    },
+    {
+      aggregate: {
+        avg: {
+          nights: true,
+        },
+      },
+    },
+  ],
+});
 // Example
-const userMemberships = createTypedQuery({
+const userMemberships = tq({
   user: [
     {
       id: 'x',
@@ -34,3 +54,14 @@ const userMemberships = createTypedQuery({
     },
   ],
 });
+
+const mutate = tm({
+  insertBooking: [
+    {
+      object: {},
+    },
+    {
+      bookerName: true,
+    },
+  ],
+});

src/CLI/index.ts

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import * as yargs from 'yargs';
-import { boolean } from 'yargs';
 import { CLI } from './CLIClass';
 const args = yargs
   .usage(

src/plugins/typed-document-node/index.ts

@@ -1,72 +1,40 @@
 import { OperationType, ParserTree } from 'graphql-js-tree';
 
-const pluginApolloOps = ({ queryName, operation }: { queryName: string; operation: OperationType | 'LazyQuery' }) => {
-  const capitalized = operation[0].toUpperCase() + operation.slice(1);
-  const zeusOperation = operation === 'LazyQuery' ? OperationType.query : operation;
+const createOperationFunction = ({ queryName, operation }: { queryName: string; operation: OperationType }) => {
+  const firstLetter = operation[0];
 
   return {
     queryName,
     operation,
-    ts: `export function useTyped${capitalized}<Z extends ValueTypes[O], O extends "${queryName}">(
-  ${operation}: Z | ValueTypes[O],
-  options?: ${capitalized}HookOptions<InputType<GraphQLTypes[O], Z>>,
-  operationName?: string,
-) {
-  return use${capitalized}<InputType<GraphQLTypes[O], Z>>(gql(Zeus("${zeusOperation}",${operation}, operationName)), options);
-}`,
+    ts: `export function t${firstLetter}<Z extends ValueTypes["${queryName}"]>(
+  ${operation}: Z | ValueTypes["${queryName}"],
+):  TypedDocumentNode<InputType<GraphQLTypes["${queryName}"], Z>, {}> {
+  return gql(Zeus("${operation}", ${operation}));
+}
+`,
   };
 };
 
 export const pluginTypedDocumentNode = ({ tree, esModule }: { tree: ParserTree; esModule?: boolean }) => {
   const operationNodes = tree.nodes.filter((n) => n.type.operations);
   const opsFunctions = operationNodes.flatMap((n) =>
-    n.type.operations!.map((o) => pluginApolloOps({ queryName: n.name, operation: o })),
+    n.type.operations!.map((o) => createOperationFunction({ queryName: n.name, operation: o })),
   );
-  for (const [index, o] of opsFunctions.entries()) {
-    if (o.operation === OperationType.query) {
-      opsFunctions.splice(index + 1, 0, pluginApolloOps({ queryName: o.queryName, operation: 'LazyQuery' }));
-      break;
-    }
-  }
-  const o = opsFunctions.reduce<Pick<ReturnType<typeof pluginApolloOps>, 'ts'>>(
+
+  const o = opsFunctions.reduce(
     (a, b) => {
       a.ts = [a.ts, b.ts].join('\n');
       return a;
     },
     { ts: '' },
   );
-  const capitalizedOps = opsFunctions.map((o) => o.operation[0].toUpperCase() + o.operation.slice(1));
-  const jsDefsImports: string[] = [];
-  if (capitalizedOps.includes('LazyQuery')) {
-    jsDefsImports.push('QueryTuple');
-  }
-  if (capitalizedOps.includes('Query')) {
-    jsDefsImports.push('QueryResult');
-  }
-  if (capitalizedOps.includes('Mutation')) {
-    jsDefsImports.push('MutationTuple');
-  }
+
   return {
     ts: `/* eslint-disable */
 
 import type { TypedDocumentNode } from '@graphql-typed-document-node/core';
 import gql from 'graphql-tag';
-import { GraphQLTypes, InputType, Selectors, ValueTypes, Zeus } from './index${esModule ? '.js' : ''}';
-
-export const constructQuery = <T extends ValueTypes['Query']>(q: T) => {
-  const gqlString = Zeus.query(q);
-  const selector = Selectors.query(q);
-  type InferredResponseType = InputType<GraphQLTypes['Query'], typeof selector>;
-  return gql(gqlString) as TypedDocumentNode<InferredResponseType, {}>;
-};
-
-const drawCardDocument = constructQuery({
-  drawCard: {
-    Attack: true,
-    Children: true,
-    id: true,
-  },
-});
+import { GraphQLTypes, InputType, ValueTypes, Zeus } from './index';
 
 ${o.ts}
 `,