crelte 0.5.10 → 0.5.11

package/src/server/queries/queries.ts

@@ -1,8 +1,10 @@
 import ServerRouter from '../ServerRouter.js';
 import QueriesCaching from './QueriesCaching.js';
-import { CacheIfFn, QueryRoute, TransformFn } from './routes.js';
+import { CacheIfFn, HandleFn, TransformFn } from './routes.js';
 import { isQueryVar, QueryVar } from '../../queries/vars.js';
 import { Platform } from '../platform.js';
+import QueryHandleRoute from './QueryHandleRoute.js';
+import QueryGqlRoute from './QueryGqlRoute.js';
 
 type ModQuery = {
 	default: { name: string };
@@ -13,17 +15,20 @@ type ModTs = {
 	variables?: any;
 	caching?: any;
 	transform?: any;
+	handle?: any;
 };
 
 type ModQueries = Record<string, ModQuery | ModTs>;
 
-type PreRoute = {
+type RouteBuilder = {
 	query: string | null;
 	jsFile: string | null;
 	vars: Record<string, QueryVar> | null;
+	/** corresponds to the caching export */
 	cacheIfFn: CacheIfFn | null;
 	preventCaching: boolean;
 	transformFn: TransformFn | null;
+	handleFn: HandleFn | null;
 };
 
 export async function initQueryRoutes(
@@ -33,59 +38,67 @@ export async function initQueryRoutes(
 ): Promise<void> {
 	if (typeof mod.queries !== 'object') {
 		throw new Error(
-			"expected `export const queries = import.meta.glob('@/queries/*', { eager: true });` in server.js",
+			'expected `export const queries = import.meta.glob(' +
+				"'@/queries/*', { eager: true });` in server.js",
 		);
 	}
 
 	const debugCaching = !!mod?.debugCaching;
 	const modQueries: ModQueries = mod.queries;
 
-	const preRoutes: Map<string, PreRoute> = new Map();
+	const routeBuilders: Map<string, RouteBuilder> = new Map();
 
 	for (const [file, mq] of Object.entries(modQueries)) {
 		const filename = file.split('/').pop()!;
 		const dotPos = filename.lastIndexOf('.');
 		const name = filename.substring(0, dotPos);
 
-		let preRoute = preRoutes.get(name);
-		if (!preRoute) {
-			preRoute = {
+		let routeBuilder = routeBuilders.get(name);
+		if (!routeBuilder) {
+			routeBuilder = {
 				query: null,
 				jsFile: null,
 				vars: null,
 				cacheIfFn: null,
 				preventCaching: false,
 				transformFn: null,
+				handleFn: null,
 			};
-			preRoutes.set(name, preRoute);
+			routeBuilders.set(name, routeBuilder);
 		}
 
 		// set the gql query (this can only happen once)
 		if (filename.endsWith('.graphql')) {
-			preRoute.query = (mq as ModQuery).query.query;
+			routeBuilder.query = (mq as ModQuery).query.query;
 			continue;
 		}
 
 		// now check that only one file matches
-		if (preRoute.jsFile) {
+		if (routeBuilder.jsFile) {
 			throw new Error(
-				`cannot have two files for the same query ${preRoute.jsFile} and ${filename}`,
+				`cannot have two files for the same query ${
+					routeBuilder.jsFile
+				} and ${filename}`,
 			);
 		}
 
 		const mts = mq as ModTs;
 		if (mts.variables) {
-			preRoute.vars = parseVars(mts.variables);
+			routeBuilder.vars = parseVars(mts.variables);
 		}
 
 		if (mts.caching) {
-			preRoute.cacheIfFn = parseCaching(mts.caching);
+			routeBuilder.cacheIfFn = parseCaching(mts.caching);
 		} else if (typeof mts.caching === 'boolean') {
-			preRoute.preventCaching = true;
+			routeBuilder.preventCaching = true;
 		}
 
 		if (mts.transform) {
-			preRoute.transformFn = parseTransform(mts.transform);
+			routeBuilder.transformFn = parseTransform(mts.transform);
+		}
+
+		if (mts.handle) {
+			routeBuilder.handleFn = parseHandle(mts.handle);
 		}
 	}
 
@@ -93,14 +106,30 @@ export async function initQueryRoutes(
 		debug: debugCaching,
 	});
 
-	for (const [name, pr] of preRoutes.entries()) {
-		if (!pr.query) throw new Error(`no .graphql file for query ${name}`);
+	for (const [name, rb] of routeBuilders.entries()) {
+		if (rb.query) {
+			if (rb.handleFn) throw new Error('handle function not supported');
 
-		const route = new QueryRoute(name, pr.query, pr);
+			const route = new QueryGqlRoute(name, rb.query, rb);
 
-		router.post('/queries/' + route.name, async csr =>
-			route.handle(caching, csr),
-		);
+			router.post('/queries/' + route.name, csr =>
+				route.handle(caching, csr),
+			);
+		} else if (rb.handleFn) {
+			if (rb.cacheIfFn || rb.transformFn || rb.preventCaching)
+				throw new Error('caching or transform not supported');
+
+			const route = new QueryHandleRoute(name, rb.handleFn, rb.vars);
+
+			router.post('/queries/' + route.name, csr =>
+				route.handle(caching.router, csr),
+			);
+		} else {
+			throw new Error(
+				`query js/ts ${name} file needs to either have ` +
+					'a .graphql file or a handle function',
+			);
+		}
 	}
 }
 
@@ -137,3 +166,10 @@ function parseTransform(transform: any): TransformFn {
 
 	return transform;
 }
+
+function parseHandle(handle: any): HandleFn {
+	if (typeof handle !== 'function')
+		throw new Error('handle should be a function');
+
+	return handle;
+}

package/src/server/queries/routes.ts

@@ -1,9 +1,6 @@
+import { QueryVar } from '../../queries/vars.js';
 import CrelteServerRequest from '../CrelteServer.js';
-import QueriesCaching from './QueriesCaching.js';
-import { QueryVar, vars } from '../../queries/vars.js';
-import { extractEntry } from '../../loadData/index.js';
 import ServerRouter from '../ServerRouter.js';
-import { calcKey } from '../../ssr/index.js';
 
 export type CacheIfFn = (response: any, vars: Record<string, any>) => boolean;
 
@@ -16,233 +13,32 @@ export type TransformFn = (
 	vars: Record<string, any>,
 ) => void | any | Promise<void | any>;
 
-export type QueryRouteArgs = {
-	vars: Record<string, QueryVar> | null;
-	cacheIfFn: CacheIfFn | null;
-	preventCaching: boolean;
-	transformFn: TransformFn | null;
-};
-
-// only internal
-export class QueryRoute {
-	name: string;
-	query: string;
-	vars: Record<string, QueryVar> | null;
-	cacheIfFn: CacheIfFn | null;
-	transformFn: TransformFn | null;
-
-	constructor(name: string, query: string, args: QueryRouteArgs) {
-		if (args.cacheIfFn && !vars)
-			throw new Error(
-				'queryRoute: ' +
-					name +
-					' cannot have caching function if there are no ' +
-					'variables defined',
-			);
-
-		this.name = name;
-		this.query = query;
-		this.vars = args.vars;
-		this.cacheIfFn = args.cacheIfFn;
-		this.transformFn = args.transformFn;
-
-		if (args.preventCaching) {
-			if (this.cacheIfFn) throw new Error('unreachable');
-			// prevent filling defaults
-			return;
-		}
-
-		// add default vars and cacheIfFn if we know the route
-		if (this.name === 'entry') this.fillEntryDefaults();
-		else if (this.name === 'global') this.fillGlobalDefaults();
-		else this.fillBasicDefaults();
-	}
-
-	private fillEntryDefaults() {
-		if (this.vars) return;
-
-		// the _setName step happens in parseVars which happens before setting
-		// the defaults
-		this.vars = {
-			siteId: vars.siteId().z_setName('siteId'),
-			uri: vars.string().z_setName('uri'),
-		};
-		this.cacheIfFn = res => !!extractEntry(res);
-	}
-
-	private fillGlobalDefaults() {
-		if (this.vars) return;
-
-		this.vars = { siteId: vars.siteId().z_setName('siteId') };
-		this.cacheIfFn = () => true;
-	}
-
-	/**
-	 * This adds caching to queries containing `query {` or
-	 * `query ($siteId: [QueryArgument) {` without any additional vars
-	 */
-	private fillBasicDefaults() {
-		if (this.vars) return;
-
-		const NO_VAR_TEST = /(^|\s)query\s*{/;
-		const SITE_ID_VAR_TEST =
-			/(^|\s)query\s*\(\s*\$siteId\s*:\s*\[\s*QueryArgument\s*\]\s*\)\s*{/;
-
-		if (NO_VAR_TEST.test(this.query)) {
-			this.vars = {};
-			this.cacheIfFn = () => true;
-		} else if (SITE_ID_VAR_TEST.test(this.query)) {
-			this.vars = { siteId: vars.siteId().z_setName('siteId') };
-			this.cacheIfFn = () => true;
-		}
-	}
-
-	/**
-	 * Returns the validated variables if some vars where defined
-	 * else just returns all vars
-	 */
-	validateVars(vars: any, cs: ServerRouter): Record<string, any> {
-		if (!vars || typeof vars !== 'object')
-			throw new Error('expected an object as vars');
-
-		if (!this.vars) return vars;
-
-		const nVars: Record<string, any> = {};
-
-		for (const [k, v] of Object.entries(this.vars)) {
-			nVars[k] = v.validValue(vars[k], cs);
-		}
-
-		return nVars;
-	}
-
-	private async transform(
-		jsonResp: Record<string, any>,
-		vars: Record<string, any>,
-	): Promise<void> {
-		if (!this.transformFn || !jsonResp.data) return;
-
-		const transformed = await this.transformFn(jsonResp.data, vars);
-		if (typeof transformed !== 'undefined') jsonResp.data = transformed;
+export type HandleFn = (
+	csr: CrelteServerRequest,
+	vars: Record<string, any>,
+) => Promise<any> | any;
+
+/**
+ * Returns the validated variables if some vars where defined
+ * else just returns all vars
+ */
+export function validateVars(
+	qvars: Record<string, QueryVar> | null,
+	vars: any,
+	cs: ServerRouter,
+): Record<string, any> {
+	if (!vars || typeof vars !== 'object')
+		throw new Error('expected an object as vars');
+
+	if (!qvars) return vars;
+
+	const nVars: Record<string, any> = {};
+
+	for (const [k, v] of Object.entries(qvars)) {
+		nVars[k] = v.validValue(vars[k], cs);
 	}
 
-	async handle(
-		caching: QueriesCaching,
-		csr: CrelteServerRequest,
-	): Promise<Response> {
-		let vars;
-		try {
-			const reqVars = await csr.req.json();
-			vars = this.validateVars(reqVars, caching.router);
-			if ('qName' in vars || 'xCraftSite' in vars)
-				throw new Error(
-					'qName and xCraftSite are reserved variable names',
-				);
-		} catch (e) {
-			return newError(e, 400);
-		}
-
-		let logInfo: string | null = null;
-		if (caching.debug) {
-			logInfo = `[queries: ${this.name}] vars: ${JSON.stringify(vars)}`;
-		}
-
-		let previewToken: string | null = null;
-		let siteToken: string | null = null;
-
-		const reqSearch = new URL(csr.req.url).searchParams;
-
-		if (reqSearch.has('token')) {
-			previewToken = reqSearch.get('token');
-		} else if (reqSearch.has('siteToken')) {
-			siteToken = reqSearch.get('siteToken');
-		}
-
-		// check for x-craft-site header and pass it on
-		const xCraftSite = csr.req.headers.get('X-Craft-Site');
-
-		let cacheKey: string | null = null;
-		const useCache = !previewToken && caching.isEnabled();
-		if (useCache) {
-			cacheKey = await calcKey({ ...vars, qName: this.name, xCraftSite });
-			const cached = await caching.getCache(cacheKey);
-
-			if (logInfo) console.log(`${logInfo} ${cached ? 'hit' : 'miss'}`);
-
-			// we found something in the cache
-			if (cached) return Response.json(cached);
-		}
-
-		const headers: Record<string, string> = {
-			'Content-Type': 'application/json',
-		};
-
-		const auth = csr.getEnv('ENDPOINT_TOKEN');
-		if (auth) headers['Authorization'] = 'Bearer ' + auth;
-
-		const url = new URL(csr.getEnv('ENDPOINT_URL'));
-		if (previewToken) url.searchParams.set('token', previewToken);
-		if (siteToken) url.searchParams.set('siteToken', siteToken);
-
-		const xDebug = csr.req.headers.get('X-Debug');
-		if (xDebug) headers['X-Debug'] = xDebug;
-
-		if (xCraftSite) headers['X-Craft-Site'] = xCraftSite;
-
-		// now execute the gql request
-		let resp: Response;
-		try {
-			resp = await fetch(url, {
-				method: 'POST',
-				headers,
-				body: JSON.stringify({
-					query: this.query,
-					variables: vars,
-				}),
-			});
-
-			// if the response is not ok we don't cache anything
-			// and just return the response
-			if (!resp.ok) return resp;
-		} catch (e) {
-			return newError(e, 500);
-		}
-
-		const respHeaders: Record<string, string> = {};
-		const xDebugLink = resp.headers.get('X-Debug-Link');
-		if (xDebugLink) respHeaders['X-Debug'] = xDebugLink;
-
-		let jsonResp: Record<string, any>;
-		try {
-			jsonResp = await resp.json();
-			if (!jsonResp || typeof jsonResp !== 'object')
-				throw new Error('invalid json response');
-			await this.transform(jsonResp, vars);
-		} catch (e) {
-			return newError(e, 500);
-		}
-
-		// also no caching for errors
-		if (jsonResp.errors) {
-			return Response.json(jsonResp, { headers: respHeaders });
-		}
-
-		// now we have a valid json resp.
-		// should we cache it?
-		if (cacheKey && this.cacheIfFn?.(jsonResp.data, vars)) {
-			try {
-				await caching.setCache(cacheKey, jsonResp);
-				if (logInfo) console.log(logInfo + ' set cache');
-			} catch (e) {
-				console.error('could not cache gql response', e);
-			}
-			// if caching is generally disabled we don't warn
-		} else if (cacheKey && logInfo) {
-			console.warn('!! ' + logInfo + ' caching not allowed');
-		}
-
-		return Response.json(jsonResp, { headers: respHeaders });
-	}
+	return nVars;
 }
 
 export function newError(e: any, status: number): Response {