meno-core 1.0.52 → 1.0.53

package/lib/server/services/componentService.ts

@@ -11,8 +11,13 @@ import { existsSync, mkdirSync, unlinkSync, readdirSync, rmdirSync } from 'fs';
 import { loadComponentDirectory, loadJSONFile, parseJSON } from '../jsonLoader';
 import type { ComponentWithCategory, ComponentDirectoryResult, ComponentLoadDiagnostic } from '../jsonLoader';
 import { projectPaths } from '../projectContext';
-import type { ComponentDefinition } from '../../shared/types';
+import type { ComponentDefinition, JSONPage } from '../../shared/types';
 import { readTextFile, fileExists } from '../runtime';
+import type { PageService } from './pageService';
+import { rewriteComponentRefs } from '../../shared/componentRefs';
+
+// Re-export for callers that already imported the helper from this module.
+export { rewriteComponentRefs };
 
 /**
  * File system interface for dependency injection
@@ -32,6 +37,50 @@ export interface ComponentLoader {
   loadFile(path: string): Promise<string | null>;
 }
 
+/**
+ * Component writer interface for dependency injection.
+ *
+ * This is the WRITE-side mirror of {@link ComponentLoader}. By default (no writer
+ * injected) ComponentService keeps its exact JSON behavior — `.json` definition files
+ * plus sibling `.js`/`.css` under `<root>/components/`. Injecting a writer lets a
+ * different on-disk format own where and how components are persisted. The astro
+ * format (`meno-astro`'s `AstroComponentWriter`) emits a single `.astro` file per
+ * component under `src/components/` (structure + JS + CSS + meta folded together).
+ *
+ * The service still owns category resolution, the in-memory cache, ref-rewriting,
+ * and validation; the writer only abstracts the directory + the physical file I/O.
+ */
+export interface ComponentWriter {
+  /** Base components directory this writer owns (e.g. `<root>/src/components`). */
+  componentsDir(): string;
+
+  /**
+   * Persist a component definition into `dir` under `name`. For single-file formats
+   * (astro) `def` carries everything (structure/interface/js/css/meta); for the JSON
+   * writer it is the `.json` payload (js/css live in sibling files written separately).
+   */
+  writeComponent(dir: string, name: string, def: ComponentDefinition): Promise<void>;
+
+  /**
+   * Persist the component's JavaScript. `currentDef` is the latest in-memory definition
+   * so single-file formats can re-emit the whole `.astro` with the new JS folded in.
+   * Multi-file formats (JSON) just write a sibling `<name>.js`.
+   */
+  writeJavaScript(dir: string, name: string, javascript: string, currentDef?: ComponentDefinition): Promise<void>;
+
+  /** Persist the component's CSS. Mirrors {@link writeJavaScript}. */
+  writeCSS(dir: string, name: string, css: string, currentDef?: ComponentDefinition): Promise<void>;
+
+  /** Delete every on-disk file for `name` in `dir` (definition + any JS/CSS). */
+  removeComponent(dir: string, name: string): Promise<void>;
+
+  /** Whether any on-disk file for `name` already exists in `dir` (collision check). */
+  componentExists(dir: string, name: string): Promise<boolean>;
+
+  /** Move every file for `name` from `srcDir` to `dstDir` (category change / rename). */
+  moveComponent(srcDir: string, dstDir: string, name: string, dstName?: string): Promise<void>;
+}
+
 /**
  * Component info with category metadata
  */
