houdini 0.17.8 → 0.17.10

package/src/codegen/generators/persistedQueries/persistedQuery.test.ts

@@ -1,26 +0,0 @@
-import { test, expect } from 'vitest'
-
-import { runPipeline } from '../../../codegen'
-import { CollectedGraphQLDocument, fs, path } from '../../../lib'
-import { mockCollectedDoc, testConfig } from '../../../test'
-
-test('generates an artifact for every document', async function () {
-	const config = testConfig()
-	config.persistedQueryPath = path.join(config.rootDir, 'hash.json')
-
-	// the documents to test
-	const docs: CollectedGraphQLDocument[] = [
-		mockCollectedDoc(`query TestQuery1 { version }`),
-		mockCollectedDoc(`query TestQuery2 { user { ...TestFragment } }`),
-		mockCollectedDoc(`fragment TestFragment on User { firstName }`),
-	]
-	// execute the generator
-	await runPipeline(config, docs)
-
-	expect(JSON.parse((await fs.readFile(config.persistedQueryPath))!)).toMatchInlineSnapshot(`
-		{
-		    "361432f464ed44eed788f3ea66c4dabc46437b88edbe7daccca87045fd31447f": "query TestQuery1 {\\n  version\\n}\\n",
-		    "17f12389123502b3d5d81202d0af249bdf0ec95cea480c9c12501ef627abd463": "query TestQuery2 {\\n  user {\\n    ...TestFragment\\n    id\\n  }\\n}\\n\\nfragment TestFragment on User {\\n  firstName\\n}\\n"
-		}
-	`)
-})

package/src/codegen/generators/runtime/index.test.ts

@@ -1,74 +0,0 @@
-import type { ProgramKind } from 'ast-types/gen/kinds'
-import * as recast from 'recast'
-import * as typeScriptParser from 'recast/parsers/typescript'
-import { test, expect } from 'vitest'
-
-import { runPipeline } from '../..'
-import { fs, path } from '../../../lib'
-import { CollectedGraphQLDocument } from '../../../lib/types'
-import { testConfig, mockCollectedDoc } from '../../../test'
-
-// the documents to test
-const docs: CollectedGraphQLDocument[] = [
-	mockCollectedDoc(`query TestQuery { version }`),
-	mockCollectedDoc(`fragment TestFragment on User { firstName }`),
-]
-
-test('runtime index file - sapper', async function () {
-	const config = testConfig({ module: 'commonjs' })
-	// execute the generator
-	await runPipeline(config, docs)
-
-	// open up the index file
-	const queryContents = await fs.readFile(path.join(config.rootDir, 'index.js'))
-	expect(queryContents).toBeTruthy()
-	// parse the contents
-	const parsedQuery: ProgramKind = recast.parse(queryContents!, {
-		parser: typeScriptParser,
-	}).program
-	// verify contents
-	expect(parsedQuery).toMatchInlineSnapshot(`
-		"use strict";
-		var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-		    if (k2 === undefined) k2 = k;
-		    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-		}) : (function(o, m, k, k2) {
-		    if (k2 === undefined) k2 = k;
-		    o[k2] = m[k];
-		}));
-		var __exportStar = (this && this.__exportStar) || function(m, exports) {
-		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-		};
-		var __importDefault = (this && this.__importDefault) || function (mod) {
-		    return (mod && mod.__esModule) ? mod : { "default": mod };
-		};
-		Object.defineProperty(exports, "__esModule", { value: true });
-		__exportStar(require("./runtime"), exports);
-
-		__exportStar(require("./artifacts"), exports);
-
-		__exportStar(require("./graphql"), exports);
-	`)
-})
-
-test('runtime index file - kit', async function () {
-	const config = testConfig({ module: 'esm', framework: 'kit' })
-	// execute the generator
-	await runPipeline(config, docs)
-
-	// open up the index file
-	const queryContents = await fs.readFile(path.join(config.rootDir, 'index.js'))
-	expect(queryContents).toBeTruthy()
-	// parse the contents
-	const parsedQuery: ProgramKind = recast.parse(queryContents!, {
-		parser: typeScriptParser,
-	}).program
-	// verify contents
-	expect(parsedQuery).toMatchInlineSnapshot(`
-		export * from "./runtime"
-
-		export * from "./artifacts"
-
-		export * from "./graphql"
-	`)
-})

