houdini 0.17.9 → 0.17.11

package/src/lib/graphql.ts

@@ -1,200 +0,0 @@
-import crypto from 'crypto'
-import * as graphql from 'graphql'
-
-import { HoudiniError } from './error'
-import * as path from './path'
-
-export function getRootType(type: graphql.GraphQLType): graphql.GraphQLType {
-	// if the type is non-null, unwrap and go again
-	if (graphql.isNonNullType(type)) {
-		return getRootType((type as graphql.GraphQLNonNull<any>).ofType)
-	}
-
-	// if the type is non-null, unwrap and go again
-	if (graphql.isListType(type)) {
-		return getRootType((type as graphql.GraphQLList<any>).ofType)
-	}
-
-	// we've unwrapped everything
-	return type
-}
-
-export function hashDocument(document: string | graphql.DocumentNode): string {
-	// if we were given an AST document, print it first
-	const docString = typeof document === 'string' ? document : graphql.print(document)
-
-	// hash the string
-	return crypto.createHash('sha256').update(docString).digest('hex')
-}
-
-type GraphQLParentType =
-	| graphql.GraphQLObjectType
-	| graphql.GraphQLInputObjectType
-	| graphql.GraphQLInterfaceType
-
-export function parentTypeFromAncestors(
-	schema: graphql.GraphQLSchema,
-	filepath: string,
-	ancestors: readonly any[]
-) {
-	const parents = [...ancestors] as (
-		| graphql.OperationDefinitionNode
-		| graphql.FragmentDefinitionNode
-		| graphql.SelectionNode
-	)[]
-	parents.reverse()
-
-	return walkAncestors(schema, filepath, parents)
-}
-
-function walkAncestors(
-	schema: graphql.GraphQLSchema,
-	filepath: string,
-	ancestors: (
-		| graphql.OperationDefinitionNode
-		| graphql.FragmentDefinitionNode
-		| graphql.SelectionNode
-		| graphql.SelectionSetNode
-	)[]
-): GraphQLParentType {
-	// get the front node
-	let head = ancestors.shift()
-	// if it was a list, skip it
-	if (Array.isArray(head)) {
-		return walkAncestors(schema, filepath, ancestors)
-	}
-
-	if (!head) {
-		throw new HoudiniError({ filepath, message: 'Could not figure out type of field' })
-	}
-
-	// if we are at the top of the definition stack
-	if (head.kind === 'OperationDefinition') {
-		// grab the appropriate
-		const operationType = {
-			query: schema.getQueryType(),
-			mutation: schema.getMutationType(),
-			subscription: schema.getSubscriptionType(),
-		}[head.operation]
-
-		if (!operationType) {
-			throw new HoudiniError({ filepath, message: 'Could not find operation type' })
-		}
-		return operationType
-	}
-
-	if (head.kind === 'FragmentDefinition') {
-		// look up the type condition in the schema
-		const result = schema.getType(head.typeCondition.name.value) as GraphQLParentType
-		if (!result) {
-			throw new HoudiniError({
-				filepath,
-				message: `Could not find definition for ${head.typeCondition.name.value} in the schema`,
-			})
-		}
-
-		// we're done here
-		return result
-	}
-
-	// if we are looking at a fragment spread there is a serious problem
-	if (head.kind === 'FragmentSpread') {
-		throw new Error('How the hell did this happen?')
-	}
-
-	// grab our parent type
-	const parent = walkAncestors(schema, filepath, ancestors)
-
-	// if we are looking at an inline fragment
-	if (head.kind === 'InlineFragment') {
-		// if there is no type condition, then our parents type is the answer
-		if (!head.typeCondition) {
-			return parent
-		}
-
-		// look at the type condition to find the type
-		const wrapper = schema.getType(head.typeCondition.name.value) as GraphQLParentType
-		if (!wrapper) {
-			throw new HoudiniError({
-				filepath,
-				message: 'Could not find type with name: ' + head.typeCondition.name.value,
-			})
-		}
-
-		return wrapper
-	}
-
-	// we are looking at a selection select our type is our parent's type
-	if (head.kind === 'SelectionSet') {
-		return parent
-	}
-	// we are looking at a field so we can just access the field map of the parent type
-	const field = parent.getFields()[head.name.value]
-	if (!field) {
-		throw new HoudiniError({
-			filepath,
-			message: `Could not find definition of ${head.name.value} in ${parent.toString()}`,
-		})
-	}
-
-	return getRootType(field.type) as GraphQLParentType
-}
-
-export function definitionFromAncestors(ancestors: readonly any[]) {
-	// in order to look up field type information we have to start at the parent
-	// and work our way down
-	// note:  the top-most parent is always gonna be a document so we ignore it
-	let parents = [...ancestors] as (
-		| graphql.FieldNode
-		| graphql.InlineFragmentNode
-		| graphql.FragmentDefinitionNode
-		| graphql.OperationDefinitionNode
-		| graphql.SelectionSetNode
-	)[]
-	parents.shift()
-
-	// the first meaningful parent is a definition of some kind
-	let definition = parents.shift() as
-		| graphql.FragmentDefinitionNode
-		| graphql.OperationDefinitionNode
-	while (Array.isArray(definition) && definition) {
-		// @ts-ignore
-		definition = parents.shift()
-	}
-
-	return definition
-}
-
-export function formatErrors(e: unknown, afterError?: (e: Error) => void) {
-	// we need an array of errors to loop through
-	const errors = (Array.isArray(e) ? e : [e]) as (Error & {
-		filepath?: string
-		description?: string
-	})[]
-
-	for (const error of errors) {
-		// if we have filepath, show that to the user
-		if ('filepath' in error && error.filepath) {
-			const relative = path.relative(process.cwd(), error.filepath)
-			console.error(`❌ Encountered error in ${relative}`)
-			if (error.message) {
-				console.error(error.message)
-			}
-		} else {
-			console.error(`❌ ${error.message}`)
-			if ('description' in error && error.description) {
-				console.error(`${error.description}`)
-			}
-		}
-		afterError?.(e as Error)
-	}
-}
-
-export function operation_requires_variables(operation: graphql.OperationDefinitionNode) {
-	return Boolean(
-		operation.variableDefinitions &&
-			operation.variableDefinitions?.find(
-				(defn) => defn.type.kind === 'NonNullType' && !defn.defaultValue
-			)
-	)
-}

