houdini 0.17.9 → 0.17.10

package/src/vite/ast.ts

@@ -1,107 +0,0 @@
-import * as recast from 'recast'
-
-type Statement = recast.types.namedTypes.Statement
-type Program = recast.types.namedTypes.Program
-type ExportNamedDeclaration = recast.types.namedTypes.ExportNamedDeclaration
-type FunctionDeclaration = recast.types.namedTypes.FunctionDeclaration
-type VariableDeclaration = recast.types.namedTypes.VariableDeclaration
-type Identifier = recast.types.namedTypes.Identifier
-type ArrowFunctionExpression = recast.types.namedTypes.ArrowFunctionExpression
-type FunctionExpression = recast.types.namedTypes.FunctionExpression
-
-export function find_insert_index(script: Program) {
-	let insert_index = script.body.findIndex((statement) => {
-		return statement.type !== 'ImportDeclaration'
-	})
-
-	// if we didn't find one, make sure we add stuff at the end of the file
-	if (insert_index === -1) {
-		insert_index = script.body.length
-	}
-
-	return insert_index
-}
-
-export function find_exported_fn(
-	body: Statement[],
-	name: string
-): FunctionDeclaration | FunctionExpression | ArrowFunctionExpression | null {
-	for (const statement of body) {
-		if (statement.type !== 'ExportNamedDeclaration') {
-			continue
-		}
-
-		const exportDeclaration = statement as ExportNamedDeclaration
-
-		// if the exported thing is a function it could be what we're looking for
-		if (exportDeclaration.declaration?.type === 'FunctionDeclaration') {
-			const value = exportDeclaration.declaration as FunctionDeclaration
-			if (value.id?.name === name) {
-				return exportDeclaration.declaration
-			}
-		}
-
-		// we also need to find exported variables that are functions or arrow functions
-		else if (exportDeclaration.declaration?.type === 'VariableDeclaration') {
-			const value = exportDeclaration.declaration as VariableDeclaration
-
-			// make sure that the declared value has a matching name
-			if (
-				value.declarations.length !== 1 ||
-				value.declarations[0].type !== 'VariableDeclarator' ||
-				value.declarations[0].id.type !== 'Identifier' ||
-				value.declarations[0].id.name !== name
-			) {
-				continue
-			}
-
-			// we only care about this exported thing if it's a function or arrow function
-			const declaration = value.declarations[0]
-
-			if (
-				declaration.init?.type === 'FunctionExpression' ||
-				declaration.init?.type === 'ArrowFunctionExpression'
-			) {
-				return declaration.init
-			}
-		}
-		// it wasn't something we care about, move along
-		else {
-			continue
-		}
-	}
-	const exported = body.find(
-		(expression) =>
-			expression.type === 'ExportNamedDeclaration' &&
-			(((expression as ExportNamedDeclaration).declaration?.type === 'FunctionDeclaration' &&
-				((expression as ExportNamedDeclaration).declaration as FunctionDeclaration).id
-					?.name === name) ||
-				((expression as ExportNamedDeclaration).declaration?.type ===
-					'VariableDeclaration' &&
-					((expression as ExportNamedDeclaration).declaration as VariableDeclaration)
-						.declarations.length === 1 &&
-					((expression as ExportNamedDeclaration).declaration as VariableDeclaration)
-						.declarations[0].type === 'Identifier' &&
-					(
-						((expression as ExportNamedDeclaration).declaration as VariableDeclaration)
-							.declarations[0] as Identifier
-					).name === name))
-	) as ExportNamedDeclaration
-	if (!exported) {
-		return null
-	}
-
-	return exported.declaration as FunctionDeclaration
-}
-
-export function find_exported_id(program: Program, name: string) {
-	return program.body.find<ExportNamedDeclaration>(
-		(statement): statement is ExportNamedDeclaration =>
-			statement.type === 'ExportNamedDeclaration' &&
-			statement.declaration?.type === 'VariableDeclaration' &&
-			statement.declaration.declarations.length === 1 &&
-			statement.declaration.declarations[0].type === 'VariableDeclarator' &&
-			statement.declaration.declarations[0].id.type === 'Identifier' &&
-			statement.declaration.declarations[0].id.name === name
-	)
-}

package/src/vite/houdini.ts

