houdini-core 2.0.0-go.0

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "houdini-core",
+    "version": "2.0.0-go.0",
+    "scripts": {
+        "compile": "scripts build-go",
+        "typedefs": "scripts typedefs --go-package",
+        "postinstall": "node postInstall.js"
+    },
+    "devDependencies": {},
+    "dependencies": {
+        "@whatwg-node/server": "^0.9.14",
+        "graphql-yoga": "^4.0.4",
+        "minimatch": "^5.1.0"
+    },
+    "optionalDependencies": {
+        "houdini-core-darwin-amd64": "2.0.0-go.0",
+        "houdini-core-darwin-arm64": "2.0.0-go.0",
+        "houdini-core-linux-amd64": "2.0.0-go.0",
+        "houdini-core-linux-arm64": "2.0.0-go.0",
+        "houdini-core-windows-amd64": "2.0.0-go.0",
+        "houdini-core-windows-arm64": "2.0.0-go.0"
+    },
+    "bin": "./shim.cjs"
+}

package/postInstall.js

@@ -0,0 +1,117 @@
+const fs = require('fs')
+const path = require('path')
+const zlib = require('zlib')
+const https = require('https')
+
+// Adjust the version you want to install. You can also make this dynamic.
+const BINARY_DISTRIBUTION_VERSION = '2.0.0-go.0'
+
+// Windows binaries end with .exe so we need to special case them.
+const binaryName = process.platform === 'win32' ? 'houdini-core.exe' : 'houdini-core'
+
+// Determine package name for this platform
+const platformSpecificPackageName = `houdini-core-${process.platform}-${process.arch}`
+
+// Compute the path we want to emit the fallback binary to
+const fallbackBinaryPath = path.join(__dirname, binaryName)
+
+function makeRequest(url) {
+	return new Promise((resolve, reject) => {
+		https
+			.get(url, (response) => {
+				if (response.statusCode >= 200 && response.statusCode < 300) {
+					const chunks = []
+					response.on('data', (chunk) => chunks.push(chunk))
+					response.on('end', () => {
+						resolve(Buffer.concat(chunks))
+					})
+				} else if (
+					response.statusCode >= 300 &&
+					response.statusCode < 400 &&
+					response.headers.location
+				) {
+					// Follow redirects
+					makeRequest(response.headers.location).then(resolve, reject)
+				} else {
+					reject(
+						new Error(
+							`npm responded with status code ${response.statusCode} when downloading the package!`
+						)
+					)
+				}
+			})
+			.on('error', (error) => {
+				reject(error)
+			})
+	})
+}
+
+function extractFileFromTarball(tarballBuffer, filepath) {
+	// Tar archives are organized in 512 byte blocks.
+	// Blocks can either be header blocks or data blocks.
+	// Header blocks contain file names of the archive in the first 100 bytes, terminated by a null byte.
+	// The size of a file is contained in bytes 124-135 of a header block and in octal format.
+	// The following blocks will be data blocks containing the file.
+	let offset = 0
+	while (offset < tarballBuffer.length) {
+		const header = tarballBuffer.subarray(offset, offset + 512)
+		offset += 512
+
+		const fileName = header.toString('utf-8', 0, 100).replace(/\0.*/g, '')
+		const fileSize = parseInt(header.toString('utf-8', 124, 136).replace(/\0.*/g, ''), 8)
+
+		if (fileName === filepath) {
+			return tarballBuffer.subarray(offset, offset + fileSize)
+		}
+
+		// Clamp offset to the uppoer multiple of 512
+		offset = (offset + fileSize + 511) & ~511
+	}
+}
+
+async function downloadBinaryFromNpm() {
+	// Download the tarball of the right binary distribution package
+	const tarballDownloadBuffer = await makeRequest(
+		`https://registry.npmjs.org/${platformSpecificPackageName}/-/${platformSpecificPackageName}-${BINARY_DISTRIBUTION_VERSION}.tgz`
+	)
+
+	const tarballBuffer = zlib.unzipSync(tarballDownloadBuffer)
+
+	// Extract binary from package and write to disk
+	fs.writeFileSync(
+		fallbackBinaryPath,
+		extractFileFromTarball(tarballBuffer, `package/bin/${binaryName}`),
+		{ mode: 0o755 } // Make binary file executable
+	)
+}
+
+function isPlatformSpecificPackageInstalled() {
+	try {
+		// Resolving will fail if the optionalDependency was not installed
+		require.resolve(`${platformSpecificPackageName}/bin/${binaryName}`)
+		return true
+	} catch (e) {
+		return false
+	}
+}
+
+if (!platformSpecificPackageName) {
+	throw new Error('Platform not supported!')
+}
+
+// once we've confirmed the required package is installed we want to overwrite the bin entry of our package.json
+// to point to the correct binary
+function overwriteBinary() {
+	const packageJsonPath = path.join(__dirname, 'package.json')
+	const packageJson = require(packageJsonPath)
+	packageJson.bin = path.join('..', platformSpecificPackageName, 'bin', binaryName)
+	fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2))
+}
+
+// Skip downloading the binary if it was already installed via optionalDependencies
+if (!isPlatformSpecificPackageInstalled()) {
+	console.log('Platform specific package not found. Will manually download binary.')
+	downloadBinaryFromNpm().then(overwriteBinary)
+} else {
+	overwriteBinary()
+}

