spooder 4.2.17 → 4.3.0

package/README.md

@@ -200,7 +200,9 @@ When starting or restarting a server process, `spooder` can automatically update
 {
 	"spooder": {
 		"update": [
-			"git pull",
+			"git reset --hard",
+			"git clean -fd",
+			"git pull origin main",
 			"bun install"
 		]
 	}
@@ -210,7 +212,7 @@ When starting or restarting a server process, `spooder` can automatically update
 Each command should be a separate entry in the array and will be executed in sequence. The server process will be started once all commands have resolved.
 
 > [!IMPORTANT]
-> Chainging commands using `&&` or `||` operators does not work.
+> Chaining commands using `&&` or `||` operators does not work.
 
 If a command in the sequence fails, the remaining commands will not be executed, however the server will still be started. This is preferred over entering a restart loop or failing to start the server at all.
 
@@ -435,7 +437,7 @@ In addition to the information provided by the developer, `spooder` also include
 		"modules": "108"
 	},
 	"bun": {
-		"version": "0.6.4",
+		"version": "0.6.5",
 		"rev": "f02561530fda1ee9396f51c8bc99b38716e38296",
 		"memory_usage": {
 			"rss": 99672064,
@@ -716,6 +718,9 @@ server.route('/api/endpoint', async (req, url) => {
 
 	try {
 		const json = await req.json();
+		if (json === null || typeof json !== 'object' || Array.isArray(json))
+			return 400;
+
 		// do something with json.
 		return 200;
 	} catch (err) {
@@ -735,6 +740,9 @@ server.route('/api/endpoint', validate_req_json(async (json, req, url) => {
 
 This behaves the same as the code above, where a `400` status code is returned if the `Content-Type` header is not `application/json` or if the request body is not valid JSON, and no error is thrown.
 
+> [!NOTE]
+> While arrays and other primitives are valid JSON, `validate_req_json` will only pass objects to the handler, since they are the most common use case for JSON request bodies and it removes the need to validate that in the handler. If you need to use arrays or other primitives, either box them in an object or provide your own validation.
+
 <a id="api-routing-directory-serving"></a>
 ## API > Routing > Directory Serving
 
@@ -772,7 +780,7 @@ function default_directory_handler(file_path: string, file: BunFile, stat: DirSt
 ```
 
 > [!NOTE]
-> Uncaught `ENOENT` errors throw from the directory handler will return a `404` response, other errors will return a `500` response.
+> Uncaught `ENOENT` errors thrown from the directory handler will return a `404` response, other errors will return a `500` response.
 
 > [!NOTE]
 > The call to `apply_range` in the default directory handler will automatically slice the file based on the [`Range`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range) header. This function is also exposed as part of the `spooder` API for use in your own handlers.
@@ -1058,6 +1066,24 @@ const html = parse_template(template, replacements);
 </html>
 ```
 
+Object properties are supported by using the dot syntax.
+
+```ts
+const template = `<span>{$foo.bar}</span>`;
+
+const replacements = {
+	foo: {
+		bar: 'Hello, world!';
+	}
+};
+
+const html = parse_template(template, replacements);
+```
+
+```html
+<span>Hello, world!</span>
+```
+
 By default, placeholders that do not appear in the replacement object will be left as-is. Set `drop_missing` to `true` to remove them.
 
 ```ts
@@ -1099,16 +1125,15 @@ parse_template('Hello {$world}', replacer);
 	</body>
 </html>
 ```
-
 `parse_template` supports looping arrays with the following syntax.
 
 ```html
-{$for:foo}My colour is %s{/for}
+{$for:foo as bar}My colour is {$bar}{/for}
 ```
 ```ts
 const template = `
 	<ul>
-		{$for:foo}<li>%s</li>{/for}
+		{$for:foo as bar}<li>{$bar}</li>{/for}
 	</ul>
 `;
 
@@ -1127,24 +1152,39 @@ const html = parse_template(template, replacements);
 </ul>
 ```
 
-All placeholders inside a `{$for:}` loop are substituted, but only if the loop variable exists.
-
-In the following example, `missing` does not exist, so `test` is not substituted inside the loop, but `test` is still substituted outside the loop.
+Loops also support object properties using the dot syntax.
 
 ```html
-<div>Hello {$test}!</div>
-{$for:missing}<div>Loop {$test}</div>{/for}
+{$for:foo as bar}My colour is {$bar.baz}{/for}
 ```
-
 ```ts
-parse_template(..., {
-	test: 'world'
-});
+const template = `
+	<ul>
+		{$for:foo as bar}<li>My colour is {$bar.baz}</li>{/for}
+	</ul>
+`;
 ```
 
+If/else statements are supported in templates, which include blocks based on the existence/truthiness of a property.
+
+```html
+{$if:is_on_earth}
+	Hello, world!
+{else}
+	Hello, Mars!
+{/if}
+```
+
+This also works with nested properties and loops.
+
 ```html
-<div>Hello world!</div>
-{$for}Loop <div>{$test}</div>{/for}
+{$for:countries as country}
+	{$if:country.is_in_europe}
+		Europe: {$country.name}
+	{else}
+		Not Europe: {$country.name}
+	{/if}
+{/for}
 ```
 
 <a id="api-content-generate-hash-subs"></a>

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "spooder",
 	"type": "module",
-	"version": "4.2.17",
+	"version": "4.3.0",
 	"exports": {
 		".": {
 			"bun": "./src/api.ts",

package/src/api.ts

@@ -108,8 +108,8 @@ export async function safe(target_fn: Callable) {
 	}
 }
 
-type ReplacerFn = (key: string) => string | Array<string> | undefined;
-type Replacements = Record<string, string | Array<string>> | ReplacerFn;
+type ReplacerFn = (key: string) => string | Array<any> | Record<string, any> | undefined;
+type Replacements = Record<string, string | Array<any> | Record<string, any>> | ReplacerFn;
 
 export function parse_template(template: string, replacements: Replacements, drop_missing = false): string {
 	let result = '';
@@ -118,6 +118,28 @@ export function parse_template(template: string, replacements: Replacements, dro
 
 	const is_replacer_fn = typeof replacements === 'function';
 
+	function getValue(key: string): any {
+		const var_parts = key.split('.');
+		let value: any = is_replacer_fn ? replacements(var_parts[0]) : replacements[var_parts[0]];
+		
+		for (let j = 1; j < var_parts.length; j++) {
+			if (value && typeof value === 'object') {
+				value = value[var_parts[j]];
+			} else {
+				value = undefined;
+				break;
+			}
+		}
+		return value;
+	}
+
+	function parseBlock(content: string, local_replacements: Replacements): string {
+		return parse_template(content, {
+			...replacements,
+			...local_replacements
+		}, drop_missing);
+	}
+
 	const template_length = template.length;
 	for (let i = 0; i < template_length; i++) {
 		const char = template[i];
@@ -130,9 +152,8 @@ export function parse_template(template: string, replacements: Replacements, dro
 			buffer_active = false;
 
 			if (buffer.startsWith('for:')) {
-				const loop_key = buffer.substring(4);
-
-				const loop_entries = is_replacer_fn ? replacements(loop_key) : replacements[loop_key];
+				const [loop_key, loop_var] = buffer.substring(4).split(' as ');
+				const loop_entries = getValue(loop_key);
 				const loop_content_start_index = i + 1;
 				const loop_close_index = template.indexOf('{/for}', loop_content_start_index);
 				
@@ -141,19 +162,48 @@ export function parse_template(template: string, replacements: Replacements, dro
 						result += '{$' + buffer + '}';
 				} else {
 					const loop_content = template.substring(loop_content_start_index, loop_close_index);
-					if (loop_entries !== undefined) {
-						for (const loop_entry of loop_entries) {
-							const inner_content = loop_content.replaceAll('%s', loop_entry);
-							result += parse_template(inner_content, replacements, drop_missing);
-						}
+					if (Array.isArray(loop_entries)) {
+						for (const loop_entry of loop_entries)
+							result += parseBlock(loop_content, { [loop_var]: loop_entry });
 					} else {
 						if (!drop_missing)
 							result += '{$' + buffer + '}' + loop_content + '{/for}';
 					}
-					i += loop_content.length + 6;
+					i = loop_close_index + 5; // Move past {/for}
+				}
+			} else if (buffer.startsWith('if:')) {
+				const condition_key = buffer.substring(3);
+				const condition_value = getValue(condition_key);
+				const if_content_start_index = i + 1;
+				const if_close_index = template.indexOf('{/if}', if_content_start_index);
+				
+				if (if_close_index === -1) {
+					if (!drop_missing)
+						result += '{$' + buffer + '}';
+				} else {
+					const if_content = template.substring(if_content_start_index, if_close_index);
+					const else_index = if_content.indexOf('{else}');
+					
+					if (else_index === -1) {
+						// No else block
+						if (condition_value) {
+							result += parseBlock(if_content, {});
+						}
+					} else {
+						// Has else block
+						const true_content = if_content.substring(0, else_index);
+						const false_content = if_content.substring(else_index + 6); // +6 to move past {else}
+						
+						if (condition_value)
+							result += parseBlock(true_content, {});
+						else
+							result += parseBlock(false_content, {});
+					}
+					i = if_close_index + 4; // Move past {/if}
 				}
 			} else {
-				const replacement = is_replacer_fn ? replacements(buffer) : replacements[buffer];
+				const replacement = getValue(buffer);
+
 				if (replacement !== undefined)
 					result += replacement;
 				else if (!drop_missing)
@@ -398,7 +448,7 @@ type ErrorHandler = (err: Error, req: Request, url: URL) => Resolvable<Response>
 type DefaultHandler = (req: Request, status_code: number) => HandlerReturnType;
 type StatusCodeHandler = (req: Request) => HandlerReturnType;
 
-type JSONRequestHandler = (req: Request, url: URL, json: JsonSerializable) => HandlerReturnType;
+type JSONRequestHandler = (req: Request, url: URL, json: JsonObject) => HandlerReturnType;
 
 type ServerSentEventClient = {
 	message: (message: string) => void;
@@ -451,7 +501,13 @@ export function validate_req_json(JSONRequestHandler: JSONRequestHandler): Reque
 			if (req.headers.get('Content-Type') !== 'application/json')
 				return 400; // Bad Request
 
-			return JSONRequestHandler(req, url, await req.json());
+			const json = await req.json();
+
+			// validate json is a plain object
+			if (json === null || typeof json !== 'object' || Array.isArray(json))
+				return 400; // Bad Request
+
+			return JSONRequestHandler(req, url, json);
 		} catch (e) {
 			return 400; // Bad Request
 		}