crelte 0.5.13 → 0.5.14

package/dist/std/url/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/std/url/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AAEnD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,kCAM1E;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,SAAS,GAAG,GAAG,GAAG,MAAM,GAAG,GAAG,CAMxD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,GAAG,OAAO,CAWxE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAGxD"}

package/dist/std/url/utils.js

@@ -0,0 +1,40 @@
+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) {
+    return (typeof value === 'undefined' ||
+        value === null ||
+        (typeof value === 'string' && value === ''));
+}
+/**
+ * Converts a `BaseRoute`, `URL`, or string to a `URL` object.
+ */
+export function toUrl(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, b) {
+    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, b) {
+    // check for trailing slashes
+    return a === b || a === b + '/' || a + '/' === b;
+}

package/dist/vite/index.js

@@ -126,7 +126,7 @@ export default function crelte(opts) {
                 publicDir: isSsrBuild ? false : 'public',
                 base: '/',
                 server: {
-                    port: 8080,
+                    port: config.server?.port ?? 8080,
                 },
                 optimizeDeps: {
                     exclude: ['crelte'],
@@ -256,7 +256,8 @@ export default function crelte(opts) {
 async function serveVite(env, vite) {
     let sites = null;
     const handle = async (nReq, res) => {
-        const protocol = vite.config.server.https ? 'https' : 'http';
+        const protocol = nReq.headers['x-forwarded-proto'] ??
+            (vite.config.server.https ? 'https' : 'http');
         const baseUrl = protocol + '://' + nReq.headers['host'];
         const req = requestToWebRequest(baseUrl, nReq);
         const serverMod = await vite.ssrLoadModule('./src/server.js');

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "crelte",
-	"version": "0.5.13",
+	"version": "0.5.14",
 	"author": "Crelte <support@crelte.com>",
 	"type": "module",
 	"scripts": {
@@ -107,6 +107,10 @@
 		"./std/rand": {
 			"types": "./dist/std/rand/index.d.ts",
 			"default": "./dist/std/rand/index.js"
+		},
+		"./std/url": {
+			"types": "./dist/std/url/index.d.ts",
+			"default": "./dist/std/url/index.js"
 		}
 	},
 	"dependencies": {

package/src/queries/Queries.ts

@@ -42,6 +42,9 @@ export type NamedQuery = { queryName: string };
  * Create a NamedQuery for the given server query name.
  *
  * Prefer importing a graphql file instead.
+ *
+ * #### Note
+ * This needs to match the name of the js/ts file.
  */
 export function namedQuery(name: string): NamedQuery {
 	return { queryName: name };

package/src/queries/index.ts

@@ -8,6 +8,7 @@ import Queries, {
 	QueryOptions,
 } from '../queries/Queries.js';
 import type CrelteServerRequest from '../server/CrelteServer.js';
+import ServerRouter from '../server/ServerRouter.js';
 import { gql } from './gql.js';
 import QueryError, { QueryErrorResponse } from './QueryError.js';
 import { QueryVar, ValidIf, vars, varsIdsEqual } from './vars.js';
@@ -38,6 +39,30 @@ export type InferVariableTypes<T> = {
 	[K in keyof T]: InferQueryVarType<T[K]>;
 };
 
+/**
+ * Defines wether the query variables are valid.
+ *
+ * Either throw or return a boolean.
+ *
+ * #### Example
+ * ```ts
+ * import { vars, ValidVars } from 'crelte/queries';
+ *
+ * export const variables = {
+ *     siteId: vars.siteId(),
+ *     category: vars.id()
+ * };
+ *
+ * export const validVars: ValidVars<typeof variables> = (vars, sr) => {
+ *     if (!vars.category === 5) throw new Error('category needs to be 5');
+ * };
+ * ```
+ */
+export type ValidVars<T extends Record<string, QueryVar<any>>> = (
+	vars: InferVariableTypes<T>,
+	sr: ServerRouter,
+) => void | boolean;
+
 /**
  * Defines when a query can safely be cached.
  *

package/src/queries/vars.ts

@@ -1,10 +1,32 @@
 import ServerRouter from '../server/ServerRouter.js';
 
 export const vars = {
+	/**
+	 * Any is not validated except for nullability
+	 */
 	any: (): QueryVar<any> => new QueryVar(),
+
+	/**
+	 * Number is a number, but will also parse strings to numbers
+	 */
 	number: (): QueryVar<number> => new QueryVar().number(),
+
+	/**
+	 * String is a string, but will not parse numbers to strings
+	 */
 	string: (): QueryVar<string> => new QueryVar().string(),
 
+	/**
+	 * Strings is an array of strings, but will also convert a single string to
+	 * an array with one element
+	 *
+	 * #### Note
+	 * The returned array will **never be empty**, but might be null if allowed.
+	 * It is not deduped or sorted.
+	 * If you have ids you should use `vars.ids()` instead.
+	 */
+	strings: (): QueryVar<string[]> => new QueryVar().strings(),
+
 	/**
 	 * Id is almost the same as number but will also parse
 	 * strings, but only allow non negative integers
@@ -37,6 +59,9 @@ export const vars = {
 	 */
 	ids: (): QueryVar<number[]> => new QueryVar().ids(),
 
+	/**
+	 * Checks for a valid site id which exists
+	 */
 	siteId: (): QueryVar<number> =>
 		new QueryVar()
 			.number()
@@ -47,11 +72,11 @@ export const vars = {
 
 /// either throw with an error which will get returned in a 400 response or
 // return false if the value is not valid
-export type ValidIf<T> = (v: T, cs: ServerRouter) => boolean;
+export type ValidIf<T> = (v: T, sr: ServerRouter) => boolean;
 
 export class QueryVar<T = any> {
 	private name: string | null;
-	private type: 'any' | 'string' | 'number' | 'id' | 'ids';
+	private type: 'any' | 'string' | 'strings' | 'number' | 'id' | 'ids';
 	private flagNullable: boolean;
 	private defaultValue: T | undefined;
 	private validIfFn: ValidIf<T>;
@@ -69,6 +94,11 @@ export class QueryVar<T = any> {
 		return this as unknown as QueryVar<string>;
 	}
 
+	strings(): QueryVar<string[]> {
+		this.type = 'strings';
+		return this as unknown as QueryVar<string[]>;
+	}
+
 	number(): QueryVar<number> {
 		this.type = 'number';
 		return this as unknown as QueryVar<number>;
@@ -98,7 +128,7 @@ export class QueryVar<T = any> {
 	 * Set a validation function for this variable
 	 *
 	 * If the value is allowed to be null and it is null
-	 * valid will not be called.
+	 * the passed function will not be called.
 	 */
 	validIf(fn: ValidIf<T>): QueryVar<T> {
 		this.validIfFn = fn;
@@ -127,6 +157,31 @@ export class QueryVar<T = any> {
 					throw new Error(`variable ${this.name} is not a string`);
 				break;
 
+			case 'strings':
+				if (typeof v === 'string') v = [v];
+
+				if (!Array.isArray(v))
+					throw new Error(
+						`variable ${this.name} is not a string or a list of strings`,
+					);
+
+				if (v.length <= 0) {
+					if (this.defaultValue !== undefined)
+						return this.defaultValue;
+
+					if (this.flagNullable) return null;
+
+					throw new Error(
+						`variable ${this.name} is not allowed to be empty`,
+					);
+				}
+
+				if (!v.every(s => typeof s === 'string'))
+					throw new Error(
+						`variable ${this.name} is not a list of strings`,
+					);
+				break;
+
 			case 'number':
 				if (typeof v !== 'number')
 					throw new Error(`variable ${this.name} is not a number`);

package/src/routing/route/BaseRoute.ts

@@ -1,3 +1,8 @@
+import {
+	deleteSearchParam,
+	pathnameEq,
+	searchEq,
+} from '../../std/url/utils.js';
 import { objClone } from '../../utils.js';
 import Site from '../Site.js';
 import { trimSlashEnd } from '../utils.js';
@@ -238,12 +243,7 @@ export default class BaseRoute {
 	 * ```
 	 */
 	setSearchParam(key: string, value?: string | number | null) {
-		const deleteValue =
-			typeof value === 'undefined' ||
-			value === null ||
-			(typeof value === 'string' && value === '');
-
-		if (!deleteValue) {
+		if (!deleteSearchParam(value)) {
 			this.search.set(key, value as string);
 		} else {
 			this.search.delete(key);
@@ -344,8 +344,8 @@ export default class BaseRoute {
 	eqUrl(route: BaseRoute | null) {
 		return (
 			route &&
-			this.url.pathname === route.url.pathname &&
-			this.url.origin === route.url.origin
+			this.url.origin === route.url.origin &&
+			pathnameEq(this.url.pathname, route.url.pathname)
 		);
 	}
 
@@ -353,20 +353,6 @@ export default class BaseRoute {
 	 * Checks if the search params are equal to another route
 	 */
 	eqSearch(route: BaseRoute | null) {
-		const searchEq = (a: URLSearchParams, b: URLSearchParams) => {
-			if (a.size !== b.size) return false;
-
-			a.sort();
-			b.sort();
-
-			const aEntries = Array.from(a.entries());
-			const bEntries = Array.from(b.entries());
-
-			return aEntries
-				.map((a, i) => [a, bEntries[i]])
-				.every(([[ak, av], [bk, bv]]) => ak === bk && av === bv);
-		};
-
 		return route && searchEq(this.search, route.search);
 	}
 

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;
 
@@ -112,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',

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
@@ -20,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');
@@ -36,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);