crelte 0.5.8 → 0.5.10

package/src/node/index.ts

@@ -5,6 +5,7 @@ import { createReadStream } from 'node:fs';
 import {
 	EnvData,
 	initEnvData,
+	initSites,
 	modRender,
 	modRenderError,
 } from '../server/shared.js';
@@ -18,6 +19,8 @@ import {
 	webResponseToResponse,
 	writeFile,
 } from './utils.js';
+import { timeout } from '../std/index.js';
+import { SiteFromGraphQl } from '../routing/Site.js';
 
 function localDir(...args: string[]) {
 	return join(path.dirname(fileURLToPath(import.meta.url)), ...args);
@@ -31,23 +34,21 @@ async function writeSitesCache(data: any): Promise<void> {
 	return await writeFile(localDir('sites.json'), JSON.stringify(data));
 }
 
-export default async function createServer(serverMod: any, buildTime: string) {
-	const env = await initEnvData(PLATFORM, {
+async function initRouter(
+	serverMod: any,
+	env: EnvData,
+): Promise<[SiteFromGraphQl[], ServerRouter]> {
+	const sites = await initSites(env, {
 		enabled: process.env.NODE_ENV === 'production',
 		writeSitesCache,
 		readSitesCache,
 	});
-	const template = await readFile(localDir('index.html'));
-	const globalEtag = '"' + buildTime + '"';
-	const ssrManifest = JSON.parse(
-		await readFile(localDir('ssr-manifest.json')),
-	);
 
 	const router = new ServerRouter(
 		env.endpointUrl,
 		env.frontendUrl,
 		env.env,
-		env.sites,
+		sites,
 		{
 			endpointToken: env.endpointToken,
 		},
@@ -59,62 +60,122 @@ export default async function createServer(serverMod: any, buildTime: string) {
 		await serverMod.routes(router);
 	}
 
+	return [sites, router];
+}
+
+/**
+ * Create and start the server
+ *
+ * Generally this call should automatically happen via the vite build step.
+ */
+export default async function createServer(serverMod: any, buildTime: string) {
+	const env = await initEnvData(PLATFORM);
+	const template = await readFile(localDir('index.html'));
+	const globalEtag = '"' + buildTime + '"';
+	const ssrManifest = JSON.parse(
+		await readFile(localDir('ssr-manifest.json')),
+	);
+
+	let sites: SiteFromGraphQl[] | null = null;
+	let router: ServerRouter | null = null;
+	let routesError: any = null;
+
+	// let's try to init the router
+	// if it fails we start a retry loop
+	// this way the server can start even if the endpoint is not yet available
+	try {
+		[sites, router] = await initRouter(serverMod, env);
+	} catch (e) {
+		routesError = e;
+		console.error('Failed to setup router:', e);
+
+		// retry loop
+		(async () => {
+			while (!router) {
+				await timeout(1000);
+
+				try {
+					[sites, router] = await initRouter(serverMod, env);
+					routesError = null;
+				} catch (e) {
+					routesError = e;
+					console.error('Failed to setup router:', e);
+				}
+			}
+		})();
+	}
+
 	const publicDir = localDir('public');
 
-	http.createServer(async (nReq, res) => {
-		if (await servePublic(nReq, res, publicDir, globalEtag)) return;
+	const handle = async (req: Request, res: ServerResponse) => {
+		// if router is not set, just render the error page
+		if (routesError || !router || !sites) {
+			throw routesError ?? new Error('Router not initialized');
+		}
 
-		// todo this is not safe if we are not in a trusted environment
-		const baseUrl =
-			(nReq.headers['x-forwarded-proto'] ?? 'http') +
-			'://' +
-			nReq.headers['host'];
+		const routeResp = await router.z_handle(req);
+		if (routeResp) {
+			await webResponseToResponse(routeResp, res);
+			return;
+		}
 
-		const req = requestToWebRequest(baseUrl, nReq);
+		if (await basicAuthCheck(req, res, env)) return;
 
-		let thrownError: any = null;
+		const response = await modRender(env, sites, serverMod, template, req, {
+			ssrManifest,
+		});
+		await webResponseToResponse(response, res);
+	};
 
+	http.createServer(async (nodeReq, res) => {
+		let req: Request | null = null;
+		let err: any;
 		try {
-			const routeResp = await router.z_handle(req);
-			if (routeResp) {
-				await webResponseToResponse(routeResp, res);
-				return;
-			}
+			if (await servePublic(nodeReq, res, publicDir, globalEtag)) return;
 
-			if (await basicAuthCheck(nReq, res, env)) return;
+			// todo this is not safe if we are not in a trusted environment
+			const baseUrl =
+				(nodeReq.headers['x-forwarded-proto'] ?? 'http') +
+				'://' +
+				nodeReq.headers['host'];
+
+			req = requestToWebRequest(baseUrl, nodeReq);
+
+			await handle(req, res);
 
-			const response = await modRender(env, serverMod, template, req, {
-				ssrManifest,
-			});
-			await webResponseToResponse(response, res);
 			return;
-		} catch (e: any) {
-			if (typeof serverMod.renderError !== 'function') {
-				console.log('error', e);
-				throw e;
-			}
+		} catch (e) {
+			err = e;
+		}
 
-			thrownError = e;
+		if (typeof serverMod.renderError !== 'function' || !req) {
+			basicError(res, err);
+			return;
 		}
 
 		try {
 			const response = await modRenderError(
 				env,
 				serverMod,
-				thrownError,
+				err,
 				template,
 				req,
 				{ ssrManifest },
 			);
 			await webResponseToResponse(response, res);
-			return;
 		} catch (e) {
-			console.log('error', e);
-			throw e;
+			basicError(res, e);
 		}
 	}).listen(8080);
 }
 
+function basicError(res: ServerResponse, err: any) {
+	console.error('Internal Server Error:', err);
+	res.statusCode = 500;
+	res.end('Internal Server Error: ' + err?.message);
+	return;
+}
+
 const MIME_TYPES: Record<string, string> = {
 	'.html': 'text/html',
 	'.css': 'text/css',
@@ -203,7 +264,7 @@ async function servePublic(
  * for staging or unlisted instances.
  */
 async function basicAuthCheck(
-	req: IncomingMessage,
+	req: Request,
 	res: ServerResponse,
 	{ env }: EnvData,
 ): Promise<boolean> {
@@ -213,7 +274,7 @@ async function basicAuthCheck(
 	// ignore if one information is missing
 	if (!user || !password) return false;
 
-	const authHeader = req.headers['authorization'];
+	const authHeader = req.headers.get('authorization');
 
 	if (!authHeader || !authHeader.startsWith('Basic ')) {
 		res.statusCode = 401;

package/src/plugins/Events.ts

@@ -12,23 +12,23 @@ export default class Events {
 	/**
 	 * Listens for an event.
 	 *
-	 * ## beforeRequest
+	 * #### beforeRequest
 	 * Please prefer to return not return a promise only if you need to wait
 	 * for something. This allows a push request to be done without a microtask.
 	 * Allowing for a better DX.
 	 *
-	 * ## loadEntry
+	 * #### loadEntry
 	 * This will execute all listeners in sequence and stop on the first one
 	 * which returns an entry.
 	 * Will be executed in preload as well.
 	 *
-	 * ## beforeQueryEntry
+	 * #### beforeQueryEntry
 	 * This allows to modify the entry query variables before the entry query
 	 * is executed.
 	 * Will be executed in preload as well.
 	 *
 	 *
-	 * ## afterLoadEntry
+	 * #### afterLoadEntry
 	 * Will be executed in preload as well.
 	 *
 	 * @returns a function to remove the listener

package/src/plugins/Plugins.ts

@@ -15,8 +15,8 @@ export interface Plugin {
  * a configurePluginname function which will be called by youre user and should
  * return a createPlugin function.
  *
- * ## Example App.svelte in module="context"
- * ```
+ * #### Example App.svelte in module="context"
+ * ```js
  * import { createPlugin, configurePlugin } from 'some-plugin';
  *
  * export plugins = [createPlugin, configurePlugin({ enableFeature: true })];

package/src/plugins/index.ts

@@ -1,5 +1,4 @@
 import Events from './Events.js';
-import { Plugin, PluginCreator } from './Plugins.js';
+import Plugins, { type Plugin, type PluginCreator } from './Plugins.js';
 
-export type { Plugin, PluginCreator };
-export { Events };
+export { Plugins, Events, Plugin, PluginCreator };

package/src/queries/Queries.ts

@@ -91,12 +91,21 @@ export default class Queries {
 		this.request = request;
 	}
 
+	/**
+	 * Create a new Queries instance
+	 *
+	 * @param endpoint the craft GraphQl endpoint
+	 * @param frontend the frontend url where the server queries are reachable
+	 * @param ssrCache the ssrCache to use for caching
+	 * @param opts options
+	 * @returns
+	 */
 	static new(
 		endpoint: string,
 		frontend: string,
 		ssrCache: SsrCache,
 		opts: QueriesOptions = {},
-	) {
+	): Queries {
 		return new Queries(
 			new Inner(endpoint, frontend, ssrCache, opts),
 			opts?.route ?? null,
@@ -131,6 +140,8 @@ export default class Queries {
 		// for convenience we set the siteId as variable if it is known
 		if (siteId !== null) vars = { siteId, ...vars };
 
+		// todo, maybe we should set the XCraftSiteId, with the siteId from vars?
+
 		return this.inner.query(query, vars, {
 			previewToken,
 			siteToken,
@@ -217,16 +228,15 @@ class Inner {
 
 		try {
 			const resp = await this.queryNotCached(query, vars, opts);
+
 			if (key) {
 				// todo maybe we should objClone here?
 				this.ssrCache.set(key, resp);
 
-				// ! because the listeners get's in the previous if statement and will
-				// always be set when the key is set
+				// ! (never null) because the listeners get's in the previous
+				// if statement and will always be set when the key is set
 				const listeners = this.listeners.get(key)!;
-				listeners.forEach(([resolve, _error]) => {
-					resolve(resp);
-				});
+				listeners.forEach(([resolve, _error]) => resolve(resp));
 
 				this.listeners.delete(key);
 			}
@@ -234,12 +244,10 @@ class Inner {
 			return resp;
 		} catch (e: unknown) {
 			if (key) {
-				// ! because the listeners get's in the previous if statement and will
-				// always be set when the key is set
+				// ! (never null) because the listeners get's in the previous
+				// if statement and will always be set when the key is set
 				const listeners = this.listeners.get(key)!;
-				listeners.forEach(([_resolve, error]) => {
-					error(e);
-				});
+				listeners.forEach(([_resolve, error]) => error(e));
 
 				this.listeners.delete(key);
 			}
@@ -291,11 +299,17 @@ class Inner {
 			body = { query: query.query, variables: vars };
 		}
 
-		const resp = await fetch(url, {
-			method: 'POST',
-			headers,
-			body: JSON.stringify(body),
-		});
+		let resp: Response;
+
+		try {
+			resp = await fetch(url, {
+				method: 'POST',
+				headers,
+				body: JSON.stringify(body),
+			});
+		} catch (e: any) {
+			throw new Error(`query to '${url}' failed with: ${e.message}`);
+		}
 
 		if (!resp.ok) {
 			throw new QueryError(
@@ -322,8 +336,11 @@ class Inner {
 		}
 
 		if ('errors' in jsonResp) {
-			console.log(logName + ' errors', jsonResp.errors);
-			throw new QueryError({ status: resp.status }, jsonResp.errors);
+			console.error(logName + ' errors', jsonResp.errors);
+			throw new QueryError(
+				{ status: resp.status, errors: jsonResp.errors },
+				'received errors',
+			);
 		}
 
 		return jsonResp.data ?? null;

package/src/queries/QueryError.ts

@@ -1,6 +1,7 @@
 export type QueryErrorResponse = {
 	status?: number;
 	body?: string;
+	errors?: any[];
 };
 
 // todo improve this
@@ -32,6 +33,14 @@ export default class QueryError extends Error {
 	 * The error message in string form
 	 */
 	get message(): string {
-		return 'QueryError: ' + JSON.stringify(this.resp);
+		return 'QueryError: ' + JSON.stringify(this.resp, null, '  ');
 	}
 }
+
+export function isQueryError(err: any): err is QueryError {
+	return (
+		typeof err === 'object' &&
+		err !== null &&
+		typeof err.__QueryError__ === 'function'
+	);
+}

package/src/queries/gql.ts

@@ -5,8 +5,8 @@ import { isQuery, Query } from './Queries.js';
  * @param strings
  * @param keys
  *
- * ## Example
- * ```
+ * #### Example
+ * ```js
  * const query = gql`query ($id: ID!) { page(id: $id) { id } }`;
  * ```
  */

package/src/queries/index.ts

@@ -5,7 +5,7 @@ import Queries, {
 	QueryOptions,
 } from '../queries/Queries.js';
 import { gql } from './gql.js';
-import QueryError from './QueryError.js';
+import QueryError, { QueryErrorResponse } from './QueryError.js';
 import { QueryVar, ValidIf, vars, varsIdsEqual } from './vars.js';
 
 export {
@@ -15,6 +15,7 @@ export {
 	type Query,
 	isQuery,
 	QueryError,
+	type QueryErrorResponse,
 	gql,
 	vars,
 	type ValidIf,
@@ -22,14 +23,16 @@ export {
 	varsIdsEqual,
 };
 
-type InferQueryVarType<T> = T extends QueryVar<infer U> ? U : never;
+/** @hidden */
+export type InferQueryVarType<T> = T extends QueryVar<infer U> ? U : never;
 
-type InferVariableTypes<T> = {
+/** @hidden */
+export type InferVariableTypes<T> = {
 	[K in keyof T]: InferQueryVarType<T[K]>;
 };
 
 /**
- * ## Example
+ * #### Example
  * ```ts
  * import { vars, Caching } from 'crelte/queries';
  *

package/src/queries/vars.ts

@@ -9,7 +9,7 @@ export const vars = {
 	 * Id is almost the same as number but will also parse
 	 * strings, but only allow non negative integers
 	 *
-	 * ## Warning
+	 * #### Warning
 	 * Ids are not automatically safe to be cached
 	 * you need to validate the response to make sure filters
 	 * with this id returned something
@@ -24,7 +24,7 @@ export const vars = {
 	 *
 	 * The numbers are always unique and sorted in ascending order
 	 *
-	 * ## Warning
+	 * #### Warning
 	 * Ids are not automatically safe to be cached, it is also not
 	 * enough to just check if the filter returned some results.
 	 * Since for example a `relatedTo` filter works like an `or` and
@@ -180,7 +180,11 @@ export class QueryVar<T = any> {
 }
 
 export function isQueryVar(v: any): v is QueryVar {
-	return v && typeof v === 'object' && typeof v.__QueryVar__ === 'function';
+	return (
+		typeof v === 'object' &&
+		v !== null &&
+		typeof v.__QueryVar__ === 'function'
+	);
 }
 
 // does not do string to number conversion
@@ -194,8 +198,8 @@ function isValidId(id: any): id is number {
  * The first argument needs to come from a `vars.ids()` variable.
  * The second argument should come from a query, where the output is trusted.
  *
- * ## Example
- * ```
+ * #### Example
+ * ```js
  * export const variables = {
  *     categories: vars.ids()
  * };
@@ -206,15 +210,15 @@ function isValidId(id: any): id is number {
  * };
  * ```
  *
- * ## Note
+ * #### Note
  * The following cases are considered equal:
- * ```
+ * ```js
  * varsIdsEqual(null, null);
  * varsIdsEqual([], null);
  * varsIdsEqual([1,2], ['2',1]);
  * ```
  * These are not equal:
- * ```
+ * ```js
  * varsIdsEqual([1], null);
  * varsIdsEqual([2,1], [2,1]); // because the second arg gets ordered
  * ```

package/src/routing/LoadRunner.ts

@@ -52,7 +52,7 @@ export default class LoadRunner {
 	/**
 	 * @returns true if the load was completed
 	 *
-	 * ## Throws
+	 * #### Throws
 	 * if there was an error but not if the request
 	 * was cancelled before
 	 */

package/src/routing/index.ts

@@ -1,22 +1,32 @@
 import Router, { type UpdateRequest } from './router/Router.js';
-import Route, { type RouteOptions } from './route/Route.js';
+import Route, {
+	type TemplateModule,
+	type RouteOptions,
+} from './route/Route.js';
 import Request, {
 	type RequestOptions,
 	type DelayRender,
 } from './route/Request.js';
-import Site from './Site.js';
-import BaseRoute from './route/BaseRoute.js';
+import Site, { type SiteFromGraphQl } from './Site.js';
+import BaseRoute, {
+	type BaseRouteOptions,
+	type RouteOrigin,
+} from './route/BaseRoute.js';
 import { shouldInterceptClick } from './utils.js';
 
 export {
 	Router,
 	UpdateRequest,
 	BaseRoute,
+	BaseRouteOptions,
 	Route,
 	RouteOptions,
+	TemplateModule,
 	Site,
+	SiteFromGraphQl,
 	Request,
 	DelayRender,
 	RequestOptions,
 	shouldInterceptClick,
+	RouteOrigin,
 };