crelte 0.5.12 → 0.5.14

package/src/server/queries/QueryGqlRoute.ts

@@ -3,10 +3,17 @@ import QueriesCaching from './QueriesCaching.js';
 import { QueryVar, vars } from '../../queries/vars.js';
 import { extractEntry } from '../../loadData/index.js';
 import { calcKey } from '../../ssr/index.js';
-import { CacheIfFn, newError, TransformFn, validateVars } from './routes.js';
+import {
+	CacheIfFn,
+	newError,
+	TransformFn,
+	validateVars,
+	ValidIfFn,
+} from './routes.js';
 
 export type QueryGqlArgs = {
 	vars: Record<string, QueryVar> | null;
+	validIfFn: ValidIfFn | null;
 	cacheIfFn: CacheIfFn | null;
 	preventCaching: boolean;
 	transformFn: TransformFn | null;
@@ -17,6 +24,7 @@ export default class QueryGqlRoute {
 	name: string;
 	query: string;
 	vars: Record<string, QueryVar> | null;
+	validIfFn: ValidIfFn | null;
 	cacheIfFn: CacheIfFn | null;
 	transformFn: TransformFn | null;
 
@@ -32,6 +40,7 @@ export default class QueryGqlRoute {
 		this.name = name;
 		this.query = query;
 		this.vars = args.vars;
+		this.validIfFn = args.validIfFn;
 		this.cacheIfFn = args.cacheIfFn;
 		this.transformFn = args.transformFn;
 
@@ -97,10 +106,11 @@ export default class QueryGqlRoute {
 	private async transform(
 		jsonResp: Record<string, any>,
 		vars: Record<string, any>,
+		csr: CrelteServerRequest,
 	): Promise<void> {
 		if (!this.transformFn || !jsonResp.data) return;
 
-		const transformed = await this.transformFn(jsonResp.data, vars);
+		const transformed = await this.transformFn(jsonResp.data, vars, csr);
 		if (typeof transformed !== 'undefined') jsonResp.data = transformed;
 	}
 
@@ -111,7 +121,13 @@ export default class QueryGqlRoute {
 		let vars: Record<string, any>;
 		try {
 			const reqVars = await csr.req.json();
-			vars = validateVars(this.vars, reqVars, caching.router);
+			vars = validateVars(
+				this.vars,
+				reqVars,
+				this.validIfFn,
+				caching.router,
+			);
+
 			if ('qName' in vars || 'xCraftSite' in vars)
 				throw new Error(
 					'qName and xCraftSite are reserved variable names',
@@ -195,7 +211,7 @@ export default class QueryGqlRoute {
 			jsonResp = await resp.json();
 			if (!jsonResp || typeof jsonResp !== 'object')
 				throw new Error('invalid json response');
-			await this.transform(jsonResp, vars);
+			await this.transform(jsonResp, vars, csr);
 		} catch (e) {
 			return newError(e, 500);
 		}

package/src/server/queries/QueryHandleRoute.ts

@@ -1,20 +1,23 @@
 import { QueryVar } from '../../queries/vars.js';
 import CrelteServerRequest from '../CrelteServer.js';
 import ServerRouter from '../ServerRouter.js';
-import { HandleFn, newError, validateVars } from './routes.js';
+import { HandleFn, newError, validateVars, ValidIfFn } from './routes.js';
 
 // only internal
 export default class QueryHandleRoute {
 	name: string;
+	validIfFn: ValidIfFn | null;
 	handleFn: HandleFn;
 	vars: Record<string, QueryVar> | null;
 
 	constructor(
 		name: string,
+		validIfFn: ValidIfFn | null,
 		handleFn: HandleFn,
 		vars: Record<string, QueryVar> | null,
 	) {
 		this.name = name;
+		this.validIfFn = validIfFn;
 		this.handleFn = handleFn;
 		this.vars = vars;
 	}
@@ -26,7 +29,7 @@ export default class QueryHandleRoute {
 		let vars: Record<string, any>;
 		try {
 			const reqVars = await csr.req.json();
-			vars = validateVars(this.vars, reqVars, cs);
+			vars = validateVars(this.vars, reqVars, this.validIfFn, cs);
 		} catch (e) {
 			return newError(e, 400);
 		}

package/src/server/queries/queries.ts

@@ -1,6 +1,6 @@
 import ServerRouter from '../ServerRouter.js';
 import QueriesCaching from './QueriesCaching.js';
-import { CacheIfFn, HandleFn, TransformFn } from './routes.js';
+import { CacheIfFn, HandleFn, TransformFn, ValidIfFn } from './routes.js';
 import { isQueryVar, QueryVar } from '../../queries/vars.js';
 import { Platform } from '../platform.js';
 import QueryHandleRoute from './QueryHandleRoute.js';
@@ -13,6 +13,11 @@ type ModQuery = {
 
 type ModTs = {
 	variables?: any;
+	// only to hint that its validVars
+	validVariables?: any;
+	// only to hint that its validVars
+	validIf?: any;
+	validVars?: any;
 	caching?: any;
 	transform?: any;
 	handle?: any;
@@ -24,6 +29,7 @@ type RouteBuilder = {
 	query: string | null;
 	jsFile: string | null;
 	vars: Record<string, QueryVar> | null;
+	validIfFn: ValidIfFn | null;
 	/** corresponds to the caching export */
 	cacheIfFn: CacheIfFn | null;
 	preventCaching: boolean;
@@ -59,6 +65,7 @@ export async function initQueryRoutes(
 				query: null,
 				jsFile: null,
 				vars: null,
+				validIfFn: null,
 				cacheIfFn: null,
 				preventCaching: false,
 				transformFn: null,
@@ -87,6 +94,17 @@ export async function initQueryRoutes(
 			routeBuilder.vars = parseVars(mts.variables);
 		}
 
+		if (mts.validVariables || mts.validIf) {
+			throw new Error(`use the function validVars in ${filename}`);
+		}
+
+		if (mts.validVars) {
+			if (typeof mts.validVars !== 'function') {
+				throw new Error('validVars should be a function');
+			}
+			routeBuilder.validIfFn = mts.validVars;
+		}
+
 		if (mts.caching) {
 			routeBuilder.cacheIfFn = parseCaching(mts.caching);
 		} else if (typeof mts.caching === 'boolean') {
@@ -108,7 +126,10 @@ export async function initQueryRoutes(
 
 	for (const [name, rb] of routeBuilders.entries()) {
 		if (rb.query) {
-			if (rb.handleFn) throw new Error('handle function not supported');
+			if (rb.handleFn)
+				throw new Error(
+					'cannot have a handle function if a query is present',
+				);
 
 			const route = new QueryGqlRoute(name, rb.query, rb);
 
@@ -119,7 +140,12 @@ export async function initQueryRoutes(
 			if (rb.cacheIfFn || rb.transformFn || rb.preventCaching)
 				throw new Error('caching or transform not supported');
 
-			const route = new QueryHandleRoute(name, rb.handleFn, rb.vars);
+			const route = new QueryHandleRoute(
+				name,
+				rb.validIfFn,
+				rb.handleFn,
+				rb.vars,
+			);
 
 			router.post('/queries/' + route.name, csr =>
 				route.handle(caching.router, csr),

package/src/server/queries/routes.ts

@@ -4,6 +4,12 @@ import ServerRouter from '../ServerRouter.js';
 
 export type CacheIfFn = (response: any, vars: Record<string, any>) => boolean;
 
+/// Either throw or return a boolean
+export type ValidIfFn = (
+	vars: Record<string, any>,
+	sr: ServerRouter,
+) => void | boolean;
+
 /// Anything other than returning undefined will replace the response
 //
 // Note that even if you return undefined since the response is by reference
@@ -11,6 +17,7 @@ export type CacheIfFn = (response: any, vars: Record<string, any>) => boolean;
 export type TransformFn = (
 	response: any,
 	vars: Record<string, any>,
+	csr: CrelteServerRequest,
 ) => void | any | Promise<void | any>;
 
 export type HandleFn = (
@@ -19,13 +26,14 @@ export type HandleFn = (
 ) => Promise<any> | any;
 
 /**
- * Returns the validated variables if some vars where defined
+ * Returns the validated variables if some vars were defined
  * else just returns all vars
  */
 export function validateVars(
 	qvars: Record<string, QueryVar> | null,
 	vars: any,
-	cs: ServerRouter,
+	validIfFn: ValidIfFn | null,
+	sr: ServerRouter,
 ): Record<string, any> {
 	if (!vars || typeof vars !== 'object')
 		throw new Error('expected an object as vars');
@@ -35,7 +43,14 @@ export function validateVars(
 	const nVars: Record<string, any> = {};
 
 	for (const [k, v] of Object.entries(qvars)) {
-		nVars[k] = v.validValue(vars[k], cs);
+		nVars[k] = v.validValue(vars[k], sr);
+	}
+
+	if (validIfFn) {
+		// or throw
+		const valid = validIfFn(nVars, sr);
+		if (typeof valid === 'boolean' && !valid)
+			throw new Error('invalid variables for query');
 	}
 
 	return nVars;

package/src/std/index.ts

@@ -10,6 +10,7 @@
  * - {@link std/stores}
  * - {@link std/sync}
  * - {@link std/rand}
+ * - {@link std/url}
  */
 
 /**

package/src/std/url/index.ts

@@ -0,0 +1,78 @@
+import { BaseRoute } from '../../routing/index.js';
+import { deleteSearchParam, pathnameEq, searchEq, toUrl } from './utils.js';
+
+/**
+ * Sets the search params of a URL based on the provided options.
+ *
+ * If a value is `null`, `undefined`, or an empty string, the corresponding
+ * search param will be deleted.
+ *
+ * #### Example
+ * ```js
+ * urlWithSearch(entry.url, { p: 1 });
+ * // or remove a value
+ * urlWithSearch(entry.url, { p: null });
+ * ```
+ */
+export function urlWithSearch(
+	url: BaseRoute | URL | string | null | undefined,
+	opts: Record<string, string | number | null | undefined>,
+): string | null {
+	if (!url) return null;
+
+	url = toUrl(url);
+
+	for (const [k, v] of Object.entries(opts)) {
+		if (!deleteSearchParam(v)) {
+			url.searchParams.set(k, v as string);
+		} else {
+			url.searchParams.delete(k);
+		}
+	}
+
+	return url.href;
+}
+
+/**
+ * Compares two URLs for equality.
+ * Normally search and hash are ignored.
+ *
+ * If either or both url is `null` or `undefined`, the function will return
+ * `false`.
+ *
+ * #### Example
+ * ```svelte
+ * <script>
+ *     import { getRoute } from 'crelte';
+ *
+ *     const route = getRoute();
+ * </script>
+ *
+ * <a href={item.url} class:active={urlEq($route, item.url)}>
+ *     {item.title}
+ * </a>
+ * ```
+ */
+export function urlEq(
+	a: BaseRoute | URL | string | null | undefined,
+	b: BaseRoute | URL | string | null | undefined,
+	opts?: { search?: boolean; hash?: boolean },
+): boolean {
+	if (!a || !b) return false;
+
+	a = toUrl(a);
+	b = toUrl(b);
+
+	// check origin and pathname
+	const baseMatches =
+		a.origin === b.origin && pathnameEq(a.pathname, b.pathname);
+	if (!baseMatches) return false;
+
+	// check search
+	if (opts?.search && !searchEq(a.searchParams, b.searchParams)) return false;
+
+	// check hash
+	if (opts?.hash && a.hash !== b.hash) return false;
+
+	return true;
+}

package/src/std/url/utils.ts

@@ -0,0 +1,48 @@
+import { BaseRoute } from '../../routing/index.js';
+
+/**
+ * Checks if a search param should be removed.
+ * This is the case if the value is `null`, `undefined`, or an empty string.
+ */
+export function deleteSearchParam(value: string | number | null | undefined) {
+	return (
+		typeof value === 'undefined' ||
+		value === null ||
+		(typeof value === 'string' && value === '')
+	);
+}
+
+/**
+ * Converts a `BaseRoute`, `URL`, or string to a `URL` object.
+ */
+export function toUrl(url: BaseRoute | URL | string): URL {
+	if (typeof url === 'string') return new URL(url);
+
+	if (url instanceof BaseRoute) return new URL(url.url);
+
+	return url;
+}
+
+/**
+ * Compares two `URLSearchParams` objects for equality.
+ */
+export function searchEq(a: URLSearchParams, b: URLSearchParams): boolean {
+	if (a.size !== b.size) return false;
+
+	// Clone to avoid mutating the original objects
+	const cloneA = new URLSearchParams(a);
+	const cloneB = new URLSearchParams(b);
+
+	cloneA.sort();
+	cloneB.sort();
+
+	return cloneA.toString() === cloneB.toString();
+}
+
+/**
+ * Compares two pathnames for equality, ignoring trailing slashes.
+ */
+export function pathnameEq(a: string, b: string): boolean {
+	// check for trailing slashes
+	return a === b || a === b + '/' || a + '/' === b;
+}

package/src/vite/index.ts

@@ -180,7 +180,7 @@ export default function crelte(opts?: CrelteOptions): Plugin {
 				publicDir: isSsrBuild ? false : 'public',
 				base: '/',
 				server: {
-					port: 8080,
+					port: config.server?.port ?? 8080,
 				},
 				optimizeDeps: {
 					exclude: ['crelte'],
@@ -338,7 +338,9 @@ async function serveVite(env: EnvData, vite: ViteDevServer) {
 		nReq: Connect.IncomingMessage,
 		res: ServerResponse,
 	) => {
-		const protocol = vite.config.server.https ? 'https' : 'http';
+		const protocol =
+			(nReq.headers['x-forwarded-proto'] as string | undefined) ??
+			(vite.config.server.https ? 'https' : 'http');
 		const baseUrl = protocol + '://' + nReq.headers['host'];
 
 		const req = requestToWebRequest(baseUrl, nReq);