@quilted/create 0.1.65 → 0.1.67

package/templates/app-graphql/server/graphql.ts

@@ -1,21 +1,38 @@
-import {type GraphQLResult} from '@quilted/quilt';
-import {type GraphQLSchema} from 'graphql';
+import {graphql} from 'graphql';
+import {
+  createGraphQLSchema,
+  createGraphQLResolverBuilder,
+} from '@quilted/quilt/graphql/server';
+import type {GraphQLResult, GraphQLSource} from '@quilted/quilt/graphql';
 
-export async function performGraphQLOperation<Data = Record<string, unknown>>(
-  operation: string,
+import schemaSource, {type Schema} from '../graphql/schema.ts';
+
+const {createResolver, createQueryResolver} =
+  createGraphQLResolverBuilder<Schema>();
+
+const Person = createResolver('Person', {
+  name: 'Winston',
+});
+
+const Query = createQueryResolver({
+  me: () => ({}),
+});
+
+const schema = createGraphQLSchema(schemaSource, {Query, Person});
+
+export async function performGraphQLOperation<
+  Data = Record<string, unknown>,
+  Variables = Record<string, unknown>,
+>(
+  operation: GraphQLSource<Data, Variables>,
   {
     variables,
     operationName,
-  }: {variables?: Record<string, unknown>; operationName?: string} = {},
+  }: {variables?: Variables; operationName?: string} = {},
 ) {
-  const [schema, {execute, parse}] = await Promise.all([
-    getSchema(),
-    import('graphql'),
-  ]);
-
-  const result = await execute({
+  const result = await graphql({
     schema,
-    document: parse(operation),
+    source: operation,
     operationName,
     variableValues: variables,
     rootValue: {name: () => 'Winston'},
@@ -23,20 +40,3 @@ export async function performGraphQLOperation<Data = Record<string, unknown>>(
 
   return result as GraphQLResult<Data>;
 }
-
-let schemaPromise: Promise<GraphQLSchema>;
-
-function getSchema() {
-  if (!schemaPromise) {
-    schemaPromise = (async () => {
-      const [{buildSchema}, {default: schemaSource}] = await Promise.all([
-        import('graphql'),
-        import('../graphql/schema.ts'),
-      ]);
-
-      return buildSchema(schemaSource);
-    })();
-  }
-
-  return schemaPromise;
-}

package/templates/app-graphql/server.tsx

@@ -1,17 +1,16 @@
 import '@quilted/quilt/global';
 
-import {type GraphQLFetch, type GraphQLData} from '@quilted/quilt';
 import {createRequestRouter, json} from '@quilted/quilt/request-router';
 import {createServerRender} from '@quilted/quilt/server';
+import {type GraphQLFetch} from '@quilted/quilt/graphql';
 import {createBrowserAssets} from '@quilted/quilt/magic/assets';
 
-import {performGraphQLOperation} from './server/graphql.ts';
-
 const router = createRequestRouter();
 
 // GraphQL API, called from the client
 router.post('/api/graphql', async (request) => {
-  const {query, operationName, variables} = await request.json();
+  const [{performGraphQLOperation}, {query, operationName, variables}] =
+    await Promise.all([import('./server/graphql.ts'), request.json()]);
 
   const result = await performGraphQLOperation(query, {
     variables,
@@ -25,13 +24,14 @@ router.post('/api/graphql', async (request) => {
 router.get(
   createServerRender(
     async () => {
-      const {default: App} = await import('./App.tsx');
+      const [{default: App}, {performGraphQLOperation}] = await Promise.all([
+        import('./App.tsx'),
+        import('./server/graphql.ts'),
+      ]);
 
       // GraphQL API, called during server rendering
       const fetchGraphQL: GraphQLFetch = async (operation, variables) => {
-        type Data = GraphQLData<typeof operation>;
-
-        const result = await performGraphQLOperation<Data>(operation.source, {
+        const result = await performGraphQLOperation(operation.source, {
           variables,
           operationName: operation.name,
         });

package/templates/app-graphql/tests/graphql.ts

@@ -1,13 +1,14 @@
-import {buildSchema} from 'graphql';
 import {
   TestGraphQL,
+  createGraphQLSchema,
   createGraphQLFiller,
   createGraphQLController,
   type GraphQLController,
 } from '@quilted/quilt/graphql/testing';
 
-import schema from '../graphql/schema.ts';
+import schemaSource from '../graphql/schema.ts';
 
-export const fillGraphQL = createGraphQLFiller(buildSchema(schema));
+export const schema = createGraphQLSchema(schemaSource);
+export const fillGraphQL = createGraphQLFiller(schema);
 
 export {createGraphQLController, TestGraphQL, type GraphQLController};

package/build/cjs/_virtual/parser-babel.cjs

@@ -1,5 +0,0 @@
-'use strict';
-
-var parserBabel = {exports: {}};
-
-exports.__module = parserBabel;

package/build/cjs/_virtual/parser-typescript.cjs

@@ -1,5 +0,0 @@
-'use strict';
-
-var parserTypescript = {exports: {}};
-
-exports.__module = parserTypescript;

package/build/cjs/_virtual/parser-yaml.cjs

@@ -1,5 +0,0 @@
-'use strict';
-
-var parserYaml = {exports: {}};
-
-exports.__module = parserYaml;