@@ -45,6 +94,7 @@ export class ComponentService {
   private componentCategories = new Map<string, string | undefined>();
   private fs?: ComponentServiceFs;
   private loader?: ComponentLoader;
+  private writer?: ComponentWriter;
   private loadErrors = new Map<string, ComponentLoadDiagnostic>();
   private loadWarnings: ComponentLoadDiagnostic[] = [];
 
@@ -53,11 +103,27 @@ export class ComponentService {
    *
    * @param options - Optional configuration for dependency injection
    * @param options.fs - Optional file system interface for testing
-   * @param options.loader - Optional component loader interface for testing
+   * @param options.loader - Optional component loader interface for testing (READ)
+   * @param options.writer - Optional component writer for non-JSON on-disk formats
+   *   (WRITE). When omitted, the service writes JSON exactly as before — legacy
+   *   projects are byte-identical. The astro bootstrap injects an AstroComponentWriter
+   *   so saves emit `.astro` files under `src/components/`.
    */
-  constructor(options?: { fs?: ComponentServiceFs; loader?: ComponentLoader }) {
+  constructor(options?: { fs?: ComponentServiceFs; loader?: ComponentLoader; writer?: ComponentWriter }) {
     this.fs = options?.fs;
     this.loader = options?.loader;
+    this.writer = options?.writer;
+  }
+
+  /**
+   * Base components directory — `<root>/components` for JSON, or whatever the
+   * injected writer owns (e.g. `<root>/src/components` for astro). All path
+   * resolution (categories, folders, save/move/rename targets) routes through
+   * here so a single switch covers every write op.
+   * @internal
+   */
+  private componentsBaseDir(): string {
+    return this.writer ? this.writer.componentsDir() : projectPaths.components();
   }
 
   /**
@@ -77,10 +143,15 @@ export class ComponentService {
    * ```
    */
   async loadAllComponents(): Promise<void> {
-    this.components.clear();
-    this.componentCategories.clear();
-    this.loadErrors.clear();
-    this.loadWarnings = [];
+    // Build new state locally and swap atomically. Concurrent saves
+    // (e.g. ensureAcceptsStyles firing while the file watcher reload runs)
+    // must never observe an empty `componentCategories` mid-reload — that
+    // gap was what caused fresh component files to be written at root next
+    // to the canonical categorized file.
+    const nextComponents = new Map<string, ComponentDefinition>();
+    const nextCategories = new Map<string, string | undefined>();
+    const nextErrors = new Map<string, ComponentLoadDiagnostic>();
+    let nextWarnings: ComponentLoadDiagnostic[] = [];
 
     let loadedComponents: Map<string, ComponentWithCategory>;
 
@@ -92,9 +163,9 @@ export class ComponentService {
       loadedComponents = result.components;
 
       // Store diagnostics
-      this.loadWarnings = result.warnings;
+      nextWarnings = result.warnings;
       for (const error of result.errors) {
-        this.loadErrors.set(error.componentName, error);
+        nextErrors.set(error.componentName, error);
       }
     }
 
@@ -103,13 +174,17 @@ export class ComponentService {
       const componentWithCategory = value as ComponentWithCategory;
       const category = componentWithCategory._category;
 
-      // Store category mapping
-      this.componentCategories.set(key, category);
+      nextCategories.set(key, category);
 
       // Remove internal metadata before storing
       const { _category, _relativePath, ...cleanDef } = componentWithCategory;
-      this.components.set(key, cleanDef as ComponentDefinition);
+      nextComponents.set(key, cleanDef as ComponentDefinition);
     });
+
+    this.components = nextComponents;
+    this.componentCategories = nextCategories;
+    this.loadErrors = nextErrors;
+    this.loadWarnings = nextWarnings;
   }
 
   /**
@@ -286,11 +361,67 @@ export class ComponentService {
    * @internal
    */
   private getComponentDir(name: string, category?: string): string {
-    const componentsDir = projectPaths.components();
-    const cat = category ?? this.componentCategories.get(name);
+    const componentsDir = this.componentsBaseDir();
+    const cat = this.resolveComponentCategory(name, category);
     return cat ? join(componentsDir, cat) : componentsDir;
   }
 
+  /**
+   * Resolve which category a save should land in. Priority:
+   *   1. Explicit caller-supplied category (including '' for root)
+   *   2. In-memory categories cache
+   *   3. Existing file on disk (defense against a stale/empty cache)
+   * Falls back to root only when none of the above resolves. The disk
+   * scan in step 3 closes the race where a save fires while
+   * loadAllComponents has been called but hasn't rebuilt the cache yet.
+   * @internal
+   */
+  private resolveComponentCategory(name: string, category?: string): string | undefined {
+    if (category !== undefined) {
+      return category || undefined;
+    }
+    if (this.componentCategories.has(name)) {
+      return this.componentCategories.get(name);
+    }
+    return this.findComponentCategoryOnDisk(name);
+  }
+
+  /**
+   * Look on disk for an existing `<name>.json` and return its category.
+   * Returns undefined for "exists at root" or "not found anywhere" — both
+   * map to writing at root, which is the right default.
+   * @internal
+   */
+  private findComponentCategoryOnDisk(name: string): string | undefined {
+    const componentsDir = this.componentsBaseDir();
+    if (!existsSync(componentsDir)) return undefined;
+    // File extension is format-specific (.json for JSON, .astro for astro). When a
+    // writer is injected we don't know its extension here, so use a synchronous
+    // directory scan that matches any `<name>.*` definition file.
+    const ext = this.writer ? null : '.json';
+    const existsAt = (dir: string): boolean => {
+      if (ext) return existsSync(join(dir, `${name}${ext}`));
+      try {
+        return readdirSync(dir, { withFileTypes: true }).some(
+          (e) => e.isFile() && (e.name === `${name}.json` || e.name === `${name}.astro`),
+        );
+      } catch {
+        return false;
+      }
+    };
+    if (existsAt(componentsDir)) return undefined;
+    try {
+      for (const entry of readdirSync(componentsDir, { withFileTypes: true })) {
+        if (entry.isDirectory() && existsAt(join(componentsDir, entry.name))) {
+          return entry.name;
+        }
+      }
+    } catch {
+      // If the components dir is unreadable, fall through to root.
+    }
+    return undefined;
+  }
+
   /**
    * Get component JavaScript from .js file
    *
@@ -349,33 +480,39 @@ export class ComponentService {
    * ```
    */
   async saveComponent(name: string, data: ComponentDefinition, category?: string): Promise<void> {
-    const writeFile = this.fs
-      ? this.fs.writeFile.bind(this.fs)
-      : (await import('fs/promises')).writeFile;
-
     // Create a copy without the javascript field (JavaScript should only be in .js files)
     const dataWithoutJS = JSON.parse(JSON.stringify(data));
     if (dataWithoutJS?.component?.javascript !== undefined) {
       delete dataWithoutJS.component.javascript;
     }
 
-    // Determine target directory
-    // If category is explicitly provided (including ''), use it
-    // Otherwise, use existing category or root
-    const targetCategory = category !== undefined
-      ? (category || undefined)  // Convert '' to undefined for root
-      : this.componentCategories.get(name);
-
-    const componentDir = this.getComponentDir(name, targetCategory);
+    // Determine target directory. Resolver consults the explicit arg, then
+    // the in-memory cache, then disk — so a save during the file-watcher
+    // reload window can't accidentally land at root next to a categorized
+    // file.
+    const targetCategory = this.resolveComponentCategory(name, category);
+    const componentsDir = this.componentsBaseDir();
+    const componentDir = targetCategory ? join(componentsDir, targetCategory) : componentsDir;
+
+    if (this.writer) {
+      // Format-aware write (e.g. emit a `.astro` file). The writer owns directory
+      // creation + serialization. The category folder is part of `componentDir`.
+      await this.writer.writeComponent(componentDir, name, dataWithoutJS);
+    } else {
+      // JSON path — unchanged, byte-identical to legacy behavior.
+      const writeFile = this.fs
+        ? this.fs.writeFile.bind(this.fs)
+        : (await import('fs/promises')).writeFile;
+
+      // Create category directory if needed
+      if (targetCategory && !existsSync(componentDir)) {
+        mkdirSync(componentDir, { recursive: true });
+      }
 
-    // Create category directory if needed
-    if (targetCategory && !existsSync(componentDir)) {
-      mkdirSync(componentDir, { recursive: true });
+      const filePath = join(componentDir, `${name}.json`);
+      await writeFile(filePath, JSON.stringify(dataWithoutJS, null, 2), 'utf-8');
     }
 
-    const filePath = join(componentDir, `${name}.json`);
-    await writeFile(filePath, JSON.stringify(dataWithoutJS, null, 2), 'utf-8');
-
     // Update in-memory cache
     this.components.set(name, dataWithoutJS);
     this.componentCategories.set(name, targetCategory);
@@ -399,10 +536,23 @@ export class ComponentService {
    * ```
    */
   async saveComponentJavaScript(name: string, javascript: string): Promise<void> {
+    const componentDir = this.getComponentDir(name);
+
+    if (this.writer) {
+      // Single-file formats (astro) fold JS into the `.astro` file. Re-emit from
+      // the latest in-memory definition with the new JS so structure/CSS survive.
+      const current = this.components.get(name);
+      await this.writer.writeJavaScript(componentDir, name, javascript || '', current);
+      const next: ComponentDefinition = current
+        ? { ...current, component: { ...current.component, javascript: javascript || '' } }
+        : { component: { javascript: javascript || '' } };
+      this.components.set(name, next);
+      return;
+    }
+
     const writeFile = this.fs
       ? this.fs.writeFile.bind(this.fs)
       : (await import('fs/promises')).writeFile;
-    const componentDir = this.getComponentDir(name);
     const jsFilePath = join(componentDir, `${name}.js`);
     await writeFile(jsFilePath, javascript || '', 'utf-8');
 
@@ -444,10 +594,23 @@ export class ComponentService {
    * ```
    */
   async saveComponentCSS(name: string, css: string): Promise<void> {
+    const componentDir = this.getComponentDir(name);
+
+    if (this.writer) {
+      // Single-file formats (astro) fold CSS into the `.astro` file. Re-emit from
+      // the latest in-memory definition with the new CSS so structure/JS survive.
+      const current = this.components.get(name);
+      await this.writer.writeCSS(componentDir, name, css || '', current);
+      const next: ComponentDefinition = current
+        ? { ...current, component: { ...current.component, css: css || '' } }
+        : { component: { css: css || '' } };
+      this.components.set(name, next);
+      return;
+    }
+
     const writeFile = this.fs
       ? this.fs.writeFile.bind(this.fs)
       : (await import('fs/promises')).writeFile;
-    const componentDir = this.getComponentDir(name);
     const cssFilePath = join(componentDir, `${name}.css`);
     await writeFile(cssFilePath, css || '', 'utf-8');
 
@@ -486,7 +649,7 @@ export class ComponentService {
    * ```
    */
   getAllFolders(): string[] {
-    const componentsDir = projectPaths.components();
+    const componentsDir = this.componentsBaseDir();
     if (!existsSync(componentsDir)) {
       return [];
     }
@@ -529,7 +692,7 @@ export class ComponentService {
       throw new Error('Folder name can only contain lowercase letters, numbers, dashes, and underscores');
     }
 
-    const componentsDir = projectPaths.components();
+    const componentsDir = this.componentsBaseDir();
     const folderPath = join(componentsDir, folderName);
 
     if (existsSync(folderPath)) {
@@ -569,25 +732,31 @@ export class ComponentService {
       return;
     }
 
-    const componentsDir = projectPaths.components();
+    const componentsDir = this.componentsBaseDir();
     const sourceDir = currentCategory ? join(componentsDir, currentCategory) : componentsDir;
     const targetDir = targetCategory ? join(componentsDir, targetCategory) : componentsDir;
 
-    // Create target directory if needed
-    if (targetCategory && !existsSync(targetDir)) {
-      mkdirSync(targetDir, { recursive: true });
-    }
+    if (this.writer) {
+      // Format-aware move (e.g. relocate the single `.astro` file). The writer
+      // owns target-dir creation + which files belong to the component.
+      await this.writer.moveComponent(sourceDir, targetDir, name);
+    } else {
+      // Create target directory if needed
+      if (targetCategory && !existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+      }
 
-    // Move all component files (.json, .js, .css)
-    const extensions = ['.json', '.js', '.css'];
-    const { rename } = await import('fs/promises');
+      // Move all component files (.json, .js, .css)
+      const extensions = ['.json', '.js', '.css'];
+      const { rename } = await import('fs/promises');
 
-    for (const ext of extensions) {
-      const sourcePath = join(sourceDir, `${name}${ext}`);
-      const targetPath = join(targetDir, `${name}${ext}`);
+      for (const ext of extensions) {
+        const sourcePath = join(sourceDir, `${name}${ext}`);
+        const targetPath = join(targetDir, `${name}${ext}`);
 
-      if (existsSync(sourcePath)) {
-        await rename(sourcePath, targetPath);
+        if (existsSync(sourcePath)) {
+          await rename(sourcePath, targetPath);
+        }
       }
     }
 
@@ -606,5 +775,141 @@ export class ComponentService {
       }
     }
   }
+
+  /**
+   * Rename a component across the project.
+   *
+   * Renames the component's `.json`/`.js`/`.css` files on disk (respecting its
+   * category folder), updates the in-memory caches, rewrites every
+   * `{ type: "component", component: "<oldName>" }` reference inside other
+   * component structures, and — if `pageService` is provided — also walks every
+   * page/template and rewrites references there, saving any pages that changed.
+   *
+   * Matching is structural (only `node.component` string equality), not
+   * text-based, so it never touches HTML tags, CSS classes, prop values, or
+   * embedded markup that happen to contain the name as a substring.
+   *
+   * @throws {Error} If old/new name is missing, names are identical, new name
+   *   isn't a valid JS identifier, the source component doesn't exist, or the
+   *   new name is already taken.
+   */
+  async renameComponent(
+    oldName: string,
+    newName: string,
+    pageService?: PageService,
+  ): Promise<{
+    oldName: string;
+    newName: string;
+    category: string | undefined;
+    componentRefs: number;
+    pageRefs: number;
+  }> {
+    if (!oldName || typeof oldName !== 'string') {
+      throw new Error('oldName is required');
+    }
+    if (!newName || typeof newName !== 'string') {
+      throw new Error('newName is required');
+    }
+    const trimmedNew = newName.trim();
+    if (oldName === trimmedNew) {
+      throw new Error('newName must differ from oldName');
+    }
+    if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(trimmedNew)) {
+      throw new Error('newName must be a valid JavaScript identifier');
+    }
+    if (!this.components.has(oldName)) {
+      throw new Error(`Component "${oldName}" not found`);
+    }
+    if (this.components.has(trimmedNew)) {
+      throw new Error(`Component "${trimmedNew}" already exists`);
+    }
+
+    const category = this.componentCategories.get(oldName);
+    const componentsDir = this.componentsBaseDir();
+    const dir = category ? join(componentsDir, category) : componentsDir;
+
+    if (this.writer) {
+      // On-disk collision check (format-aware) + move the component's file(s).
+      if (await this.writer.componentExists(dir, trimmedNew)) {
+        throw new Error(`Component "${trimmedNew}" already exists in components/${category ?? ''}`);
+      }
+      await this.writer.moveComponent(dir, dir, oldName, trimmedNew);
+    } else {
+      // On-disk collision check — defends against a stale cache where the file
+      // exists but wasn't loaded (e.g. a parse error masked it).
+      for (const ext of ['.json', '.js', '.css'] as const) {
+        if (existsSync(join(dir, `${trimmedNew}${ext}`))) {
+          throw new Error(`File "${trimmedNew}${ext}" already exists in components/${category ?? ''}`);
+        }
+      }
+
+      const { rename } = await import('fs/promises');
+      for (const ext of ['.json', '.js', '.css'] as const) {
+        const src = join(dir, `${oldName}${ext}`);
+        const dst = join(dir, `${trimmedNew}${ext}`);
+        if (existsSync(src)) {
+          await rename(src, dst);
+        }
+      }
+    }
+
+    // Move the cache entries to the new key.
+    const def = this.components.get(oldName)!;
+    this.components.delete(oldName);
+    this.componentCategories.delete(oldName);
+    this.components.set(trimmedNew, def);
+    this.componentCategories.set(trimmedNew, category);
+
+    // Rewrite references in every OTHER component's structure and persist
+    // each one that actually changed. The owning component's own structure
+    // shouldn't reference itself, so we don't bother walking it.
+    let componentRefs = 0;
+    const writeFile = this.fs
+      ? this.fs.writeFile.bind(this.fs)
+      : (await import('fs/promises')).writeFile;
+    for (const [name, otherDef] of this.components.entries()) {
+      if (name === trimmedNew) continue;
+      const structure = otherDef.component?.structure;
+      if (!structure) continue;
+      if (rewriteComponentRefs(structure, oldName, trimmedNew)) {
+        const otherCategory = this.componentCategories.get(name);
+        const otherDir = otherCategory ? join(componentsDir, otherCategory) : componentsDir;
+        // Strip the runtime-only javascript field on save, matching saveComponent.
+        const persisted = JSON.parse(JSON.stringify(otherDef));
+        if (persisted?.component?.javascript !== undefined) {
+          delete persisted.component.javascript;
+        }
+        if (this.writer) {
+          await this.writer.writeComponent(otherDir, name, persisted);
+        } else {
+          await writeFile(join(otherDir, `${name}.json`), JSON.stringify(persisted, null, 2), 'utf-8');
+        }
+        componentRefs++;
+      }
+    }
+
+    // Walk every page (and CMS template — they're loaded under /templates/*)
+    // and rewrite refs. Save pages that actually changed.
+    let pageRefs = 0;
+    if (pageService) {
+      const pagePaths = pageService.getAllPagePaths();
+      for (const path of pagePaths) {
+        const pageData = pageService.getPageData(path);
+        if (!pageData || !('root' in pageData) || !pageData.root) continue;
+        if (rewriteComponentRefs(pageData.root, oldName, trimmedNew)) {
+          await pageService.savePage(path, pageData as JSONPage);
+          pageRefs++;
+        }
+      }
+    }
+
+    return {
+      oldName,
+      newName: trimmedNew,
+      category,
+      componentRefs,
+      pageRefs,
+    };
+  }
 }
 

package/lib/server/services/fileWatcherService.ts

@@ -3,8 +3,6 @@
  * Manages file watching for pages and components
  */
 
-import { join } from 'path';
-import { existsSync } from 'fs';
 import { FileWatcher, type FileWatchCallbacks } from '../fileWatcher';
 import { WebSocketManager } from '../websocketManager';
 import { ComponentService } from './componentService';
@@ -15,9 +13,6 @@ import { colorService } from './ColorService';
 import { variableService } from './VariableService';
 import { enumService } from './EnumService';
 import { configService } from './configService';
-import { loadJSONFile, mapPageNameToPath } from '../jsonLoader';
-import { buildLineMap } from '../utils/jsonLineMapper';
-import { projectPaths } from '../projectContext';
 
 export class FileWatcherService {
   private fileWatcher: FileWatcher | null = null;
@@ -43,26 +38,11 @@ export class FileWatcherService {
         this.wsManager.broadcastUpdate('all');
       },
       onPageChange: async (pagePath: string) => {
-        const pageName = pagePath === '/' ? 'index' : pagePath.substring(1);
-        // Route template paths to the root templates/ directory
-        const filePath = pageName.startsWith('templates/')
-          ? join(projectPaths.templates(), `${pageName.substring('templates/'.length)}.json`)
-          : join(projectPaths.pages(), `${pageName}.json`);
-        const content = await loadJSONFile(filePath);
-        if (content) {
-          const lineMap = buildLineMap(content);
-          this.pageCache.set(pagePath, content, lineMap);
+        // Provider-based reload so .astro and JSON projects both live-reload. The
+        // provider re-reads (and, for astro, re-parses) the file; a transient
+        // mid-write returns false and is left for the next watcher event.
+        if (await this.pageService.reloadPageFromDisk(pagePath)) {
           this.wsManager.broadcastUpdate(pagePath);
-        } else {
-          // Only delete from cache if file truly doesn't exist
-          // If file exists but couldn't be read (being written), skip this update
-          // The file watcher will trigger again when write completes
-          if (!existsSync(filePath)) {
-            this.pageCache.delete(pagePath);
-            this.wsManager.broadcastUpdate(pagePath);
-          }
-          // If file exists but read failed, don't delete from cache or broadcast
-          // This prevents race condition where partial write triggers premature cache deletion
         }
 
         // Refresh CMS schemas when template files change

package/lib/server/services/pageService.test.ts

@@ -255,4 +255,27 @@ describe('PageService', () => {
       expect(mappings[0].slugs).toEqual({ _default: '' });
     });
   });
+
+  describe('renamePage validation', () => {
+    test('no-op when oldPath === newPath', async () => {
+      await expect(pageService.renamePage('/about', '/about')).resolves.toBeUndefined();
+    });
+
+    test('rejects rename to "/" (index)', async () => {
+      await expect(pageService.renamePage('/about', '/')).rejects.toThrow(/index/i);
+    });
+
+    test('rejects newPath without leading slash', async () => {
+      await expect(pageService.renamePage('/about', 'about-us')).rejects.toThrow(/start with/);
+    });
+
+    test('rejects cross-folder rename (use movePage)', async () => {
+      await expect(pageService.renamePage('/about', '/blog/about')).rejects.toThrow(/movePage/);
+    });
+
+    test('rejects invalid slug characters', async () => {
+      await expect(pageService.renamePage('/about', '/About Us')).rejects.toThrow(/lowercase/);
+      await expect(pageService.renamePage('/about', '/about!')).rejects.toThrow(/lowercase/);
+    });
+  });
 });