package/src/lib/imports.ts

@@ -1,82 +0,0 @@
-import * as recast from 'recast'
-
-import { Config } from './config'
-
-const AST = recast.types.builders
-
-type Statement = recast.types.namedTypes.Statement
-type ImportDeclaration = recast.types.namedTypes.ImportDeclaration
-
-export function ensureArtifactImport({
-	config,
-	artifact,
-	body,
-	local,
-	withExtension,
-}: {
-	config: Config
-	artifact: { name: string }
-	body: Statement[]
-	local?: string
-	withExtension?: boolean
-}) {
-	return ensureImports({
-		config,
-		body,
-		sourceModule: config.artifactImportPath(artifact.name) + (withExtension ? '.js' : ''),
-		import: local || `_${artifact.name}Artifact`,
-	})
-}
-
-export function ensureImports<_Count extends string[] | string>({
-	config,
-	body,
-	import: importID,
-	sourceModule,
-	importKind,
-}: {
-	config: Config
-	body: Statement[]
-	import: _Count
-	sourceModule: string
-	importKind?: 'value' | 'type'
-}): _Count {
-	const idList = Array.isArray(importID) ? importID : [importID]
-
-	// figure out the list of things to import
-	const toImport = idList.filter(
-		(identifier) =>
-			!body.find(
-				(statement) =>
-					statement.type === 'ImportDeclaration' &&
-					(statement as ImportDeclaration).specifiers!.find(
-						(importSpecifier) =>
-							(importSpecifier.type === 'ImportSpecifier' &&
-								importSpecifier.imported.type === 'Identifier' &&
-								importSpecifier.imported.name === identifier &&
-								importSpecifier.local!.name === identifier) ||
-							(importSpecifier.type === 'ImportDefaultSpecifier' &&
-								importSpecifier.local!.type === 'Identifier' &&
-								importSpecifier.local!.name === identifier)
-					)
-			)
-	)
-
-	// add the import if it doesn't exist, add it
-	if (toImport.length > 0) {
-		body.unshift({
-			type: 'ImportDeclaration',
-			// @ts-ignore
-			source: AST.stringLiteral(sourceModule),
-			// @ts-ignore
-			specifiers: toImport.map((identifier) =>
-				!Array.isArray(importID)
-					? AST.importDefaultSpecifier(AST.identifier(identifier))
-					: AST.importSpecifier(AST.identifier(identifier), AST.identifier(identifier))
-			),
-			importKind,
-		})
-	}
-
-	return Array.isArray(importID) ? toImport : toImport[0]
-}