@@ -1,113 +0,0 @@
-import type { Plugin as VitePlugin } from 'vite'
-
-import generate from '../codegen'
-import { path, Config, getConfig, PluginConfig, formatErrors } from '../lib'
-
-let config: Config
-
-export default function Plugin(opts: PluginConfig = {}): VitePlugin {
-	return {
-		name: 'houdini',
-
-		// houdini will always act as a "meta framework" and process the user's code before it
-		// is processed by the user's library-specific plugins.
-		enforce: 'pre',
-
-		// add watch-and-run to their vite config
-		async config(viteConfig) {
-			config = await getConfig(opts)
-
-			return {
-				server: {
-					...viteConfig.server,
-					fs: {
-						...viteConfig.server?.fs,
-						allow: ['.'].concat(viteConfig.server?.fs?.allow || []),
-					},
-				},
-			}
-		},
-
-		// when the build starts, we need to make sure to generate
-		async buildStart() {
-			try {
-				await generate(config)
-			} catch (e) {
-				formatErrors(e)
-			}
-		},
-
-		// transform the user's code
-		async transform(code, filepath) {
-			// everything internal to houdini should assume posix paths
-			filepath = path.posixify(filepath)
-
-			if (filepath.startsWith('/src/')) {
-				filepath = path.join(process.cwd(), filepath)
-			}
-
-			// if the file is not in our configured source path, we need to ignore it
-			if (!config.includeFile(filepath)) {
-				return
-			}
-
-			// bundle up the contextual stuff
-			const ctx: TransformPage = {
-				content: code,
-				watch_file: this.addWatchFile,
-				config: config,
-				filepath,
-			}
-
-			// run the plugin pipeline
-			for (const plugin of config.plugins) {
-				if (!plugin.transform_file) {
-					continue
-				}
-				const { code } = await plugin.transform_file(ctx)
-				ctx.content = code
-			}
-
-			return { code: ctx.content }
-		},
-
-		async load(id, opts, ...rest) {
-			for (const plugin of config.plugins) {
-				if (typeof plugin.vite?.load !== 'function') {
-					continue
-				}
-
-				const result = await plugin.vite!.load.call(this, id, { ...opts, config }, ...rest)
-				if (result) {
-					return result
-				}
-			}
-		},
-
-		async resolveId(id, two, opts, ...rest) {
-			for (const plugin of config.plugins) {
-				if (typeof plugin.vite?.resolveId !== 'function') {
-					continue
-				}
-
-				const result = await plugin.vite!.resolveId.call(
-					this,
-					id,
-					two,
-					{ ...opts, config },
-					...rest
-				)
-				if (result) {
-					return result
-				}
-			}
-		},
-	}
-}
-
-export interface TransformPage {
-	config: Config
-	content: string
-	filepath: string
-	watch_file: (path: string) => void
-}

package/src/vite/imports.ts

@@ -1,129 +0,0 @@
-import * as recast from 'recast'
-
-import { Config } from '../lib/config'
-import { Script } from '../lib/types'
-import { TransformPage } from './houdini'
-
-const AST = recast.types.builders
-
-type Identifier = recast.types.namedTypes.Identifier
-type ImportDeclaration = recast.types.namedTypes.ImportDeclaration
-
-export function ensure_imports(args: {
-	config: Config
-	script: Script
-	import?: string
-	as?: never
-	sourceModule: string
-	importKind?: 'value' | 'type'
-}): { ids: Identifier; added: number }
-export function ensure_imports(args: {
-	config: Config
-	script: Script
-	import?: string[]
-	as?: string[]
-	sourceModule: string
-	importKind?: 'value' | 'type'
-}): { ids: Identifier[]; added: number }
-export function ensure_imports({
-	config,
-	script,
-	import: importID,
-	sourceModule,
-	importKind,
-	as,
-}: {
-	config: Config
-	script: Script
-	import?: string[] | string
-	as?: string[]
-	sourceModule: string
-	importKind?: 'value' | 'type'
-}): { ids: Identifier[] | Identifier; added: number } {
-	// if there is no import, we can simplify the logic, just look for something with a matching source
-	if (!importID) {
-		// look for an import from the source module
-		const has_import = script.body.find(
-			(statement) =>
-				statement.type === 'ImportDeclaration' && statement.source.value === sourceModule
-		)
-		if (!has_import) {
-			script.body.unshift({
-				type: 'ImportDeclaration',
-				source: AST.stringLiteral(sourceModule),
-				importKind,
-			})
-		}
-
-		return { ids: [], added: has_import ? 0 : 1 }
-	}
-
-	const idList = (Array.isArray(importID) ? importID : [importID]).map((id) => AST.identifier(id))
-
-	// figure out the list of things to import
-	const toImport = idList.filter(
-		(identifier) =>
-			!script.body.find(
-				(statement) =>
-					statement.type === 'ImportDeclaration' &&
-					(statement as unknown as ImportDeclaration).specifiers?.find(
-						(importSpecifier) =>
-							(importSpecifier.type === 'ImportSpecifier' &&
-								importSpecifier.imported.type === 'Identifier' &&
-								importSpecifier.imported.name === identifier.name &&
-								importSpecifier.local?.name === identifier.name) ||
-							(importSpecifier.type === 'ImportDefaultSpecifier' &&
-								importSpecifier.local?.type === 'Identifier' &&
-								importSpecifier.local.name === identifier.name &&
-								importSpecifier.local.name === identifier.name)
-					)
-			)
-	)
-
-	// add the import if it doesn't exist, add it
-	if (toImport.length > 0) {
-		script.body.unshift({
-			type: 'ImportDeclaration',
-			source: AST.stringLiteral(sourceModule),
-			specifiers: toImport.map((identifier, i) =>
-				!Array.isArray(importID)
-					? AST.importDefaultSpecifier(identifier)
-					: AST.importSpecifier(identifier, as?.[i] ? AST.identifier(as[i]) : identifier)
-			),
-			importKind,
-		})
-	}
-
-	// the resulting identifiers might have been aliased the as aliases if they exist
-	for (const [i, target] of (as ?? []).entries()) {
-		if (target) {
-			idList[i] = AST.identifier(target)
-		}
-	}
-
-	return {
-		ids: Array.isArray(importID) ? idList : idList[0],
-		added: toImport.length,
-	}
-}
-
-export function artifact_import({
-	config,
-	script,
-	artifact,
-	local,
-}: {
-	page: TransformPage
-	config: Config
-	script: Script
-	artifact: { name: string }
-	local?: string
-}) {
-	const { ids, added } = ensure_imports({
-		config,
-		script,
-		sourceModule: config.artifactImportPath(artifact.name),
-		import: local || `_${artifact.name}Artifact`,
-	})
-	return { id: ids, added }
-}

