nurev 0.0.9 → 0.1.0

package/README.md

@@ -12,6 +12,8 @@ Template generator for [Nuxt](https://nuxt.com/) configured with “on-demand re
 
 ## How to use it?
 
+1. Run the script
+
 ```bash
 bunx nurev
 ```
@@ -23,3 +25,53 @@ npx nurev
 ```bash
 pnpm dlx nurev
 ```
+
+2. After the script completes, start the backend in dev mode
+
+```bash
+make backend-dev
+```
+
+3. Then start frontend in dev mode
+
+```bash
+make frontend-dev
+```
+
+## How it works?
+
+1. **Interactive prompts**: Asks you to choose a package manager (`bun`, `npm`, or `pnpm`) and a backend (`PocketBase`)
+2. **Template copying**: Copies the base Nuxt template, backend-specific files, and package-manager-specific configuration to your current directory
+3. **Installation & setup**: Runs `make install` to install dependencies and `make setup` to initialize the project
+4. **Backend configuration**: Applies backend-specific setup (e.g., PocketBase configuration)
+5. **Ready to use**: Your Nuxt project with on-demand revalidation is ready
+
+## On-Demand Revalidation
+
+The caching system uses a webhook pattern between PocketBase and Nuxt:
+
+1. **Cache storage**: Nuxt routes use `defineCachedEventHandler` with `swr: true` (stale-while-revalidate) and `maxAge: 604800` (1 week). Route rules set `prerender: true` for `/` and `swr: true` for `/posts/**`
+
+2. **Backend hooks**: Backend (PocketBase) registers hooks on `OnRecordAfterCreateSuccess`, `OnRecordAfterUpdateSuccess`, `OnRecordAfterDeleteSuccess`, `OnBackupCreate` and `OnBackupRestore` for collections defined in `TABLES_TRIGGER`
+
+3. **Webhook notification**: When a record changes, PocketBase sends an authenticated POST (JWT Bearer token) to `/api/private/reloadcache` with the table name and record ID
+
+4. **Selective invalidation**: The Nuxt endpoint validates the JWT and uses `useStorage("cache")` to remove only cache entries matching the changed table and record ID. Backup events trigger a full cache clear
+
+5. **Next request**: Subsequent requests fetch fresh data and repopulate the cache
+
+## Pros and Cons
+
+### Pros
+
+- ⚡ **Performance**: Cached responses are served instantly without hitting the database on each request
+- 📉 **Reduced backend load**: Fewer API calls to PocketBase, lowering server resource usage
+- 🔄 **Fresh data on demand**: Cache is invalidated only when data actually changes, avoiding stale content
+- 🚀 **Scalability**: SWR (stale-while-revalidate) serves cached content while refreshing in the background, keeping response times low under high traffic
+
+### Cons
+
+- 🔗 **Tight coupling**: The backend must know the frontend URL and send webhooks, creating a dependency between services
+- 🌐 **Network reliability**: If the webhook fails to reach Nuxt (network issues, downtime), the cache won't be invalidated and stale data persists
+- 🖥️ **Single-server limitation**: Cache is stored in-memory/local storage, so this approach doesn't work well with multi-instance deployments without a shared cache layer (e.g., Redis)
+- ⚙️ **Complexity**: Requires configuring JWT secrets, environment variables, and ensuring both services are running and communicating correctly

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nurev",
-  "version": "0.0.9",
+  "version": "0.1.0",
   "module": "index.js",
   "dependencies": {
     "bcrypt": "^6.0.0",

package/templates/base/frontend/server/plugins/pocketbase.ts

@@ -7,7 +7,10 @@ export default defineNitroPlugin(async (nitroApp) => {
   try {
     await pb
       .collection("users")
-      .authWithPassword(config.pocketbaseUser, config.pocketbasePassword);
+      .authWithPassword(
+        config.pocketbaseUser,
+        config.pocketbasePassword.toString(),
+      );
 
     nitroApp.hooks.hook("request", (event) => {
       event.context.pocketbase = pb;

package/templates/pocketbase/.env.example

@@ -1,7 +1,7 @@
 TABLES_TRIGGER=posts
 JWT_EXPIRES_MINUTES=1
 FRONTEND_URL=http://localhost:3000/api/private/reloadcache
-NUXT_POCKETBASE_URL=https://localhost:8090
+NUXT_POCKETBASE_URL=http://localhost:8090
 NUXT_POCKETBASE_USER=
 NUXT_POCKETBASE_PASSWORD=
 NUXT_JWT_SECRET=

package/templates/pocketbase/README.md

@@ -53,20 +53,20 @@ Tech stack:
 make backend-dev
 ```
 
-3. Create a collection named `posts` and change API Rules for give permissions with `@request.auth.id != ""`
-
-4. Create a new post
-
-5. Start frontend dev mode
+3. Start frontend dev mode
 
 ```bash
 make frontend-dev
 ```
 
-6. Open `http://localhost:3000/posts/[id]` and replace `[id]` with the post id created in the 6. step
+4. Copy a post ID from the `posts` collection
+
+5. Open `http://localhost:3000/posts/[id]` and replace `[id]` with the copied post ID
+
+6. Verify caching by checking the `ETag` header in the response (Network tab in browser dev tools). The `ETag` will change when you modify post records or create a backup
 
-## Build
+## More commands
 
 ```bash
-make build
+make help
 ```

package/templates/pocketbase-bun/Makefile

@@ -38,19 +38,19 @@ frontend-setup:
 	
 frontend-install:
 	@echo "Installing frontend dependencies..."
-	cd frontend && bun --bun install
+	cd frontend && bun install
 
 frontend-dev: frontend-install
 	@echo "Starting frontend development server..."
-	cd frontend && bun --bun run dev
+	cd frontend && bun run dev
 
 frontend-build: frontend-install
 	@echo "Building frontend for production..."
-	cd frontend && bun --bun run build
+	cd frontend && bun run build
 
 frontend-preview: frontend-build
 	@echo "Previewing frontend production build..."
-	cd frontend && bun --bun run preview
+	cd frontend && bun run preview
 
 install: backend-update frontend-install
 	@echo "Dependencies installed"

package/utils/sqlite.js

@@ -9,7 +9,7 @@ export class SQLiteManager {
     return new Promise(async (resolve, reject) => {
       try {
         this.db.exec(
-          `CREATE TABLE IF NOT EXIST ${name} (${params.toString()})`,
+          `CREATE TABLE IF NOT EXISTS ${name} (${params.toString()})`,
         );
         resolve();
       } catch (error) {

package/workflows/pocketbase/index.js

@@ -77,7 +77,32 @@ export function setup(paths) {
 
       console.log(`\nUser API created\n`);
 
-      //TODO: POSTS TABLE
+      await db.insert("_collections", {
+        created: `'${date}'`,
+        fields: `'[{"autogeneratePattern":"[a-z0-9]{15}","hidden":false,"id":"text3208210256","max":15,"min":15,"name":"id","pattern":"^[a-z0-9]+$","presentable":false,"primaryKey":true,"required":true,"system":true,"type":"text"},{"hidden":false,"id":"autodate2990389176","name":"created","onCreate":true,"onUpdate":false,"presentable":false,"system":false,"type":"autodate"},{"hidden":false,"id":"autodate3332085495","name":"updated","onCreate":true,"onUpdate":true,"presentable":false,"system":false,"type":"autodate"}]'`,
+        indexes: `'[]'`,
+        name: `'posts'`,
+        options: `'{}'`,
+        system: false,
+        updated: `'${date}'`,
+        type: `'base'`,
+        listRule: `'@request.auth.id != ""'`,
+        viewRule: `'@request.auth.id != ""'`,
+      });
+
+      await db.create("posts", [
+        `created TEXT DEFAULT '' NOT NULL`,
+        `id TEXT PRIMARY KEY DEFAULT ('r'||lower(hex(randomblob(7)))) NOT NULL`,
+        `updated TEXT DEFAULT '' NOT NULL`,
+      ]);
+
+      await db.insert("posts", {
+        created: `'${date}'`,
+        updated: `'${date}'`,
+      });
+
+      console.log(`\nPosts example created\n`);
+
       resolve();
     } catch (error) {
       reject(error);