package/runtime/cache.ts

@@ -0,0 +1,5 @@
+import { Cache } from 'houdini/runtime/cache'
+
+import { getCurrentConfig } from './config'
+
+export default new Cache(getCurrentConfig())

package/runtime/client.ts

@@ -0,0 +1,181 @@
+import type { Cache } from 'houdini/runtime/cache'
+import { HoudiniClient as BaseClient, type ObserveParams } from 'houdini/runtime/client'
+import { createPluginHooks } from 'houdini/runtime/client'
+import { DocumentStore, type ClientPlugin } from 'houdini/runtime/documentStore'
+import { flatten } from 'houdini/runtime/flatten'
+import type {
+	NestedList,
+	DocumentArtifact,
+	GraphQLObject,
+	GraphQLVariables,
+} from 'houdini/runtime/types'
+
+import cacheRef from './cache'
+import { getCurrentConfig, localApiEndpoint } from './config'
+import type { FetchParamFn, ThrowOnErrorParams } from './plugins'
+import {
+	fetch as fetchPlugin,
+	fetchParams as fetchParamsPlugin,
+	fragment as fragmentPlugin,
+	mutation as mutationPlugin,
+	query as queryPlugin,
+	throwOnError as throwOnErrorPlugin,
+	optimisticKeys,
+	cachePolicy,
+} from './plugins'
+import pluginsFromPlugins from './plugins/injectedPlugins'
+
+// export the plugin constructors
+export { fetch, mutation, query, subscription } from './plugins'
+export { DocumentStore, type ClientPlugin, type SendParams } from 'houdini/runtime/documentStore'
+
+export type HoudiniClientConstructorArgs = {
+	url?: string
+	fetchParams?: FetchParamFn
+	plugins?: NestedList<ClientPlugin>
+	pipeline?: NestedList<ClientPlugin>
+	throwOnError?: ThrowOnErrorParams
+	cache?: Cache
+}
+
+export class HoudiniClient extends BaseClient {
+	// this is modified by page entries when they load in order to register the components source
+	componentCache: Record<string, any> = {}
+
+	// store cache configuration for use in document stores
+	private _cache?: Cache
+	private _enableCache: boolean = false
+
+	// store throwOnError operations for access by stores
+	throwOnError_operations: string[] = []
+
+	constructor({
+		url,
+		fetchParams,
+		plugins,
+		pipeline,
+		throwOnError,
+		cache = cacheRef,
+	}: HoudiniClientConstructorArgs = {}) {
+		// if we were given plugins and pipeline there's an error
+		if (plugins && pipeline) {
+			throw new Error(
+				'A client cannot be given a pipeline and a list of plugins at the same time.'
+			)
+		}
+
+		let serverPort = globalThis.process?.env?.HOUDINI_PORT ?? '5173'
+
+		super({
+			config: getCurrentConfig,
+			url:
+				url ??
+				(globalThis.window ? '' : `https://localhost:${serverPort}`) +
+					localApiEndpoint(getCurrentConfig()),
+			plugins: flatten(
+				([] as NestedList<ClientPlugin>).concat(
+					// if they specified a throw behavior
+					throwOnError ? [throwOnErrorPlugin(throwOnError)] : [],
+					fetchParamsPlugin(fetchParams),
+					// if the user wants to specify the entire pipeline, let them do so
+					pipeline ??
+						// the user doesn't have a specific pipeline so we should just add their desired plugins
+						// to the standard set
+						(
+							[
+								optimisticKeys(cache ?? cacheRef),
+								// make sure that documents always work
+								queryPlugin(cache ?? cacheRef),
+								mutationPlugin(cache ?? cacheRef),
+								fragmentPlugin(cache ?? cacheRef),
+							] as NestedList<ClientPlugin>
+						).concat(
+							// add the specified middlewares
+							plugins ?? [],
+							// and any middlewares we got from plugins
+							pluginsFromPlugins,
+							// if they provided a fetch function, use it as the body for the fetch middleware
+							fetchPlugin()
+						)
+				)
+			),
+		})
+
+		// Set cache properties after super call
+		this._cache = cache
+		this._enableCache = !!cache
+
+		// Set throwOnError operations for access by stores
+		this.throwOnError_operations = throwOnError?.operations ?? []
+	}
+
+	// Override observe to properly handle cachePolicy plugin
+	observe<_Data extends GraphQLObject, _Input extends GraphQLVariables | undefined>({
+		enableCache = true,
+		fetching = false,
+		...rest
+	}: ObserveParams<_Data, DocumentArtifact, _Input>): DocumentStore<_Data, _Input> {
+		// Create plugins with cachePolicy if cache is enabled
+		const plugins: ClientPlugin[] = []
+
+		// Add cachePolicy first if cache is enabled
+		if (this._enableCache && enableCache) {
+			// We need to create a placeholder for the setFetching callback
+			// that will be set after the store is created
+			let storeRef: DocumentStore<_Data, _Input> | null = null
+
+			plugins.push(
+				cachePolicy({
+					cache: this._cache,
+					enabled: true,
+					setFetching: (fetching, data) => {
+						if (storeRef) {
+							storeRef.update((state) => {
+								const newState = { ...state, fetching }
+
+								// when we set the fetching state to true, we should also generate the appropriate
+								// loading state for the document
+								if (fetching && data) {
+									newState.data = data
+								}
+
+								return newState
+							})
+						}
+					},
+				})
+			)
+
+			// Create the document store with the plugins
+			const clientPlugins = (this.plugins as ClientPlugin[]).filter(
+				(p): p is ClientPlugin => p !== null && typeof p === 'function'
+			)
+			const store = new DocumentStore<_Data, _Input>({
+				client: this,
+				plugins: createPluginHooks([...plugins, ...clientPlugins]),
+				fetching,
+				enableCache,
+				config: this.config,
+				...rest,
+			})
+
+			// Set the store reference for the setFetching callback
+			storeRef = store
+
+			return store
+		} else {
+			// No cache, use the base implementation
+			const clientPlugins = (this.plugins as ClientPlugin[]).filter(
+				(p): p is ClientPlugin => p !== null && typeof p === 'function'
+			)
+			return new DocumentStore<_Data, _Input>({
+				client: this,
+				plugins: createPluginHooks(clientPlugins),
+				fetching,
+				enableCache,
+				config: this.config,
+				...rest,
+			})
+		}
+	}
+}