package/src/vite/index.ts

@@ -1,55 +0,0 @@
-import minimatch from 'minimatch'
-import type { Plugin } from 'vite'
-import watch_and_run from 'vite-plugin-watch-and-run'
-
-import generate from '../codegen'
-import { getConfig, PluginConfig, formatErrors, path } from '../lib'
-import houdini_vite from './houdini'
-import watch_remote_schema from './schema'
-
-export * from './ast'
-export * from './imports'
-export * from './schema'
-export * from './houdini'
-
-export default function (opts?: PluginConfig): Plugin[] {
-	// we need some way for the graphql tag to detect that we are running on the server
-	// so we don't get an error when importing.
-	process.env.HOUDINI_PLUGIN = 'true'
-
-	return [
-		houdini_vite(opts),
-		watch_remote_schema(opts),
-		watch_and_run([
-			{
-				name: 'Houdini',
-				quiet: true,
-				async watchFile(filepath: string) {
-					// load the config file
-					const config = await getConfig(opts)
-
-					// we need to watch some specific files
-					const schemaPath = path.join(path.dirname(config.filepath), config.schemaPath!)
-					if (minimatch(filepath, schemaPath)) {
-						return true
-					}
-
-					return config.includeFile(filepath, { root: process.cwd() })
-				},
-				async run() {
-					// load the config file
-					const config = await getConfig(opts)
-
-					// make sure we behave as if we're generating from inside the plugin (changes logging behavior)
-					config.pluginMode = true
-
-					// generate the runtime
-					await generate(config)
-				},
-				delay: 100,
-				watchKind: ['add', 'change', 'unlink'],
-				formatErrors,
-			},
-		]),
-	]
-}

package/src/vite/schema.ts

@@ -1,80 +0,0 @@
-import { sleep } from '@kitql/helper'
-import type { Plugin } from 'vite'
-
-import { formatErrors, getConfig, pullSchema, PluginConfig, path, fs } from '../lib'
-
-export default function HoudiniWatchSchemaPlugin(opts: PluginConfig = {}): Plugin {
-	let go = true
-
-	return {
-		name: 'houdini-watch-schema',
-		apply: 'serve',
-		async buildStart() {
-			const config = await getConfig(opts)
-			let nbPullError = 0
-
-			// validate the config
-
-			// if there's no api url set, there's nothing to poll
-			if (!config.apiUrl) {
-				return
-			}
-
-			// if the schema path is a glob, there's no reason to poll (the schema is already local)
-			if (config.schemaPath && fs.glob.hasMagic(config.schemaPath)) {
-				return
-			}
-
-			const interval = config.schemaPollInterval
-
-			// an interval of null means no initial poll
-			if (interval === null) {
-				return
-			}
-
-			// the function to call on the appropriate interval
-			async function pull(more: boolean) {
-				try {
-					// Write the schema
-					const schemaState = await pullSchema(
-						config.apiUrl!,
-						config.schemaPath ?? path.resolve(process.cwd(), 'schema.json'),
-						config.pullHeaders
-					)
-
-					nbPullError = schemaState ? 0 : nbPullError + 1
-				} catch (e) {
-					formatErrors(e)
-				}
-
-				// if we are supposed to poll more, wait the appropriate amount of time and then do it again
-				if (more) {
-					// Wait more and more and more...
-					const timeToWait = interval! + interval! * nbPullError
-					await sleep(timeToWait)
-
-					if (go) {
-						pull(more)
-					}
-				}
-			}
-
-			// its safe to pull the schema
-			await pull(false)
-
-			// if we aren't supposed to poll at all
-			if (interval <= 0) {
-				return
-			}
-
-			// wait once before starting the loop
-			await sleep(interval)
-
-			// start listening
-			await pull(true)
-		},
-		buildEnd() {
-			go = false
-		},
-	}
-}