rwsdk 0.0.79-test.20250506144558

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RedwoodJS Inc
+
+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.

package/README.md

@@ -0,0 +1,7 @@
+# RedwoodSDK
+
+RedwoodSDK is a composable framework for building server-driven webapps on Cloudflare. It starts as a **Vite plugin** that unlocks **SSR**, **React Server Components**, **Server Functions**, and **realtime**. Its standards-based router—with middleware and interruptors—gives you precise control over every request and response. With built-in access to Cloudflare’s Workers, Database (D1), Storage (R2), Queues, and AI—and full local emulation via Miniflare—development feels just like production.
+
+→ [Quick start](https://docs.rwsdk.com/getting-started/quick-start/)
+→ [Docs](https://docs.rwsdk.com/)
+→ [Discord](https://discord.gg/redwoodjs)

package/bin/rw-scripts.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { $ as $base } from "execa";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const ROOT_DIR = path.resolve(__dirname, "..");
+const BIN_DIR = path.resolve(ROOT_DIR, "node_modules", ".bin");
+
+const ARGS = process.argv.slice(2);
+const SCRIPT_NAME = ARGS[0];
+
+const $ = $base({
+  shell: true,
+  stdio: "inherit",
+  reject: false,
+  env: {
+    PATH: `${process.env.PATH}:${BIN_DIR}`,
+  },
+});
+
+const main = async () => {
+  const result =
+    await $`node ${path.resolve(ROOT_DIR, "dist", "scripts", SCRIPT_NAME)}.mjs ${ARGS.slice(1).join(" ")}`;
+
+  process.exitCode = result.exitCode;
+};
+
+main();

package/dist/lib/$.d.mts

@@ -0,0 +1,8 @@
+export declare const $: import("execa").ExecaScriptMethod<{
+    stdio: "inherit" | "pipe";
+}>;
+export declare const $sh: import("execa").ExecaScriptMethod<{
+    stdio: "inherit" | "pipe";
+} & {
+    shell: true;
+}>;

package/dist/lib/$.mjs

@@ -0,0 +1,5 @@
+import { $ as base } from "execa";
+export const $ = base({
+    stdio: process.env.VERBOSE || process.env.CI ? "inherit" : "pipe",
+});
+export const $sh = $({ shell: true });

package/dist/lib/compileTsModule.d.mts

@@ -0,0 +1 @@
+export declare const compileTsModule: (tsCode: string) => string;

package/dist/lib/compileTsModule.mjs

@@ -0,0 +1,27 @@
+import ts from "typescript";
+import path from "path";
+export const compileTsModule = (tsCode) => {
+    const tsConfigPath = "./tsconfig.json";
+    // Find the nearest tsconfig.json
+    const configPath = ts.findConfigFile(path.dirname(tsConfigPath), ts.sys.fileExists, path.basename(tsConfigPath));
+    if (!configPath) {
+        throw new Error(`Could not find a valid tsconfig.json at path: ${tsConfigPath}`);
+    }
+    // Read and parse tsconfig.json
+    const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (configFile.error) {
+        throw new Error(`Error reading tsconfig.json: ${ts.formatDiagnostic(configFile.error, ts.createCompilerHost({}))}`);
+    }
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
+    const compilerOptions = parsedConfig.options;
+    // Transpile the TypeScript code using the compiler options
+    const output = ts.transpileModule(tsCode, {
+        compilerOptions,
+        reportDiagnostics: true,
+    });
+    if (output.diagnostics && output.diagnostics.length) {
+        const diagnosticMessages = output.diagnostics.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+        throw new Error(`TypeScript Compilation Errors:\n${diagnosticMessages.join("\n")}`);
+    }
+    return output.outputText; // Compiled JavaScript code
+};

package/dist/lib/constants.d.mts

@@ -0,0 +1,7 @@
+export declare const ROOT_DIR: string;
+export declare const SRC_DIR: string;
+export declare const DIST_DIR: string;
+export declare const VENDOR_ROOT_DIR: string;
+export declare const VENDOR_SRC_DIR: string;
+export declare const VENDOR_DIST_DIR: string;
+export declare const VENDOR_REACT_SSR_PATH: string;

package/dist/lib/constants.mjs

@@ -0,0 +1,9 @@
+import { resolve } from "node:path";
+const __dirname = new URL(".", import.meta.url).pathname;
+export const ROOT_DIR = resolve(__dirname, "..", "..");
+export const SRC_DIR = resolve(ROOT_DIR, "src");
+export const DIST_DIR = resolve(ROOT_DIR, "dist");
+export const VENDOR_ROOT_DIR = resolve(ROOT_DIR, "vendor");
+export const VENDOR_SRC_DIR = resolve(VENDOR_ROOT_DIR, "src");
+export const VENDOR_DIST_DIR = resolve(VENDOR_ROOT_DIR, "dist");
+export const VENDOR_REACT_SSR_PATH = resolve(VENDOR_DIST_DIR, "react-ssr.js");

package/dist/lib/findWranglerConfig.d.mts

@@ -0,0 +1 @@
+export declare const findWranglerConfig: (projectRootDir: string) => Promise<string>;

package/dist/lib/findWranglerConfig.mjs

@@ -0,0 +1,12 @@
+import { pathExists } from "fs-extra";
+import { resolve } from "path";
+export const findWranglerConfig = async (projectRootDir) => {
+    const configFiles = ["wrangler.jsonc", "wrangler.json", "wrangler.toml"];
+    for (const file of configFiles) {
+        const fullPath = resolve(projectRootDir, file);
+        if (await pathExists(fullPath)) {
+            return fullPath;
+        }
+    }
+    throw new Error("No wrangler configuration file found.");
+};

package/dist/lib/getShortName.d.mts

@@ -0,0 +1 @@
+export declare const getShortName: (file: string, root: string) => string;

package/dist/lib/getShortName.mjs

@@ -0,0 +1,2 @@
+import { relative } from "node:path";
+export const getShortName = (file, root) => file.startsWith(root) ? relative(root, file) : file;

package/dist/lib/setupEnvFiles.d.mts

@@ -0,0 +1,4 @@
+export type EnvSetupOptions = {
+    rootDir: string;
+};
+export declare function setupEnvFiles({ rootDir, }: EnvSetupOptions): Promise<void>;

package/dist/lib/setupEnvFiles.mjs

@@ -0,0 +1,31 @@
+import { resolve } from "node:path";
+import { symlink, copyFile } from "node:fs/promises";
+import { pathExists } from "fs-extra";
+export async function setupEnvFiles({ rootDir, }) {
+    const envPath = resolve(rootDir, ".env");
+    const devVarsPath = resolve(rootDir, ".dev.vars");
+    const envExamplePath = resolve(rootDir, ".env.example");
+    const envExists = await pathExists(envPath);
+    const devVarsExists = await pathExists(devVarsPath);
+    const envExampleExists = await pathExists(envExamplePath);
+    // If .env.example exists but .env doesn't, copy from example to .env
+    if (!envExists && !devVarsExists && envExampleExists) {
+        try {
+            await copyFile(envExamplePath, envPath);
+            console.log("Created .env file from .env.example");
+        }
+        catch (error) {
+            console.warn("Failed to copy .env.example to .env:", error);
+        }
+    }
+    // Create symlink from .env to .dev.vars if needed
+    if ((await pathExists(envPath)) && !devVarsExists) {
+        try {
+            await symlink(envPath, devVarsPath);
+            console.log("Created symlink from .env to .dev.vars");
+        }
+        catch (error) {
+            console.warn("Failed to create symlink from .env to .dev.vars:", error);
+        }
+    }
+}

package/dist/llms/index.d.ts

@@ -0,0 +1,3 @@
+import type { PackageRuleItem } from "vibe-rules";
+declare const rules: PackageRuleItem[];
+export default rules;

package/dist/llms/index.js

@@ -0,0 +1,35 @@
+import { interruptors } from "./rules/interruptors.js";
+import { middleware } from "./rules/middleware.js";
+import { react } from "./rules/react.js";
+import { requestResponse } from "./rules/request-response.js";
+const rules = [
+    {
+        name: "rwsdk-interruptors",
+        description: "RedwoodSDK: Request Interruptors",
+        rule: interruptors,
+        alwaysApply: false,
+        globs: ["worker.tsx", "src/app/**/routes.ts", "src/app/**/*/routes.ts"],
+    },
+    {
+        name: "rwsdk-middleware",
+        description: "RedwoodSDK: Middleware",
+        rule: middleware,
+        alwaysApply: false,
+        globs: ["worker.tsx", "middleware.ts", "middleware.tsx"],
+    },
+    {
+        name: "rwsdk-react",
+        description: "RedwoodSDK: React, React Server Components, and React Server Functions Rules",
+        rule: react,
+        alwaysApply: false,
+        globs: ["src/app/**/*/*.tsx", "Document.tsx"],
+    },
+    {
+        name: "rwsdk-request-response",
+        description: "RedwoodSDK: Request handling and responses",
+        rule: requestResponse,
+        alwaysApply: false,
+        globs: ["worker.tsc", "src/app/**/routes.ts", "src/app/**/*/routes.ts"],
+    },
+];
+export default rules;

package/dist/llms/rules/interruptors.d.ts

@@ -0,0 +1 @@
+export declare const interruptors = "\n\n# RedwoodSDK: Request Interruptors\n\nYou're an expert at Cloudflare, TypeScript, and building web apps with RedwoodSDK. Generate high quality **RedwoodSDK interruptors** (middleware functions) that adhere to the following best practices:\n\n## Guidelines\n\n1. Create focused, single-responsibility interruptors\n2. Organize interruptors in dedicated files (e.g., `interruptors.ts`, `interceptors.ts`, or `middleware.ts`)\n3. Compose interruptors to create more complex validation chains\n4. Use typed parameters and return values\n5. Include clear error handling and user feedback\n\n## What are Interruptors?\n\nInterruptors are middleware functions that run before your route handlers. They can:\n\n- Validate user authentication and authorization\n- Transform request data\n- Validate inputs\n- Rate limit requests\n- Log activity\n- Redirect users based on conditions\n- Short-circuit request handling with early responses\n\n## Example Templates\n\n### Basic Interruptor Structure\n\n```tsx\nasync function myInterruptor({ request, params, ctx }) {\n  // Perform checks or transformations here\n\n  // Return modified context to pass to the next interruptor or handler\n  ctx.someAddedData = \"value\";\n\n  // OR return a Response to short-circuit the request\n  // return new Response('Unauthorized', { status: 401 });\n}\n```\n\n### Authentication Interruptors\n\n```tsx\nexport async function requireAuth({ request, ctx }) {\n  if (!ctx.user) {\n    return new Response(null, {\n      status: 302,\n      headers: { Location: \"/user/login\" },\n    });\n  }\n}\n\nexport async function requireAdmin({ request, ctx }) {\n  if (!ctx?.user?.isAdmin) {\n    return new Response(null, {\n      status: 302,\n      headers: { Location: \"/user/login\" },\n    });\n  }\n}\n```\n\n### Input Validation Interruptor\n\n```tsx\nimport { z } from \"zod\";\n\n// Create a reusable validator interruptor\nexport function validateInput(schema) {\n  return async function validateInputInterruptor({ request, ctx }) {\n    try {\n      const data = await request.json();\n      const validated = (ctx.data = schema.parse(data));\n    } catch (error) {\n      return Response.json(\n        { error: \"Validation failed\", details: error.errors },\n        { status: 400 },\n      );\n    }\n  };\n}\n\n// Usage example with a Zod schema\nconst userSchema = z.object({\n  name: z.string().min(2),\n  email: z.string().email(),\n  age: z.number().min(18).optional(),\n});\n\nexport const validateUser = validateInput(userSchema);\n```\n\n### Logging Interruptor\n\n```tsx\nexport async function logRequests({ request, ctx }) {\n  const start = Date.now();\n\n  // Add a function to the context that will log when called\n  ctx.logCompletion: (response) => {\n      const duration = Date.now() - start;\n      const status = response.status;\n      console.log(\n        `${request.method} ${request.url} - ${status} (${duration}ms)`,\n      );\n    },\n  };\n}\n\n// Usage in a route handler\nroute('/', [\n  logRequests,\n  async ({request, ctx}) => {\n    // Call the logging function\n    ctx.logCompletion(response);\n    return Response.json({ success: true });;\n  },\n]);\n```\n\n### Composing Multiple Interruptors\n\n```tsx\nimport { route } from \"rwsdk/router\";\nimport {\n  requireAuth,\n  validateUser,\n  apiRateLimit,\n  logRequests,\n} from \"@/app/interruptors\";\n\n// Combine multiple interruptors\nroute(\"/api/users\", [\n    logRequests, // Log all requests\n    requireAuth, // Ensure user is authenticated\n    validateUser, // Validate user input\n    async ({ request, ctx }) => {\n      // Handler receives validated data and session from interruptors\n      const newUser = await db.user.create({\n        data: {\n          /* ... */,\n          createdBy: ctx.user.userId,\n        },\n      });\n\n      return Response.json(newUser, { status: 201 });\n    },\n  ],\n});\n```\n\n### Role-Based Access Control\n\n```tsx\nimport { getSession } from \"rwsdk/auth\";\n\n// Create a function that generates role-based interruptors\nexport function hasRole(allowedRoles) {\n  return async function hasRoleInterruptor({ request, ctx }) {\n    const session = await getSession(request);\n\n    if (!session) {\n      return Response.redirect(\"/login\");\n    }\n\n    if (!allowedRoles.includes(session.role)) {\n      return Response.json({ error: \"Unauthorized\" }, { status: 403 });\n    }\n\n    return { ...ctx, session };\n  };\n}\n\n// Create specific role-based interruptors\nexport const isAdmin = hasRole([\"ADMIN\"]);\nexport const isEditor = hasRole([\"ADMIN\", \"EDITOR\"]);\nexport const isUser = hasRole([\"ADMIN\", \"EDITOR\", \"USER\"]);\n```\n\n### Organization with Co-located Interruptors\n\nCreate a file at `./src/app/interruptors.ts`:\n\n```tsx\nimport { getSession } from \"rwsdk/auth\";\n\n// Authentication interruptors\nexport async function requireAuth({ request, ctx }) {\n  const session = await getSession(request);\n\n  if (!session) {\n    return Response.redirect(\"/login\");\n  }\n\n  return { ...ctx, session };\n}\n\n// Role-based interruptors\nexport function hasRole(allowedRoles) {\n  return async function hasRoleInterruptor({ request, ctx }) {\n    const session = await getSession(request);\n\n    if (!session) {\n      return Response.redirect(\"/login\");\n    }\n\n    if (!allowedRoles.includes(session.role)) {\n      return Response.json({ error: \"Unauthorized\" }, { status: 403 });\n    }\n\n    return { ...ctx, session };\n  };\n}\n\nexport const isAdmin = hasRole([\"ADMIN\"]);\nexport const isEditor = hasRole([\"ADMIN\", \"EDITOR\"]);\n\n// Other common interruptors\nexport async function logRequests({ request, ctx }) {\n  console.log(`${request.method} ${request.url}`);\n  return ctx;\n}\n```\n\nThen import these interruptors in your route files:\n\n```tsx\n// src/app/pages/admin/routes.ts\nimport { route } from \"rwsdk/router\";\nimport { isAdmin, logRequests } from \"@/app/interruptors\";\n\nimport { AdminDashboard } from \"./AdminDashboard\";\nimport { UserManagement } from \"./UserManagement\";\n\nexport const routes = [\n  route(\"/\", [isAdmin, logRequests, AdminDashboard]),\n  route(\"/users\", [isAdmin, logRequests, UserManagement]),\n];\n```\n\n";

package/dist/llms/rules/interruptors.js

@@ -0,0 +1,243 @@
+export const interruptors = `
+
+# RedwoodSDK: Request Interruptors
+
+You're an expert at Cloudflare, TypeScript, and building web apps with RedwoodSDK. Generate high quality **RedwoodSDK interruptors** (middleware functions) that adhere to the following best practices:
+
+## Guidelines
+
+1. Create focused, single-responsibility interruptors
+2. Organize interruptors in dedicated files (e.g., \`interruptors.ts\`, \`interceptors.ts\`, or \`middleware.ts\`)
+3. Compose interruptors to create more complex validation chains
+4. Use typed parameters and return values
+5. Include clear error handling and user feedback
+
+## What are Interruptors?
+
+Interruptors are middleware functions that run before your route handlers. They can:
+
+- Validate user authentication and authorization
+- Transform request data
+- Validate inputs
+- Rate limit requests
+- Log activity
+- Redirect users based on conditions
+- Short-circuit request handling with early responses
+
+## Example Templates
+
+### Basic Interruptor Structure
+
+\`\`\`tsx
+async function myInterruptor({ request, params, ctx }) {
+  // Perform checks or transformations here
+
+  // Return modified context to pass to the next interruptor or handler
+  ctx.someAddedData = "value";
+
+  // OR return a Response to short-circuit the request
+  // return new Response('Unauthorized', { status: 401 });
+}
+\`\`\`
+
+### Authentication Interruptors
+
+\`\`\`tsx
+export async function requireAuth({ request, ctx }) {
+  if (!ctx.user) {
+    return new Response(null, {
+      status: 302,
+      headers: { Location: "/user/login" },
+    });
+  }
+}
+
+export async function requireAdmin({ request, ctx }) {
+  if (!ctx?.user?.isAdmin) {
+    return new Response(null, {
+      status: 302,
+      headers: { Location: "/user/login" },
+    });
+  }
+}
+\`\`\`
+
+### Input Validation Interruptor
+
+\`\`\`tsx
+import { z } from "zod";
+
+// Create a reusable validator interruptor
+export function validateInput(schema) {
+  return async function validateInputInterruptor({ request, ctx }) {
+    try {
+      const data = await request.json();
+      const validated = (ctx.data = schema.parse(data));
+    } catch (error) {
+      return Response.json(
+        { error: "Validation failed", details: error.errors },
+        { status: 400 },
+      );
+    }
+  };
+}
+
+// Usage example with a Zod schema
+const userSchema = z.object({
+  name: z.string().min(2),
+  email: z.string().email(),
+  age: z.number().min(18).optional(),
+});
+
+export const validateUser = validateInput(userSchema);
+\`\`\`
+
+### Logging Interruptor
+
+\`\`\`tsx
+export async function logRequests({ request, ctx }) {
+  const start = Date.now();
+
+  // Add a function to the context that will log when called
+  ctx.logCompletion: (response) => {
+      const duration = Date.now() - start;
+      const status = response.status;
+      console.log(
+        \`\${request.method} \${request.url} - \${status} (\${duration}ms)\`,
+      );
+    },
+  };
+}
+
+// Usage in a route handler
+route('/', [
+  logRequests,
+  async ({request, ctx}) => {
+    // Call the logging function
+    ctx.logCompletion(response);
+    return Response.json({ success: true });;
+  },
+]);
+\`\`\`
+
+### Composing Multiple Interruptors
+
+\`\`\`tsx
+import { route } from "rwsdk/router";
+import {
+  requireAuth,
+  validateUser,
+  apiRateLimit,
+  logRequests,
+} from "@/app/interruptors";
+
+// Combine multiple interruptors
+route("/api/users", [
+    logRequests, // Log all requests
+    requireAuth, // Ensure user is authenticated
+    validateUser, // Validate user input
+    async ({ request, ctx }) => {
+      // Handler receives validated data and session from interruptors
+      const newUser = await db.user.create({
+        data: {
+          /* ... */,
+          createdBy: ctx.user.userId,
+        },
+      });
+
+      return Response.json(newUser, { status: 201 });
+    },
+  ],
+});
+\`\`\`
+
+### Role-Based Access Control
+
+\`\`\`tsx
+import { getSession } from "rwsdk/auth";
+
+// Create a function that generates role-based interruptors
+export function hasRole(allowedRoles) {
+  return async function hasRoleInterruptor({ request, ctx }) {
+    const session = await getSession(request);
+
+    if (!session) {
+      return Response.redirect("/login");
+    }
+
+    if (!allowedRoles.includes(session.role)) {
+      return Response.json({ error: "Unauthorized" }, { status: 403 });
+    }
+
+    return { ...ctx, session };
+  };
+}
+
+// Create specific role-based interruptors
+export const isAdmin = hasRole(["ADMIN"]);
+export const isEditor = hasRole(["ADMIN", "EDITOR"]);
+export const isUser = hasRole(["ADMIN", "EDITOR", "USER"]);
+\`\`\`
+
+### Organization with Co-located Interruptors
+
+Create a file at \`./src/app/interruptors.ts\`:
+
+\`\`\`tsx
+import { getSession } from "rwsdk/auth";
+
+// Authentication interruptors
+export async function requireAuth({ request, ctx }) {
+  const session = await getSession(request);
+
+  if (!session) {
+    return Response.redirect("/login");
+  }
+
+  return { ...ctx, session };
+}
+
+// Role-based interruptors
+export function hasRole(allowedRoles) {
+  return async function hasRoleInterruptor({ request, ctx }) {
+    const session = await getSession(request);
+
+    if (!session) {
+      return Response.redirect("/login");
+    }
+
+    if (!allowedRoles.includes(session.role)) {
+      return Response.json({ error: "Unauthorized" }, { status: 403 });
+    }
+
+    return { ...ctx, session };
+  };
+}
+
+export const isAdmin = hasRole(["ADMIN"]);
+export const isEditor = hasRole(["ADMIN", "EDITOR"]);
+
+// Other common interruptors
+export async function logRequests({ request, ctx }) {
+  console.log(\`\${request.method} \${request.url}\`);
+  return ctx;
+}
+\`\`\`
+
+Then import these interruptors in your route files:
+
+\`\`\`tsx
+// src/app/pages/admin/routes.ts
+import { route } from "rwsdk/router";
+import { isAdmin, logRequests } from "@/app/interruptors";
+
+import { AdminDashboard } from "./AdminDashboard";
+import { UserManagement } from "./UserManagement";
+
+export const routes = [
+  route("/", [isAdmin, logRequests, AdminDashboard]),
+  route("/users", [isAdmin, logRequests, UserManagement]),
+];
+\`\`\`
+
+`;

package/dist/llms/rules/middleware.d.ts

@@ -0,0 +1 @@
+export declare const middleware = "\n\n# RedwoodSDK: Middleware\n\nYou're an expert at Cloudflare, TypeScript, and building web apps with RedwoodSDK. Generate high quality **RedwoodSDK middleware** that adhere to the following best practices:\n\n## Guidelines\n\n1. Create focused, single-responsibility middleware functions\n2. Organize middleware in dedicated files (e.g., `middleware.ts`, `middleware.tsx`)\n3. Use typed parameters and return values\n4. Include clear error handling and logging\n5. Follow the principle of least privilege\n6. Implement proper security headers and CORS policies\n7. Optimize for performance with caching strategies\n\n## What is Middleware?\n\nMiddleware functions in RedwoodSDK are functions that run on every request before your route handlers. They can:\n\n- Add security headers\n- Handle CORS\n- Implement caching strategies\n- Add request/response logging\n- Transform request/response data\n- Implement rate limiting\n- Add performance monitoring\n- Handle error boundaries\n- Setup sessions\n- Authenticate users\n\n## Example Templates\n\n### Basic Middleware Structure\n\n```tsx\nexport default defineApp([\n  setCommonHeaders(),\n  async ({ ctx, request, headers }) => {\n    await setupDb(env);\n    setupSessionStore(env);\n    try {\n      // Grab the session's data.\n      ctx.session = await sessions.load(request);\n    } catch (error) {\n      if (error instanceof ErrorResponse && error.code === 401) {\n        await sessions.remove(request, headers);\n        headers.set(\"Location\", \"/user/login\");\n\n        return new Response(null, {\n          status: 302,\n          headers,\n        });\n      }\n\n      throw error;\n    }\n\n    // Populate the ctx with the user's data\n    if (ctx.session?.userId) {\n      ctx.user = await db.user.findUnique({\n        where: {\n          id: ctx.session.userId,\n        },\n      });\n    }\n  },\n  // Route handlers\n]);\n```\n";

package/dist/llms/rules/middleware.js

@@ -0,0 +1,71 @@
+export const middleware = `
+
+# RedwoodSDK: Middleware
+
+You're an expert at Cloudflare, TypeScript, and building web apps with RedwoodSDK. Generate high quality **RedwoodSDK middleware** that adhere to the following best practices:
+
+## Guidelines
+
+1. Create focused, single-responsibility middleware functions
+2. Organize middleware in dedicated files (e.g., \`middleware.ts\`, \`middleware.tsx\`)
+3. Use typed parameters and return values
+4. Include clear error handling and logging
+5. Follow the principle of least privilege
+6. Implement proper security headers and CORS policies
+7. Optimize for performance with caching strategies
+
+## What is Middleware?
+
+Middleware functions in RedwoodSDK are functions that run on every request before your route handlers. They can:
+
+- Add security headers
+- Handle CORS
+- Implement caching strategies
+- Add request/response logging
+- Transform request/response data
+- Implement rate limiting
+- Add performance monitoring
+- Handle error boundaries
+- Setup sessions
+- Authenticate users
+
+## Example Templates
+
+### Basic Middleware Structure
+
+\`\`\`tsx
+export default defineApp([
+  setCommonHeaders(),
+  async ({ ctx, request, headers }) => {
+    await setupDb(env);
+    setupSessionStore(env);
+    try {
+      // Grab the session's data.
+      ctx.session = await sessions.load(request);
+    } catch (error) {
+      if (error instanceof ErrorResponse && error.code === 401) {
+        await sessions.remove(request, headers);
+        headers.set("Location", "/user/login");
+
+        return new Response(null, {
+          status: 302,
+          headers,
+        });
+      }
+
+      throw error;
+    }
+
+    // Populate the ctx with the user's data
+    if (ctx.session?.userId) {
+      ctx.user = await db.user.findUnique({
+        where: {
+          id: ctx.session.userId,
+        },
+      });
+    }
+  },
+  // Route handlers
+]);
+\`\`\`
+`;

package/dist/llms/rules/react.d.ts

@@ -0,0 +1 @@
+export declare const react = "\n# React, React Server Components, and React Server Functions Rules\n\n## React Server Components (RSC)\n\n1. By default, all components are server components unless explicitly marked as client components.\n2. Server components are rendered on the server as HTML and streamed to the browser.\n3. Server components cannot include client-side interactivity (state, effects, event handlers).\n4. Server components can directly fetch data and include it in the initial payload.\n5. Server components can be async and can be wrapped in Suspense boundaries.\n\nExample:\n\n```tsx\nexport default function MyServerComponent() {\n  return <div>Hello, from the server!</div>;\n}\n```\n\n## Client Components\n\n1. Must be explicitly marked with the \"use client\" directive at the top of the file.\n2. Required when the component needs:\n   - Interactivity (click handlers, state management)\n   - Browser APIs\n   - Event listeners\n   - Client-side effects\n   - Client-side routing\n3. Will be hydrated by React in the browser.\n\nExample:\n\n```tsx\n\"use client\";\n\nexport default function MyClientComponent() {\n  return <button onClick={() => console.log(\"clicked\")}>Click me</button>;\n}\n```\n\n## Data Fetching in Server Components\n\n1. Server components can directly fetch data without useEffect or other client-side data fetching methods.\n2. Use Suspense boundaries to handle loading states for async server components.\n3. Pass context (ctx) through props to child components that need it.\n\nExample:\n\n```tsx\nexport async function TodoList({ ctx }) {\n  const todos = await db.todo.findMany({ where: { userId: ctx.user.id } });\n\n  return (\n    <ol>\n      {todos.map((todo) => (\n        <li key={todo.id}>{todo.title}</li>\n      ))}\n    </ol>\n  );\n}\n```\n\n## Server Functions\n\n1. Must be marked with the \"use server\" directive at the top of the file.\n2. Can be imported and used in client components.\n3. Execute on the server when called from client components.\n4. Have access to the request context via requestInfo.ctx.\n5. Can handle form submissions and other server-side operations.\n\nExample:\n\n```tsx\n\"use server\";\n\nimport { requestInfo } from \"rwsdk/worker\";\n\nexport async function addTodo(formData: FormData) {\n  const { ctx } = requestInfo;\n  const title = formData.get(\"title\");\n  await db.todo.create({ data: { title, userId: ctx.user.id } });\n}\n```\n\n## Context Usage\n\n1. Context is available to all server components and server functions.\n2. Access context via:\n   - requestInfo in server functions:\n   ```\n   import { requestInfo } from \"rwsdk/worker\";\n   const { ctx } = requestInfo\n   ```\n3. Context is populated by middleware and interruptors and is request-scoped.\n\n## Best Practices\n\n1. Keep server components as the default choice unless client-side interactivity is needed.\n2. Use client components only when necessary to minimize the JavaScript bundle size.\n3. Leverage server components for data fetching and initial rendering.\n4. Use Suspense boundaries appropriately for loading states.\n5. Keep client components as small as possible, moving server-side logic to server components or server functions.\n6. Always mark client components with \"use client\" directive.\n7. Always mark server functions with \"use server\" directive.\n\n";