package/runtime/config.ts

@@ -0,0 +1,79 @@
+import type { ConfigFile } from 'houdini'
+
+import config from './imports/config'
+import pluginConfigs from './imports/pluginConfig'
+
+let mockConfig: ConfigFile | null = null
+
+export function getMockConfig() {
+	return mockConfig
+}
+
+export function setMockConfig(config: ConfigFile | null) {
+	mockConfig = config
+}
+
+export function defaultConfigValues(file: ConfigFile): ConfigFile {
+	return {
+		defaultKeys: ['id'],
+		...file,
+		types: {
+			Node: {
+				keys: ['id'],
+				resolve: {
+					queryField: 'node',
+					arguments: (node) => ({ id: node.id }),
+				},
+			},
+			...file.types,
+		},
+	}
+}
+
+export function keyFieldsForType(configFile: ConfigFile, type: string) {
+	const withDefault = defaultConfigValues(configFile)
+	return withDefault.types?.[type]?.keys || withDefault.defaultKeys!
+}
+
+export function computeID(configFile: ConfigFile, type: string, data: any): string {
+	const fields = keyFieldsForType(configFile, type)
+	let id = ''
+
+	for (const field of fields) {
+		id += data[field] + '__'
+	}
+
+	return id.slice(0, -2)
+}
+
+// only compute the config file once
+let _configFile: ConfigFile | null = null
+
+export function localApiEndpoint(configFile: ConfigFile) {
+	// @ts-ignore
+	return configFile.router?.apiEndpoint ?? '/_api'
+}
+
+export function getCurrentConfig(): ConfigFile {
+	const mockConfig = getMockConfig()
+	if (mockConfig) {
+		return mockConfig
+	}
+
+	if (_configFile) {
+		return _configFile
+	}
+
+	// we have to compute the config file. start with the default values
+	// iterate over every plugin config value and merge the result
+	let configFile = defaultConfigValues(config)
+	for (const pluginConfig of pluginConfigs) {
+		configFile = pluginConfig(configFile)
+	}
+
+	// save the result for later
+	_configFile = configFile
+
+	// we're done
+	return configFile
+}