package/src/codegen/generators/runtime/index.ts

@@ -1,64 +0,0 @@
-import { Config, siteURL as SITE_URL, fs, HoudiniError, path, houdini_mode } from '../../../lib'
-
-export default async function runtimeGenerator(config: Config) {
-	// generate the adapter to normalize interactions with the framework
-	// update the generated runtime to point to the client
-	await Promise.all([
-		fs.recursiveCopy(config.runtimeSource, config.runtimeDirectory, {
-			// transform the files while we are copying so we don't trigger unnecessary changes
-			[path.join(config.runtimeSource, 'lib', 'config.js')]: (content) => {
-				// the path to the config file
-				const configFilePath = path.join(config.runtimeDirectory, 'lib', 'config.js')
-				// the relative path
-				const relativePath = path.relative(path.dirname(configFilePath), config.filepath)
-
-				return content.replace('HOUDINI_CONFIG_PATH', relativePath)
-			},
-			[path.join(config.runtimeSource, 'lib', 'constants.js')]: (content) => {
-				return content.replace('SITE_URL', SITE_URL)
-			},
-		}),
-		...config.plugins
-			.filter((plugin) => plugin.include_runtime)
-			.map((plugin) => generatePluginRuntime(config, plugin)),
-	])
-}
-
-async function generatePluginRuntime(config: Config, plugin: Config['plugins'][number]) {
-	if (houdini_mode.is_testing) {
-		return
-	}
-
-	// a plugin with a generated runtime has something at <dir>/build/runtime-{esm,cjs}
-
-	// find the location of the plugin
-	const source = path.join(
-		plugin.directory,
-		'build',
-		'runtime-' + (config.module === 'esm' ? 'esm' : 'cjs')
-	)
-	try {
-		await fs.stat(source)
-	} catch {
-		throw new HoudiniError({
-			message: name + ' does not have a runtime to generate',
-			description: 'please use the houdini-scripts command to bundle your plugin',
-		})
-	}
-
-	const which = config.module === 'esm' ? 'esm' : 'cjs'
-
-	// copy the runtime
-	const pluginDir = config.pluginRuntimeDirectory(plugin.name)
-	await fs.mkdirp(pluginDir)
-	await fs.recursiveCopy(
-		source,
-		pluginDir,
-		Object.fromEntries(
-			Object.entries(plugin.transform_runtime ?? {}).map(([key, value]) => [
-				path.join(plugin.directory, 'build', `runtime-${which}`, key),
-				(content) => value({ config, content }),
-			])
-		)
-	)
-}

package/src/codegen/generators/runtime/runtime.test.ts

@@ -1,25 +0,0 @@
-import type { ProgramKind } from 'ast-types/gen/kinds'
-import * as recast from 'recast'
-import * as typeScriptParser from 'recast/parsers/typescript'
-import { test, expect } from 'vitest'
-
-import { runPipeline } from '../..'
-import { fs, path } from '../../../lib'
-import { testConfig } from '../../../test'
-
-test('updates the config file with import path', async function () {
-	const config = testConfig({ module: 'esm' })
-	// execute the generator
-	await runPipeline(config, [])
-
-	// open up the index file
-	const fileContents = await fs.readFile(path.join(config.runtimeDirectory, 'lib', 'config.js'))
-	expect(fileContents).toBeTruthy()
-
-	// parse the contents
-	const parsedQuery: ProgramKind = recast.parse(fileContents!, {
-		parser: typeScriptParser,
-	}).program
-	// verify contents
-	expect(recast.print(parsedQuery).code).toContain('import("../../../config.cjs")')
-})