package/src/lib/index.ts

@@ -1,17 +0,0 @@
-export * from './pipeline'
-export * from './config'
-export * from './graphql'
-export * from './types'
-export * from './parse'
-export * from './imports'
-export * from './error'
-export * from './types'
-export * from './constants'
-export * from './introspection'
-export * from './cleanupFiles'
-
-export * from './walk'
-export type { EmbeddedGraphqlDocument } from './walk'
-
-export * as fs from './fs'
-export * as path from './path'

package/src/lib/introspection.ts

@@ -1,39 +0,0 @@
-import * as graphql from 'graphql'
-import fetch from 'node-fetch'
-
-import * as fs from './fs'
-
-export async function pullSchema(
-	url: string,
-	schemaPath: string,
-	headers?: Record<string, string>
-): Promise<boolean> {
-	try {
-		// send the request
-		const resp = await fetch(url, {
-			method: 'POST',
-			body: JSON.stringify({
-				query: graphql.getIntrospectionQuery(),
-			}),
-			headers: { 'Content-Type': 'application/json', ...headers },
-		})
-		const content = await resp.text()
-
-		const jsonSchema = JSON.parse(content).data
-		const schema = graphql.buildClientSchema(jsonSchema)
-
-		// Check if the schemapath ends with .gql or .graphql - if so write the schema as string
-		// Otherwise write the json/introspection
-		if (schemaPath!.endsWith('gql') || schemaPath!.endsWith('graphql')) {
-			const schemaAsString = graphql.printSchema(graphql.lexicographicSortSchema(schema))
-			await fs.writeFile(schemaPath, schemaAsString)
-		} else {
-			await fs.writeFile(schemaPath, JSON.stringify(jsonSchema))
-		}
-
-		return true
-	} catch (e) {
-		console.warn(`⚠️  Couldn't pull your latest schema: ` + (e as Error).message)
-	}
-	return false
-}

package/src/lib/parse.test.ts

@@ -1,75 +0,0 @@
-import { test, expect, describe } from 'vitest'
-
-import { parseJSON } from './parse'
-
-describe('parse', function () {
-	test('parseJSON without comments', async function () {
-		const original_file = `{
-  "extends": "./.svelte-kit/tsconfig.json",
-  "compilerOptions": {
-    "allowJs": true,
-    "checkJs": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "strict": true,
-    "noImplicitAny": true
-  }
-}
-`
-
-		const parsed = parseJSON(original_file)
-		expect(parsed).toMatchObject({
-			extends: './.svelte-kit/tsconfig.json',
-			compilerOptions: {
-				allowJs: true,
-				checkJs: true,
-				esModuleInterop: true,
-				forceConsistentCasingInFileNames: true,
-				resolveJsonModule: true,
-				skipLibCheck: true,
-				sourceMap: true,
-				strict: true,
-				noImplicitAny: true,
-			},
-		})
-	})
-
-	test('parseJSON with comments', async function () {
-		const original_file = `{
-  "extends": "./.svelte-kit/tsconfig.json",
-  "compilerOptions": {
-    "allowJs": true,
-		// this is a comment
-    "checkJs": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "strict": true,
-    "noImplicitAny": true
-  }
-	// this is another comment
-}
-`
-
-		const parsed = parseJSON(original_file)
-		expect(parsed).toMatchObject({
-			extends: './.svelte-kit/tsconfig.json',
-			compilerOptions: {
-				allowJs: true,
-				checkJs: true,
-				esModuleInterop: true,
-				forceConsistentCasingInFileNames: true,
-				resolveJsonModule: true,
-				skipLibCheck: true,
-				sourceMap: true,
-				strict: true,
-				noImplicitAny: true,
-			},
-		})
-	})
-})