package/runtime/generated.ts

@@ -0,0 +1 @@
+export type { CacheTypeDef } from 'houdini/runtime/types'

package/runtime/imports/config.ts

@@ -0,0 +1,3 @@
+import type { ConfigFile } from 'houdini'
+
+export default {} as ConfigFile

package/runtime/imports/pluginConfig.ts

@@ -0,0 +1,5 @@
+import type { ConfigFile } from 'houdini'
+
+const configs: ((old: ConfigFile) => ConfigFile)[] = []
+
+export default configs

package/runtime/index.ts

@@ -0,0 +1,38 @@
+import type { Cache as InternalCache } from 'houdini/runtime/cache'
+
+import _cache from './cache'
+import type { CacheTypeDef } from './generated'
+import { Cache } from './public'
+
+export { CachePolicy, PendingValue } from 'houdini/runtime'
+
+export * from './client'
+export { getCurrentConfig } from './config'
+
+// this template tag gets removed by the preprocessor so it should never be invoked.
+// this function must return any so that we can assign it a type in a variable declaration (ie an inline store)
+// ideally we would be able to parse the input for values but typescript does not yet support that kind of matches in template args
+export function graphql<_Payload, _Result = _Payload>(str: string): _Result
+export function graphql(str: string): never {
+	// if we are executing this function as part of the plugin, we need to return
+	// the query instead of throwing an error. We don't want to bundle the graphql
+	// module into the runtime so all we can do is return the query string
+	if (globalThis?.process?.env?.HOUDINI_PLUGIN) {
+		// @ts-ignore: this is a totally internal/hidden value. user will never see it and we won't
+		//             and ever get a typed value of this since it's only used in the result of a dynamic
+		//             import from the plugin which gives Record<string, any>
+		return str
+	}
+
+	// if this is executed, the preprocessor is not enabled
+	throw new Error(`! graphql template was invoked at runtime. This should never happen and usually means that your project isn't properly configured.
+
+Please make sure you have the appropriate plugin/preprocessor enabled. For more information, visit this link: https://houdinigraphql.com/guides/setting-up-your-project
+`)
+}
+
+export const cache = new Cache<CacheTypeDef>(_cache)
+
+export function getCache(): InternalCache {
+	return _cache
+}

package/runtime/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/runtime/plugins/cache.ts