package/src/codegen/generators/typescript/addReferencedInputTypes.ts

@@ -1,77 +0,0 @@
-import type { StatementKind, TSPropertySignatureKind } from 'ast-types/gen/kinds'
-import * as graphql from 'graphql'
-import * as recast from 'recast'
-
-import { Config, ensureImports, HoudiniError } from '../../../lib'
-import { unwrapType } from '../../utils'
-import { tsTypeReference } from './typeReference'
-
-const AST = recast.types.builders
-
-// add any object types found in the input
-export function addReferencedInputTypes(
-	config: Config,
-	filepath: string,
-	body: StatementKind[],
-	visitedTypes: Set<string>,
-	missingScalars: Set<string>,
-	rootType: graphql.TypeNode
-) {
-	// try to find the name of the type
-	const { type } = unwrapType(config, rootType)
-
-	// if we are looking at a scalar
-	if (graphql.isScalarType(type)) {
-		// we're done
-		return
-	}
-
-	// if we have already processed this type, don't do anything
-	if (visitedTypes.has(type.name)) {
-		return
-	}
-
-	// if we ran into a union
-	if (graphql.isUnionType(type)) {
-		// we don't support them yet
-		throw new HoudiniError({ filepath, message: 'Input Unions are not supported yet. Sorry!' })
-	}
-
-	// track that we are processing the type
-	visitedTypes.add(type.name)
-
-	// if we ran into an enum, add its definition to the file
-	if (graphql.isEnumType(type)) {
-		// we need to add an import for the enum
-		ensureImports({
-			config,
-			// @ts-ignore
-			body,
-			import: [type.name],
-			sourceModule: '$houdini/graphql/enums',
-			importKind: 'type',
-		})
-		return
-	}
-
-	// we found an object type so build up the list of fields (and walk down any object fields)
-	const members: TSPropertySignatureKind[] = []
-
-	for (const field of Object.values(type.getFields())) {
-		// walk down the referenced fields and build stuff back up
-		addReferencedInputTypes(config, filepath, body, visitedTypes, missingScalars, field.type)
-
-		// check if the type is optional so we can label the value as optional
-
-		members.push(
-			AST.tsPropertySignature(
-				AST.identifier(field.name),
-				AST.tsTypeAnnotation(tsTypeReference(config, missingScalars, field)),
-				graphql.isNullableType(field.type)
-			)
-		)
-	}
-
-	// add the type def to the body
-	body.push(AST.tsTypeAliasDeclaration(AST.identifier(type.name), AST.tsTypeLiteral(members)))
-}

package/src/codegen/generators/typescript/index.ts