package/src/lib/parse.ts

@@ -1,23 +0,0 @@
-import { parse as parseJavascript } from '@babel/parser'
-
-import type { Maybe, Script } from './types'
-
-export type ParsedFile = Maybe<{ script: Script; start: number; end: number }>
-
-export async function parseJS(str: string): Promise<ParsedFile> {
-	return {
-		start: 0,
-		// @ts-ignore
-		script: parseJavascript(str || '', {
-			plugins: ['typescript'],
-			sourceType: 'module',
-		}).program,
-		end: str.length,
-	}
-}
-
-export function parseJSON(str: string): any {
-	// remove all comments to be able to parse the file, and add stuff to it.
-	str = str.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => (g ? '' : m))
-	return JSON.parse(str)
-}

package/src/lib/path.ts

@@ -1,49 +0,0 @@
-import os from 'os'
-import path from 'path'
-
-// this package is meant to enforce posix conventions whenever
-// performing path-related tasks since in general we don't actually
-// want to consider the windows conventions. Those situations that _do_
-// care will have the necessary logic to turn the posix path into one
-// thats appropriate for windows
-
-// sep is always the posix one given ^
-export const sep = '/'
-
-export function resolve(...parts: string[]): string {
-	return posixify(path.resolve(...parts))
-}
-
-export function join(...parts: string[]): string {
-	return posixify(path.join(...parts))
-}
-
-export function extname(target: string): string {
-	return path.extname(target)
-}
-
-export function relative(from: string, to: string): string {
-	return posixify(path.relative(from, to))
-}
-
-export function basename(target: string): string {
-	return path.basename(target)
-}
-
-export function dirname(target: string): string {
-	return path.dirname(target)
-}
-
-export function isAbsolute(target: string): boolean {
-	return path.isAbsolute(target)
-}
-
-export function parse(target: string) {
-	return path.parse(target)
-}
-
-export const posixify = (str: string) => str.replace(/\\/g, '/')
-
-export function importPath(target: string): string {
-	return ['win32', 'win64'].includes(os.platform()) ? 'file:///' + target : target
-}

package/src/lib/pipeline.ts

@@ -1,17 +0,0 @@
-import type { Config } from './config'
-
-// transforms are functions that takes the collected documents. some will mutate
-// the document definition, some check the definition for errors (undefined fields, etc)
-export type Transform<_TransformType> =
-	| null
-	| ((config: Config, documents: _TransformType) => Promise<void>)
-
-export async function runPipeline<_TransformType>(
-	config: Config,
-	pipeline: Transform<_TransformType>[],
-	target: _TransformType
-) {
-	for (const transform of pipeline) {
-		await transform?.(config, target)
-	}
-}

package/src/lib/types.ts

