crelte 0.5.14 → 0.6.0-alpha.1

package/src/server/queries/QueriesCaching.ts

@@ -13,7 +13,6 @@ export default class QueriesCaching {
 	private cacheDir: string | null;
 	private validBearerToken: string | null;
 	debug: boolean;
-	router: ServerRouter;
 
 	constructor(
 		platform: Platform,
@@ -21,7 +20,6 @@ export default class QueriesCaching {
 		opts?: QueriesCachingOptions,
 	) {
 		this.platform = platform;
-		this.router = cs;
 		this.debug = !!opts?.debug;
 
 		const enableCaching = cs.getEnv('CACHING') === 'true';

package/src/server/queries/QueryGqlRoute.ts

@@ -10,6 +10,7 @@ import {
 	validateVars,
 	ValidIfFn,
 } from './routes.js';
+import { cryptoSha1Hash } from '../../utils.js';
 
 export type QueryGqlArgs = {
 	vars: Record<string, QueryVar> | null;
@@ -23,6 +24,7 @@ export type QueryGqlArgs = {
 export default class QueryGqlRoute {
 	name: string;
 	query: string;
+	queryHash: string;
 	vars: Record<string, QueryVar> | null;
 	validIfFn: ValidIfFn | null;
 	cacheIfFn: CacheIfFn | null;
@@ -39,6 +41,7 @@ export default class QueryGqlRoute {
 
 		this.name = name;
 		this.query = query;
+		this.queryHash = query;
 		this.vars = args.vars;
 		this.validIfFn = args.validIfFn;
 		this.cacheIfFn = args.cacheIfFn;
@@ -56,6 +59,10 @@ export default class QueryGqlRoute {
 		else this.fillBasicDefaults();
 	}
 
+	async init() {
+		this.queryHash = await cryptoSha1Hash(this.query);
+	}
+
 	private fillEntryDefaults() {
 		if (this.vars) return;
 
@@ -121,16 +128,11 @@ export default class QueryGqlRoute {
 		let vars: Record<string, any>;
 		try {
 			const reqVars = await csr.req.json();
-			vars = validateVars(
-				this.vars,
-				reqVars,
-				this.validIfFn,
-				caching.router,
-			);
+			vars = validateVars(this.vars, reqVars, this.validIfFn, csr);
 
-			if ('qName' in vars || 'xCraftSite' in vars)
+			if (['qName', 'qHash', 'xCraftSite'].some(name => name in vars))
 				throw new Error(
-					'qName and xCraftSite are reserved variable names',
+					'qName, qHash and xCraftSite are reserved variable names',
 				);
 		} catch (e) {
 			return newError(e, 400);
@@ -158,7 +160,12 @@ export default class QueryGqlRoute {
 		let cacheKey: string | null = null;
 		const useCache = !previewToken && caching.isEnabled();
 		if (useCache) {
-			cacheKey = await calcKey({ ...vars, qName: this.name, xCraftSite });
+			cacheKey = await calcKey({
+				...vars,
+				qName: this.name,
+				qHash: this.queryHash,
+				xCraftSite,
+			});
 			const cached = await caching.getCache(cacheKey);
 
 			if (logInfo) console.log(`${logInfo} ${cached ? 'hit' : 'miss'}`);
@@ -223,7 +230,7 @@ export default class QueryGqlRoute {
 
 		// now we have a valid json resp.
 		// should we cache it?
-		if (cacheKey && this.cacheIfFn?.(jsonResp.data, vars)) {
+		if (cacheKey && this.cacheIfFn?.(jsonResp.data, vars, csr)) {
 			try {
 				await caching.setCache(cacheKey, jsonResp);
 				if (logInfo) console.log(logInfo + ' set cache');

package/src/server/queries/QueryHandleRoute.ts

@@ -1,6 +1,5 @@
 import { QueryVar } from '../../queries/vars.js';
 import CrelteServerRequest from '../CrelteServer.js';
-import ServerRouter from '../ServerRouter.js';
 import { HandleFn, newError, validateVars, ValidIfFn } from './routes.js';
 
 // only internal
@@ -22,14 +21,11 @@ export default class QueryHandleRoute {
 		this.vars = vars;
 	}
 
-	async handle(
-		cs: ServerRouter,
-		csr: CrelteServerRequest,
-	): Promise<Response> {
+	async handle(csr: CrelteServerRequest): Promise<Response> {
 		let vars: Record<string, any>;
 		try {
 			const reqVars = await csr.req.json();
-			vars = validateVars(this.vars, reqVars, this.validIfFn, cs);
+			vars = validateVars(this.vars, reqVars, this.validIfFn, csr);
 		} catch (e) {
 			return newError(e, 400);
 		}

package/src/server/queries/queries.ts

@@ -132,6 +132,7 @@ export async function initQueryRoutes(
 				);
 
 			const route = new QueryGqlRoute(name, rb.query, rb);
+			await route.init();
 
 			router.post('/queries/' + route.name, csr =>
 				route.handle(caching, csr),
@@ -147,9 +148,7 @@ export async function initQueryRoutes(
 				rb.vars,
 			);
 
-			router.post('/queries/' + route.name, csr =>
-				route.handle(caching.router, csr),
-			);
+			router.post('/queries/' + route.name, csr => route.handle(csr));
 		} else {
 			throw new Error(
 				`query js/ts ${name} file needs to either have ` +

package/src/server/queries/routes.ts

@@ -1,13 +1,16 @@
 import { QueryVar } from '../../queries/vars.js';
 import CrelteServerRequest from '../CrelteServer.js';
-import ServerRouter from '../ServerRouter.js';
 
-export type CacheIfFn = (response: any, vars: Record<string, any>) => boolean;
+export type CacheIfFn = (
+	response: any,
+	vars: Record<string, any>,
+	csr: CrelteServerRequest,
+) => boolean;
 
 /// Either throw or return a boolean
 export type ValidIfFn = (
 	vars: Record<string, any>,
-	sr: ServerRouter,
+	csr: CrelteServerRequest,
 ) => void | boolean;
 
 /// Anything other than returning undefined will replace the response
@@ -33,7 +36,7 @@ export function validateVars(
 	qvars: Record<string, QueryVar> | null,
 	vars: any,
 	validIfFn: ValidIfFn | null,
-	sr: ServerRouter,
+	csr: CrelteServerRequest,
 ): Record<string, any> {
 	if (!vars || typeof vars !== 'object')
 		throw new Error('expected an object as vars');
@@ -43,12 +46,12 @@ export function validateVars(
 	const nVars: Record<string, any> = {};
 
 	for (const [k, v] of Object.entries(qvars)) {
-		nVars[k] = v.validValue(vars[k], sr);
+		nVars[k] = v.validValue(vars[k], csr);
 	}
 
 	if (validIfFn) {
 		// or throw
-		const valid = validIfFn(nVars, sr);
+		const valid = validIfFn(nVars, csr);
 		if (typeof valid === 'boolean' && !valid)
 			throw new Error('invalid variables for query');
 	}

package/src/server/shared.ts

@@ -27,7 +27,7 @@ export type EnvData = {
 	env: Map<string, string>;
 	endpointUrl: string;
 	endpointToken?: string;
-	craftWebUrl: string;
+	craftBaseCpUrl: string;
 	frontendUrl: string;
 	viteEnv: Map<string, string>;
 };
@@ -47,8 +47,8 @@ export async function initEnvData(os: Platform): Promise<EnvData> {
 
 	const endpointToken = env.get('ENDPOINT_TOKEN');
 
-	const craftWebUrl = env.get('CRAFT_WEB_URL');
-	if (!craftWebUrl) throw new Error('CRAFT_WEB_URL not set');
+	const craftBaseCpUrl = env.get('CRAFT_BASE_CP_URL');
+	if (!craftBaseCpUrl) throw new Error('CRAFT_BASE_CP_URL not set');
 
 	const frontendUrl = env.get('FRONTEND_URL');
 	if (!frontendUrl) throw new Error('FRONTEND_URL not set');
@@ -62,7 +62,7 @@ export async function initEnvData(os: Platform): Promise<EnvData> {
 		env,
 		endpointUrl,
 		endpointToken,
-		craftWebUrl,
+		craftBaseCpUrl,
 		frontendUrl,
 		viteEnv,
 	};
@@ -145,7 +145,7 @@ export type RenderRequest = {
 	htmlTemplate: string;
 	ssrManifest: Record<string, string[]>;
 	endpoint: string;
-	craftWeb: string;
+	craftUrl: string;
 	frontend: string;
 	viteEnv: Map<string, string>;
 	sites: SiteFromGraphQl[];
@@ -170,7 +170,7 @@ export async function modRender(
 		htmlTemplate: template,
 		ssrManifest: {},
 		endpoint: env.endpointUrl,
-		craftWeb: env.craftWebUrl,
+		craftUrl: env.craftBaseCpUrl,
 		frontend: env.frontendUrl,
 		viteEnv: env.viteEnv,
 		sites,
@@ -199,7 +199,7 @@ export type RenderErrorRequest = {
 	ssrManifest: Record<string, string[]>;
 	acceptLang: string | null;
 	endpoint: string;
-	craftWeb: string;
+	craftUrl: string;
 	frontend: string;
 	viteEnv: Map<string, string>;
 };
@@ -239,7 +239,7 @@ export async function modRenderError(
 		ssrManifest: {},
 		acceptLang,
 		endpoint: env.endpointUrl,
-		craftWeb: env.craftWebUrl,
+		craftUrl: env.craftBaseCpUrl,
 		frontend: env.frontendUrl,
 		viteEnv: env.viteEnv,
 		...opts,

package/src/ssr/SsrCache.ts

@@ -1,3 +1,6 @@
+import { uneval } from 'devalue';
+import { cryptoSha1Hash } from '../utils.js';
+
 /**
  * Calculates a key based on the json representation of the data
  *
@@ -9,20 +12,7 @@ export async function calcKey(data: any): Promise<string> {
 	// specifically in the craft preview locally
 	if (!crypto?.subtle) return json;
 
-	// Convert the string data to an ArrayBuffer
-	const encoder = new TextEncoder();
-	const dataBuffer = encoder.encode(json);
-
-	// Use the Web Crypto API to hash the data with SHA-1
-	const hashBuffer = await crypto.subtle.digest('SHA-1', dataBuffer);
-
-	// Convert the ArrayBuffer to a hex string
-	const hashArray = Array.from(new Uint8Array(hashBuffer)); // Create an array from the buffer
-	const hashHex = hashArray
-		.map(b => b.toString(16).padStart(2, '0'))
-		.join(''); // Convert to hex string
-
-	return hashHex;
+	return await cryptoSha1Hash(json);
 }
 
 /**
@@ -147,15 +137,15 @@ export default class SsrCache {
 		delete window._SSR_STORE;
 	}
 
-	private exportAsJson(): string {
-		return JSON.stringify(Array.from(this.store.entries())).replace(
-			/</g,
-			'\\u003c',
-		);
-	}
-
 	/** @hidden */
-	z_exportToHead(): string {
-		return `\n\t\t<script>window._SSR_STORE = ${this.exportAsJson()};</script>`;
+	z_toData(): any {
+		return this.store;
 	}
 }
+
+export function ssrCacheExportToHead(ssr: SsrCache) {
+	const data = Array.from(ssr.z_toData().entries());
+
+	// safety, uneval already escapes data: https://github.com/sveltejs/devalue#xss-mitigation
+	return `\n\t\t<script>window._SSR_STORE = ${uneval(data)};</script>`;
+}

package/src/static/index.ts

@@ -12,7 +12,7 @@ export type CrelteStaticRequest = CrelteRequest & {
 	 *
 	 * @example
 	 * ```js
-	 * router.add('/blog/:slug', async (csr) => {
+	 * router.add('/blog/:slug', async csr => {
 	 *     const blogData = await fetchBlogData(csr.getParam('slug'));
 	 *
 	 *     return {

package/src/std/encdec/escaping.ts

@@ -0,0 +1,47 @@
+/*
+ * Code from Svelte (https://github.com/sveltejs/svelte/blob/b4968584df6be22222f58c273bdd8e04307ad36b/packages/svelte/src/escaping.js)
+ *
+ * Copyright (c) 2016-24 these people (https://github.com/sveltejs/svelte/graphs/contributors)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+const ATTR_REGEX = /[&"<]/g;
+const CONTENT_REGEX = /[&<]/g;
+
+export function escape_html<V>(value: V, is_attr: boolean = false) {
+	const str = String(value ?? '');
+
+	const pattern = is_attr ? ATTR_REGEX : CONTENT_REGEX;
+	pattern.lastIndex = 0;
+
+	let escaped = '';
+	let last = 0;
+
+	while (pattern.test(str)) {
+		const i = pattern.lastIndex - 1;
+		const ch = str[i];
+		escaped +=
+			str.substring(last, i) +
+			(ch === '&' ? '&amp;' : ch === '"' ? '&quot;' : '&lt;');
+		last = i + 1;
+	}
+
+	return escaped + str.substring(last);
+}

package/src/std/encdec/index.ts

@@ -0,0 +1,16 @@
+import { escape_html } from './escaping.js';
+
+/**
+ * Convert newlines to <br> tags and escape HTML.
+ *
+ * #### Warning
+ * When used in an attribute, the `isAttr` parameter needs to be set to `true`.
+ *
+ * #### Example
+ * ```svelte
+ * {@html nl2br("Hello\nWorld")}
+ * ```
+ */
+export function nl2br(str: string, isAttr: boolean = false): string {
+	return escape_html(str, isAttr).replace(/\n/g, '<br>');
+}

package/src/std/index.ts

@@ -31,12 +31,7 @@ export interface Cloneable {
  * A type that represents a value that can be cloned.
  */
 export type CloneableOrPrimitive =
-	| Cloneable
-	| string
-	| number
-	| boolean
-	| null
-	| undefined;
+	Cloneable | string | number | boolean | null | undefined;
 
 /**
  * Creates a clone of the provided value. The values need to be either

package/src/translations/index.ts

@@ -13,6 +13,7 @@ import {
 	createTranslations,
 	getTranslationsPlugin,
 	type TranslateFunction,
+	type TranslationVarValue,
 	type TranslateStore,
 	type Translations,
 	TranslationsPlugin,
@@ -50,6 +51,7 @@ export {
 	LoaderCreator,
 	TranslateStore,
 	TranslateFunction,
+	TranslationVarValue,
 	// loaders
 	createFileLoader,
 	createGlobalLoader,

package/src/translations/translationsPlugin.ts

@@ -7,8 +7,9 @@ import { getCrelte } from '../index.js';
 
 export type TranslateFunction = (
 	key: string,
-	// replacements?: Record<string, string>,
+	vars?: Record<string, TranslationVarValue>,
 ) => string;
+export type TranslationVarValue = string | number;
 export type TranslateStore = Readable<TranslateFunction>;
 export type Translations = Record<string, string>;
 export type TranslationsPluginOptions = {
@@ -89,18 +90,60 @@ export class TranslationsPlugin implements Plugin {
 	/** @hidden */
 	z_createTranslateStore(namespace: string): TranslateStore {
 		const store = derived(this.crelte.router.site, site => {
-			return (key: string) => {
+			return (
+				key: string,
+				vars?: Record<string, TranslationVarValue>,
+			) => {
 				const lang = site?.language ?? this.firstLang;
 				if (!lang) throw new Error('no lang');
 
 				const data = this.get(lang, namespace);
 				if (!data) console.error(`namespace '${namespace}' not loaded`);
-				return data?.[key] || key;
+
+				const text = data?.[key] || key;
+				if (!vars) return text;
+				return this.z_resolveVariables(text, vars);
 			};
 		});
 
 		return new Readable(store);
 	}
+
+	/** @hidden */
+	z_resolveVariables(
+		text: string,
+		vars: Record<string, TranslationVarValue> = {},
+	): string {
+		let result = '';
+		let index = 0;
+
+		while (index < text.length) {
+			const openIndex = text.indexOf('{', index);
+			if (openIndex === -1) {
+				result += text.slice(index);
+				break;
+			}
+
+			const closeIndex = text.indexOf('}', openIndex + 1);
+			if (closeIndex === -1) {
+				result += text.slice(index);
+				break;
+			}
+
+			result += text.slice(index, openIndex);
+
+			const key = text.slice(openIndex + 1, closeIndex);
+			if (key in vars) {
+				result += vars[key];
+			} else {
+				result += `{${key}}`;
+			}
+
+			index = closeIndex + 1;
+		}
+
+		return result;
+	}
 }
 
 /**

package/src/utils.ts

@@ -34,3 +34,24 @@ export function urlWithPath(url: string, path?: string): URL {
 	u.pathname = path ?? '';
 	return u;
 }
+
+export async function cryptoSha1Hash(str: string): Promise<string> {
+	// Convert the string data to an ArrayBuffer
+	const encoder = new TextEncoder();
+	const dataBuffer = encoder.encode(str);
+
+	// Use the Web Crypto API to hash the data with SHA-1
+	const hashBuffer = await crypto.subtle.digest('SHA-1', dataBuffer);
+
+	const bytes = new Uint8Array(hashBuffer);
+	// @ts-ignore using 2025 baseline feature
+	if (typeof bytes.toHex === 'function') return bytes.toHex();
+
+	// Convert the ArrayBuffer to a hex string
+	const hashArray = Array.from(bytes); // Create an array from the buffer
+	const hashHex = hashArray
+		.map(b => b.toString(16).padStart(2, '0'))
+		.join(''); // Convert to hex string
+
+	return hashHex;
+}