@@ -1,412 +0,0 @@
-import { logCyan, logGreen } from '@kitql/helper'
-import type { StatementKind } from 'ast-types/gen/kinds'
-import * as graphql from 'graphql'
-import * as recast from 'recast'
-
-import { Config, HoudiniError, siteURL, fs, CollectedGraphQLDocument, path } from '../../../lib'
-import { flattenSelections } from '../../utils'
-import { addReferencedInputTypes } from './addReferencedInputTypes'
-import { fragmentKey, inlineType } from './inlineType'
-import { tsTypeReference } from './typeReference'
-import { readonlyProperty } from './types'
-
-const AST = recast.types.builders
-
-// typescriptGenerator generates typescript definitions for the artifacts
-export default async function typescriptGenerator(
-	config: Config,
-	docs: CollectedGraphQLDocument[]
-) {
-	// build up a list of paths we have types in (to export from index.d.ts)
-	const typePaths: string[] = []
-
-	// we need every fragment definition
-	const fragmentDefinitions: { [name: string]: graphql.FragmentDefinitionNode } = {}
-	for (const document of docs) {
-		for (const defn of document.originalDocument.definitions.filter(
-			({ kind }) => kind === 'FragmentDefinition'
-		) as graphql.FragmentDefinitionNode[]) {
-			fragmentDefinitions[defn.name.value] = defn
-		}
-	}
-
-	const missingScalars = new Set<string>()
-
-	// every document needs a generated type
-	await Promise.all(
-		// the generated types depend solely on user-provided information
-		// so we need to use the original document that we haven't mutated
-		// as part of the compiler
-		docs.map(async ({ originalDocument, name, filename, generateArtifact }) => {
-			if (!generateArtifact) {
-				return
-			}
-
-			// the place to put the artifact's type definition
-			const typeDefPath = config.artifactTypePath(originalDocument)
-
-			// build up the program
-			const program = AST.program([])
-
-			// if we have to define any types along the way, make sure we only do it once
-			const visitedTypes = new Set<string>()
-
-			// if there's an operation definition
-			let definition = originalDocument.definitions.find(
-				(def) =>
-					(def.kind === 'OperationDefinition' || def.kind === 'FragmentDefinition') &&
-					def.name?.value === name
-			) as graphql.OperationDefinitionNode | graphql.FragmentDefinitionNode
-
-			const selections = flattenSelections({
-				config,
-				filepath: filename,
-				selections: definition.selectionSet.selections,
-				fragmentDefinitions,
-			})
-
-			if (definition?.kind === 'OperationDefinition') {
-				// treat it as an operation document
-				await generateOperationTypeDefs(
-					config,
-					filename,
-					program.body,
-					definition,
-					selections,
-					visitedTypes,
-					missingScalars
-				)
-			} else {
-				// treat it as a fragment document
-				await generateFragmentTypeDefs(
-					config,
-					filename,
-					program.body,
-					selections,
-					originalDocument.definitions,
-					visitedTypes,
-					missingScalars
-				)
-			}
-
-			// write the file contents
-			await fs.writeFile(typeDefPath, recast.print(program).code)
-
-			typePaths.push(typeDefPath)
-		})
-	)
-
-	// now that we have every type generated, create an index file in the runtime root that exports the types
-	const typeIndex = AST.program(
-		typePaths
-			.sort((a, b) => a.localeCompare(b))
-			.map((typePath) => {
-				return AST.exportAllDeclaration(
-					AST.literal(
-						'./' +
-							path
-								.relative(path.resolve(config.typeIndexPath, '..'), typePath)
-								// remove the .d.ts from the end of the path
-								.replace(/\.[^/.]+\.[^/.]+$/, '')
-					),
-					null
-				)
-			})
-			.concat([
-				AST.exportAllDeclaration(AST.literal('./runtime'), null),
-				AST.exportAllDeclaration(AST.literal('./graphql'), null),
-			])
-	)
-
-	// stringify the value so we can push it through the plugins
-	const export_default_as = ({ module, as }: { module: string; as: string }) =>
-		`\nexport { default as ${as} } from "${module}"\n`
-	const export_star_from = ({ module }: { module: string }) => `\nexport * from "${module}"\n`
-	let indexContent = recast.print(typeIndex).code
-	for (const plugin of config.plugins) {
-		if (!plugin.index_file) {
-			continue
-		}
-		indexContent = plugin.index_file({
-			config,
-			content: indexContent,
-			export_default_as,
-			export_star_from,
-			plugin_root: config.pluginDirectory(plugin.name),
-			typedef: true,
-			documents: docs,
-		})
-
-		// if the plugin generated a runtime
-		if (plugin.include_runtime) {
-			indexContent += export_star_from({
-				module:
-					'./' +
-					path.relative(config.rootDir, config.pluginRuntimeDirectory(plugin.name)),
-			})
-		}
-	}
-
-	// write the contents
-	await fs.writeFile(config.typeIndexPath, indexContent)
-
-	// if we were missing scalars, we need to warn the user and tell them
-	if (missingScalars.size > 0) {
-		console.warn(`⚠️  Missing definitions for the following scalars: ${[...missingScalars].join(
-			', '
-		)}
-Generated types will contain an any type in place of these values. To fix this, provide an equivalent
-type in your config file:
-
-{
-  scalars: {
-    ${logCyan(`/* in your case, something like */`)}
-${[...missingScalars]
-	.map(
-		(c) =>
-			`    ${c}: {                  ${logGreen(`// <- The GraphQL Scalar`)}
-      type: "${logCyan(`YourType_${c}`)}"  ${logGreen(`// <-  The TypeScript type`)}
-    }`
-	)
-	.join(
-		`,
-`
-	)}
-  }
-}
-
-For more information, please visit this link: ${siteURL}/api/config#custom-scalars`)
-	}
-}
-
-async function generateOperationTypeDefs(
-	config: Config,
-	filepath: string,
-	body: StatementKind[],
-	definition: graphql.OperationDefinitionNode,
-	selections: readonly graphql.SelectionNode[],
-	visitedTypes: Set<string>,
-	missingScalars: Set<string>
-) {
-	let parentType: graphql.GraphQLCompositeType | null = null
-	if (definition.operation === 'query') {
-		parentType = config.schema.getQueryType()!
-	} else if (definition.operation === 'mutation') {
-		parentType = config.schema.getMutationType()!
-	} else if (definition.operation === 'subscription') {
-		parentType = config.schema.getSubscriptionType()!
-	}
-	if (!parentType) {
-		throw new HoudiniError({ filepath, message: 'Could not find root type for document' })
-	}
-
-	// the name of the types we will define
-	const inputTypeName = `${definition.name!.value}$input`
-	const shapeTypeName = `${definition.name!.value}$result`
-	const optimisticTypeName = `${definition.name!.value}$optimistic`
-
-	// dry
-	const hasInputs = definition.variableDefinitions && definition.variableDefinitions.length > 0
-
-	// add our types to the body
-	body.push(
-		// add the root type named after the document that links the input and result types
-		AST.exportNamedDeclaration(
-			AST.tsTypeAliasDeclaration(
-				AST.identifier(definition.name!.value),
-				AST.tsTypeLiteral([
-					readonlyProperty(
-						AST.tsPropertySignature(
-							AST.stringLiteral('input'),
-							AST.tsTypeAnnotation(AST.tsTypeReference(AST.identifier(inputTypeName)))
-						)
-					),
-					readonlyProperty(
-						AST.tsPropertySignature(
-							AST.stringLiteral('result'),
-							AST.tsTypeAnnotation(
-								definition.operation === 'mutation'
-									? AST.tsTypeReference(AST.identifier(shapeTypeName))
-									: AST.tsUnionType([
-											AST.tsTypeReference(AST.identifier(shapeTypeName)),
-											AST.tsUndefinedKeyword(),
-									  ])
-							)
-						)
-					),
-				])
-			)
-		),
-		// export the type that describes the result
-		AST.exportNamedDeclaration(
-			AST.tsTypeAliasDeclaration(
-				AST.identifier(shapeTypeName),
-				inlineType({
-					config,
-					filepath,
-					rootType: parentType,
-					selections,
-					root: true,
-					allowReadonly: true,
-					visitedTypes,
-					body,
-					missingScalars,
-					includeFragments: true,
-				})
-			)
-		)
-	)
-
-	// if there are variables in this query
-	if (hasInputs && definition.variableDefinitions && definition.variableDefinitions.length > 0) {
-		for (const variableDefinition of definition.variableDefinitions) {
-			addReferencedInputTypes(
-				config,
-				filepath,
-				body,
-				visitedTypes,
-				missingScalars,
-				variableDefinition.type
-			)
-		}
-
-		// merge all of the variables into a single object
-		body.push(
-			AST.exportNamedDeclaration(
-				AST.tsTypeAliasDeclaration(
-					AST.identifier(inputTypeName),
-					AST.tsTypeLiteral(
-						(definition.variableDefinitions || []).map(
-							(definition: graphql.VariableDefinitionNode) => {
-								// add a property describing the variable to the root object
-								return AST.tsPropertySignature(
-									AST.identifier(definition.variable.name.value),
-									AST.tsTypeAnnotation(
-										tsTypeReference(config, missingScalars, definition)
-									),
-									definition.type.kind !== 'NonNullType'
-								)
-							}
-						)
-					)
-				)
-			)
-		)
-	} else {
-		body.push(
-			AST.exportNamedDeclaration(
-				AST.tsTypeAliasDeclaration(AST.identifier(inputTypeName), AST.tsNullKeyword())
-			)
-		)
-	}
-
-	// mutations need to have an optimistic response type defined
-	if (definition.operation === 'mutation') {
-		body.push(
-			AST.exportNamedDeclaration(
-				AST.tsTypeAliasDeclaration(
-					AST.identifier(optimisticTypeName),
-					inlineType({
-						config,
-						filepath,
-						rootType: parentType,
-						selections,
-						root: true,
-						allowReadonly: true,
-						visitedTypes,
-						body,
-						missingScalars,
-						includeFragments: false,
-						allOptional: true,
-					})
-				)
-			)
-		)
-	}
-}
-
-async function generateFragmentTypeDefs(
-	config: Config,
-	filepath: string,
-	body: StatementKind[],
-	selections: readonly graphql.SelectionNode[],
-	definitions: readonly graphql.DefinitionNode[],
-	visitedTypes: Set<string>,
-	missingScalars: Set<string>
-) {
-	// every definition will contribute the same thing to the typedefs
-	for (const definition of definitions) {
-		// if its not a fragment definition
-		if (definition.kind !== 'FragmentDefinition') {
-			// we don't know what to do
-			continue
-		}
-
-		// the name of the prop type
-		const propTypeName = definition.name.value
-		// the name of the shape type
-		const shapeTypeName = `${definition.name.value}$data`
-
-		// look up the root type of the document
-		const type = config.schema.getType(definition.typeCondition.name.value)
-		if (!type) {
-			throw new Error('Should not get here')
-		}
-
-		body.push(
-			// we need to add a type that will act as the entry point for the fragment
-			// and be assigned to the prop that holds the reference passed from
-			// the fragment's parent
-			AST.exportNamedDeclaration(
-				AST.tsTypeAliasDeclaration(
-					AST.identifier(propTypeName),
-					AST.tsTypeLiteral([
-						readonlyProperty(
-							AST.tsPropertySignature(
-								AST.stringLiteral('shape'),
-								AST.tsTypeAnnotation(
-									AST.tsTypeReference(AST.identifier(shapeTypeName))
-								),
-								true
-							)
-						),
-						readonlyProperty(
-							AST.tsPropertySignature(
-								AST.stringLiteral(fragmentKey),
-								AST.tsTypeAnnotation(
-									AST.tsTypeLiteral([
-										AST.tsPropertySignature(
-											AST.stringLiteral(propTypeName),
-											AST.tsTypeAnnotation(
-												AST.tsLiteralType(AST.booleanLiteral(true))
-											)
-										),
-									])
-								)
-							)
-						),
-					])
-				)
-			),
-
-			// export the type that describes the fragments response data
-			AST.exportNamedDeclaration(
-				AST.tsTypeAliasDeclaration(
-					AST.identifier(shapeTypeName),
-					inlineType({
-						config,
-						filepath,
-						rootType: type,
-						selections,
-						root: true,
-						allowReadonly: true,
-						body,
-						visitedTypes,
-						missingScalars,
-						includeFragments: true,
-					})
-				)
-			)
-		)
-	}
-}