@@ -1,34 +0,0 @@
-import graphql from 'graphql'
-import * as recast from 'recast'
-
-import { ArtifactKind, BaseCompiledDocument } from '../runtime/lib/types'
-import type { Config } from './config'
-
-type Program = recast.types.namedTypes.Program
-
-export type Maybe<T> = T | null | undefined
-
-export type Script = Program
-
-export type TransformDocument = {
-	instance: Maybe<Script>
-	config: Config
-	dependencies: string[]
-	filename: string
-}
-
-// the result of collecting documents from source code
-export type CollectedGraphQLDocument = {
-	kind: ArtifactKind
-	filename: string
-	name: string
-	document: graphql.DocumentNode
-	originalDocument: graphql.DocumentNode
-	generateArtifact: boolean
-	generateStore: boolean
-	originalString: string
-	refetch?: BaseCompiledDocument['refetch']
-}
-
-export * from '../runtime/lib/types'
-export * from '../runtime/lib/config'

package/src/lib/walk.ts

@@ -1,104 +0,0 @@
-import type { TaggedTemplateExpressionKind, IdentifierKind } from 'ast-types/gen/kinds'
-import { asyncWalk, BaseNode } from 'estree-walker'
-import * as graphql from 'graphql'
-
-import {
-	CompiledDocumentKind,
-	CompiledFragmentKind,
-	CompiledMutationKind,
-	CompiledQueryKind,
-	CompiledSubscriptionKind,
-} from '../runtime/lib/types'
-import { Config } from './config'
-import { Script } from './types'
-
-export type EmbeddedGraphqlDocument = {
-	parsedDocument: graphql.DocumentNode
-	artifact: {
-		name: string
-		kind: CompiledDocumentKind
-	}
-	node: BaseNode & {
-		remove: () => void
-		replaceWith: (node: BaseNode) => void
-	}
-	tagContent: string
-	parent: BaseNode
-}
-
-type GraphqlTagWalker = {
-	where?: (tag: graphql.DocumentNode) => boolean
-	dependency?: (fp: string) => void
-	tag: (tag: EmbeddedGraphqlDocument) => void | Promise<void>
-}
-
-// yield the tagged graphql documents contained within the provided AST
-export async function find_graphql(
-	config: Config,
-	parsedScript: Script,
-	walker: GraphqlTagWalker
-): Promise<void> {
-	await asyncWalk(parsedScript!, {
-		async enter(node, parent) {
-			// if we are looking at the graphql template tag
-			if (
-				node.type === 'TaggedTemplateExpression' &&
-				((node as TaggedTemplateExpressionKind).tag as IdentifierKind).name === 'graphql'
-			) {
-				const expr = node as TaggedTemplateExpressionKind
-				// we're going to replace the tag with something the runtime can use
-
-				// first, lets parse the tag contents to get the info we need
-				const tagContent = expr.quasi.quasis[0].value.raw
-				const parsedTag = graphql.parse(tagContent)
-
-				// if there is a predicate and the graphql tag does not satisfy it
-				if (walker.where && !walker.where(parsedTag)) {
-					// ignore the tag
-					return
-				}
-
-				// pull out the name of the thing
-				const definition = config.extractDefinition(parsedTag) as
-					| graphql.OperationDefinitionNode
-					| graphql.FragmentDefinitionNode
-				const name = definition.name?.value
-				if (!name) {
-					throw new Error('Could not find definition name')
-				}
-				let kind: CompiledDocumentKind
-				if (definition.kind === 'FragmentDefinition') {
-					kind = CompiledFragmentKind
-				} else {
-					if (definition.operation === 'query') {
-						kind = CompiledQueryKind
-					} else if (definition.operation === 'mutation') {
-						kind = CompiledMutationKind
-					} else {
-						kind = CompiledSubscriptionKind
-					}
-				}
-
-				// tell the walk there was a dependency
-				walker.dependency?.(config.artifactPath(parsedTag))
-
-				// invoker the walker's callback with the right context
-				await walker.tag({
-					parsedDocument: parsedTag,
-					node: {
-						...node,
-						...this,
-						remove: this.remove,
-						replaceWith: this.replace,
-					},
-					artifact: {
-						name,
-						kind,
-					},
-					parent,
-					tagContent,
-				})
-			}
-		},
-	})
-}