@@ -0,0 +1,178 @@
+import { Cache } from 'houdini/runtime/cache'
+import type { ClientPlugin } from 'houdini/runtime/documentStore'
+import { ArtifactKind, CachePolicy, DataSource, type GraphQLObject } from 'houdini/runtime/types'
+
+import cache from '../cache'
+
+const serverSide = typeof globalThis.window === 'undefined'
+
+export const cachePolicy =
+	({
+		enabled,
+		setFetching,
+		cache: localCache = cache,
+		serverSideFallback = true,
+	}: {
+		enabled: boolean
+		setFetching: (val: boolean, data?: any) => void
+		cache?: Cache
+		serverSideFallback?: boolean
+	}): ClientPlugin =>
+	() => {
+		return {
+			beforeNetwork(ctx, { initialValue, next, resolve, marshalVariables }) {
+				const { policy, artifact } = ctx
+				let useCache = false
+				// enforce cache policies for queries
+				if (
+					enabled &&
+					(artifact.kind === ArtifactKind.Query ||
+						artifact.kind === ArtifactKind.Fragment) &&
+					!ctx.cacheParams?.disableRead
+				) {
+					// this function is called as the first step in requesting data. If the policy prefers
+					// cached data, we need to load data from the cache (if its available). If the policy
+					// prefers network data we need to send a request (the onLoad of the component will
+					// resolve the next data)
+
+					// if the cache policy allows for cached data, look at the cache's value first
+					const policyAllowsCache =
+						policy !== CachePolicy.NetworkOnly && policy !== CachePolicy.NoCache
+					if (policyAllowsCache) {
+						// look up the current value in the cache
+						const value = localCache.read({
+							selection: artifact.selection,
+							variables: marshalVariables(ctx),
+							fullCheck: true,
+						})
+
+						// we can only use the result if its not a partial result
+						const allowed =
+							!value.partial ||
+							// or the artifact allows for partial responses
+							(artifact.kind === ArtifactKind.Query && artifact.partial)
+
+						// if the policy is cacheOnly and we got this far, we need to return null (no network request will be sent)
+						if (policy === CachePolicy.CacheOnly) {
+							return resolve(ctx, {
+								fetching: false,
+								variables: ctx.variables ?? null,
+								data: allowed ? value.data : initialValue.data,
+								errors: null,
+								source: DataSource.Cache,
+								partial: allowed ? value.partial : false,
+								stale: value.stale,
+							})
+						}
+
+						// if we have data, use that unless it's partial data and we don't allow that
+						useCache = !!(value.data !== null && allowed)
+
+						if (useCache) {
+							resolve(ctx, {
+								fetching: false,
+								variables: ctx.variables ?? null,
+								data: value.data,
+								errors: null,
+								source: DataSource.Cache,
+								partial: value.partial,
+								stale: value.stale,
+							})
+						}
+
+						// if we used the cache data and there's no followup necessary, we're done
+						if (
+							useCache &&
+							!value.partial &&
+							!value.stale &&
+							// if the policy is CacheAndNetwork then we don't want to stop here regardless
+							ctx.policy !== 'CacheAndNetwork'
+						) {
+							return
+						}
+					}
+				}
+
+				// we're not using the cached data which means there will be a network request
+				// tick the garbage collector asynchronously
+				if (enabled) {
+					setTimeout(() => {
+						localCache._internal_unstable.collectGarbage()
+					}, 0)
+				}
+
+				// if we got this far, we are resolving something against the network
+				// don't set the fetching state to true if we accepted a cache value
+				if (!ctx.stuff?.silenceLoading) {
+					// don't set the fetching state to true if we accepted a cache value
+					let fetchingState: GraphQLObject | null = null
+					if (
+						!useCache &&
+						'enableLoadingState' in artifact &&
+						artifact.enableLoadingState
+					) {
+						fetchingState = localCache.read({
+							selection: artifact.selection,
+							variables: marshalVariables(ctx),
+							loading: true,
+						}).data
+					}
+					setFetching(!useCache, fetchingState)
+				}
+				// move on
+				return next(ctx)
+			},
+			afterNetwork(ctx, { resolve, value, marshalVariables }) {
+				// if we have data coming in from the cache, we should write it and move on
+				if (
+					ctx.policy !== CachePolicy.NoCache &&
+					value.source !== DataSource.Cache &&
+					enabled &&
+					value.data &&
+					!ctx.cacheParams?.disableWrite
+				) {
+					// if the cache params specify a fallback behavior, use that
+					if (ctx.cacheParams && 'serverSideFallback' in ctx.cacheParams) {
+						serverSideFallback =
+							ctx.cacheParams?.serverSideFallback ?? serverSideFallback
+					}
+
+					const targetCache =
+						serverSide && serverSideFallback
+							? new Cache({ disabled: false, ...ctx.config })
+							: localCache
+
+					let layer
+					if (!serverSide && ctx.cacheParams?.layer) {
+						layer = ctx.cacheParams.layer.id
+					}
+
+					// write the result of the mutation to the cache
+					targetCache.write({
+						...ctx.cacheParams,
+						layer,
+						selection: ctx.artifact.selection,
+						data: value.data,
+						variables: marshalVariables(ctx),
+					})
+
+					// we need to embed the fragment context values in our response
+					// and apply masking other value transforms. In order to do that,
+					// we're going to read back what we just wrote. This only incurs
+					// extra computation on the server-side since we have to write the values
+					// before we can read them (instead of just transforming the value directly)
+					value = {
+						...value,
+						data: targetCache.read({
+							selection: ctx.artifact.selection,
+							variables: marshalVariables(ctx),
+							ignoreMasking: serverSide,
+						}).data,
+					}
+				}
+
+				// we're done. don't change the result value
+				resolve(ctx, value)
+			},
+		}
+	}