kilo-cms 0.1.0 → 0.2.0

package/README.md

@@ -135,6 +135,33 @@ import '@/lib/db'
 export { GET, PUT } from 'kilo-cms/routes/admin/dashboard'
 ```
 
+### Middleware
+
+Kilo CMS ships an Edge-safe, cookie-presence-only pre-filter that redirects unauthenticated
+visitors away from `/admin/*` before a page even renders — a fast filter, not the real
+security boundary (every admin page/route still validates the session and RBAC permissions
+for real). Your own `middleware.ts` re-exports it and defines `matcher` itself (Next.js
+statically analyzes `matcher` in the file it scans — it can't be re-exported through another
+module):
+
+```ts
+// middleware.ts
+export { kiloAdminMiddleware as middleware } from 'kilo-cms/middleware'
+
+export const config = {
+  matcher: ['/admin/:path*'],
+}
+```
+
+Admin pages use `requireAdminSession()` from `kilo-cms/admin/require-session` instead of
+hand-rolling `getSessionWithPermissions()` + `redirect()`:
+
+```ts
+import { requireAdminSession } from 'kilo-cms/admin/require-session'
+
+const result = await requireAdminSession((r) => r.can('projects', 'read'), '/admin/dashboard')
+```
+
 ## CLI
 
 Run from your own app's directory:
@@ -143,6 +170,7 @@ Run from your own app's directory:
 npx kilo-cms add-collection <slug>   # scaffold a new collection's fields.ts + table.ts
 npx kilo-cms sync                    # regenerate .kilo/types.gen.ts from src/collections/*
 npx kilo-cms migrate                 # apply Kilo CMS's own package-owned migrations
+npx kilo-cms init                    # migrate, then create the first admin user
 ```
 
 `add-collection` scaffolds the two files and prints the exact lines to paste into
@@ -154,6 +182,14 @@ locales — see `src/schema/`) against your `DATABASE_URL`, tracked in its own
 `kilo_cms_migrations` table, independent of your own app's migration history for its content
 tables.
 
+`init` runs `migrate`, then creates your first admin user via the existing
+`/api/setup/admin` route — it needs your app already running (`npm run dev` in another
+terminal) since that route executes inside your app's own Next.js runtime:
+
+```sh
+CMS_SETUP_TOKEN=... npx kilo-cms init --name "Your Name" --email you@example.com --password "at least 12 characters" [--url http://localhost:3000]
+```
+
 ## Package layout
 
 | Export | What it is |
@@ -165,6 +201,8 @@ tables.
 | `kilo-cms/schema` | Kilo CMS's own drizzle tables (auth, RBAC, media, settings, dev-tools, admin-ui, locales) |
 | `kilo-cms/auth`, `kilo-cms/auth-client` | `createKiloAuth()` factory + the better-auth React client |
 | `kilo-cms/admin/*` | Admin UI pages and shared components |
+| `kilo-cms/admin/require-session` | `requireAdminSession()` — the shared session/RBAC guard for admin pages |
+| `kilo-cms/middleware` | `kiloAdminMiddleware` — Edge-safe cookie-presence pre-filter for `/admin/*` |
 | `kilo-cms/routes/*` | Route Handler logic for the admin API, public API helpers, auth, cron |
 
 ## Status / roadmap
@@ -173,10 +211,9 @@ Built by extracting a working, in-production CMS out of the app it was originall
 in — see [`the-usual-dev`'s `WORKLOG.md`](https://github.com/revaldyas/the-usual-dev) for the
 full history of that extraction. Not yet done:
 
-- Centralized auth middleware (every admin page currently does its own session check).
-- A single catch-all admin route instead of one thin file per page.
-- An interactive `kilo-cms init` (migrate + seed settings + create the first admin user in one
-  command).
+- A single catch-all admin route instead of one thin file per page (deliberately skipped for
+  now — today's thin per-page files are already minimal; a hand-rolled catch-all router would
+  trade that for real complexity with no proven need yet).
 - A second, independent consumer project to prove the install story beyond the one app this
   was extracted from.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kilo-cms",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "An installable, config-driven CMS engine for Next.js — admin panel, RBAC, a generic field-type engine, and an API, mounted into your own app. Define your content schema via config, not a hand-maintained registry.",
   "keywords": [
     "cms",
@@ -39,6 +39,8 @@
     "./dashboard": "./src/dashboard.ts",
     "./routes/admin/*": "./src/routes/admin/*/route.ts",
     "./routes/*": "./src/routes/*.ts",
+    "./middleware": "./src/middleware.ts",
+    "./admin/require-session": "./src/admin/require-session.ts",
     "./admin/*": "./src/admin/*.tsx",
     "./admin.css": "./src/admin/admin.css",
     "./globals.css": "./src/admin/globals.css"
@@ -78,7 +80,9 @@
     "nodemailer": "^10.0.9",
     "react-easy-crop": "^6.2.3",
     "react-leaflet": "^5.0.0",
-    "zod": "^4.0.0"
+    "zod": "^4.0.0",
+    "@types/leaflet": "^1.9.22",
+    "@types/nodemailer": "^8.0.1"
   },
   "peerDependencies": {
     "next": "^16.2.6",
@@ -86,9 +90,7 @@
     "react-dom": "^19.2.0"
   },
   "devDependencies": {
-    "@types/leaflet": "^1.9.22",
     "@types/node": "^22.15.0",
-    "@types/nodemailer": "^8.0.1",
     "@types/react": "^19.1.0",
     "@types/react-dom": "^19.1.0",
     "drizzle-kit": "^0.31.0",

package/src/admin/pages/ai-settings.tsx

@@ -1,9 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { AiSettingsEditor } from '../AiSettingsEditor'
 
 export default async function AiSettingsPage() {
-  const result = await getSessionWithPermissions()
-  if (!result || !result.can('settings', 'read')) redirect('/admin/login')
+  const result = await requireAdminSession((r) => r.can('settings', 'read'), '/admin/login')
   return <AiSettingsEditor userName={result.session.user.name} canManageAi={result.hasSystem('ai.manage')} />
 }

package/src/admin/pages/api-tokens.tsx

@@ -1,10 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { ApiTokensEditor } from '../ApiTokensEditor'
 
 export default async function ApiTokensPage() {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.hasSystem('developers.manage')) redirect('/admin/settings')
+  const result = await requireAdminSession((r) => r.hasSystem('developers.manage'), '/admin/settings')
   return <ApiTokensEditor userName={result.session.user.name} />
 }

package/src/admin/pages/collection-list.tsx

@@ -1,5 +1,5 @@
-import { notFound, redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { notFound } from 'next/navigation'
+import { requireAdminSession } from '../require-session'
 import { getCollection } from '../../collections'
 import { CollectionListEditor } from '../CollectionListEditor'
 
@@ -7,9 +7,7 @@ export default async function CollectionListPage({ params }: { params: Promise<{
   const { collection } = await params
   const config = getCollection(collection)
   if (!config) notFound()
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.can(config.slug, 'read')) redirect('/admin/dashboard')
+  const result = await requireAdminSession((r) => r.can(config.slug, 'read'), '/admin/dashboard')
   return (
     <CollectionListEditor
       config={config}

package/src/admin/pages/collection-record.tsx

@@ -1,5 +1,5 @@
-import { notFound, redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { notFound } from 'next/navigation'
+import { requireAdminSession } from '../require-session'
 import { getCollection } from '../../collections'
 import { CollectionRecordEditor } from '../CollectionRecordEditor'
 
@@ -7,9 +7,7 @@ export default async function CollectionRecordPage({ params }: { params: Promise
   const { collection, id } = await params
   const config = getCollection(collection)
   if (!config) notFound()
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.can(config.slug, 'read')) redirect('/admin/dashboard')
+  const result = await requireAdminSession((r) => r.can(config.slug, 'read'), '/admin/dashboard')
   return (
     <CollectionRecordEditor
       config={config}

package/src/admin/pages/dashboard.tsx

@@ -1,10 +1,8 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { getDashboardSources } from '../../dashboard'
 import { DashboardBuilder } from '../DashboardBuilder'
 
 export default async function DashboardPage() {
-  const result = await getSessionWithPermissions()
-  if (!result || !result.can('settings', 'read')) redirect('/admin/login')
+  const result = await requireAdminSession((r) => r.can('settings', 'read'), '/admin/login')
   return <DashboardBuilder userName={result.session.user.name} canUpdate={result.can('settings', 'update')} dashboardSources={getDashboardSources()} />
 }

package/src/admin/pages/email-settings.tsx

@@ -1,10 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { EmailSettingsEditor } from '../EmailSettingsEditor'
 
 export default async function EmailSettingsPage() {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.hasSystem('developers.manage')) redirect('/admin/settings')
+  const result = await requireAdminSession((r) => r.hasSystem('developers.manage'), '/admin/settings')
   return <EmailSettingsEditor userName={result.session.user.name} />
 }

package/src/admin/pages/locales-settings.tsx

@@ -1,10 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { LocalesEditor } from '../LocalesEditor'
 
 export default async function LocalesPage() {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.hasSystem('locales.manage')) redirect('/admin/settings')
+  const result = await requireAdminSession((r) => r.hasSystem('locales.manage'), '/admin/settings')
   return <LocalesEditor userName={result.session.user.name} />
 }

package/src/admin/pages/media.tsx

@@ -1,9 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { MediaLibrary } from '../MediaLibrary'
 
 export default async function MediaPage() {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
+  const result = await requireAdminSession()
   return <MediaLibrary userName={result.session.user.name} />
 }

package/src/admin/pages/review-queue.tsx

@@ -1,11 +1,10 @@
 import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { getCollection, isCollectionSlug, reviewableSlugs, type CollectionSlug } from '../../collections'
 import { ReviewQueueEditor, type ReviewCollectionMeta } from '../ReviewQueueEditor'
 
 export default async function ReviewQueuePage() {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
+  const result = await requireAdminSession()
   const reviewSlugs = reviewableSlugs.filter((slug): slug is CollectionSlug => isCollectionSlug(slug))
   const canReview = Object.fromEntries(reviewSlugs.map((slug) => [slug, result.can(slug, 'review')])) as Record<CollectionSlug, boolean>
   const canApprove = Object.fromEntries(reviewSlugs.map((slug) => [slug, result.can(slug, 'approve')])) as Record<CollectionSlug, boolean>

package/src/admin/pages/role-edit.tsx

@@ -1,11 +1,8 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { RoleEditor } from '../RoleEditor'
 
 export default async function RoleEditPage({ params }: { params: Promise<{ id: string }> }) {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.hasSystem('roles.manage')) redirect('/admin')
+  const result = await requireAdminSession((r) => r.hasSystem('roles.manage'), '/admin')
   const { id } = await params
   return <RoleEditor id={id} userName={result.session.user.name} />
 }

package/src/admin/pages/roles.tsx

@@ -1,10 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { RolesEditor } from '../RolesEditor'
 
 export default async function RolesPage() {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.hasSystem('roles.manage')) redirect('/admin')
+  const result = await requireAdminSession((r) => r.hasSystem('roles.manage'), '/admin')
   return <RolesEditor userName={result.session.user.name} />
 }

package/src/admin/pages/scheduled.tsx

@@ -1,12 +1,10 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { getCollection, schedulingSlugs, type CollectionSlug } from '../../collections'
 import { ScheduledEditor, type ScheduledCollectionMeta } from '../ScheduledEditor'
 
 export default async function ScheduledPage() {
-  const result = await getSessionWithPermissions()
-  const readableSlugs = schedulingSlugs.filter((slug): slug is CollectionSlug => Boolean(result?.can(slug, 'read')))
-  if (!result || !readableSlugs.length) redirect('/admin/login')
+  const result = await requireAdminSession((r) => schedulingSlugs.some((slug) => r.can(slug, 'read')), '/admin/login')
+  const readableSlugs = schedulingSlugs.filter((slug): slug is CollectionSlug => result.can(slug, 'read'))
   const meta: ScheduledCollectionMeta = Object.fromEntries(
     readableSlugs.map((slug) => {
       const config = getCollection(slug)!

package/src/admin/pages/seo-settings.tsx

@@ -1,9 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { SeoSettingsEditor } from '../SeoSettingsEditor'
 
 export default async function SeoSettingsPage() {
-  const result = await getSessionWithPermissions()
-  if (!result || !result.can('settings', 'read')) redirect('/admin/login')
+  const result = await requireAdminSession((r) => r.can('settings', 'read'), '/admin/login')
   return <SeoSettingsEditor userName={result.session.user.name} />
 }

package/src/admin/pages/single-record.tsx

@@ -1,5 +1,5 @@
-import { notFound, redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { notFound } from 'next/navigation'
+import { requireAdminSession } from '../require-session'
 import { getSingle } from '../../collections'
 import { SingleRecordEditor } from '../SingleRecordEditor'
 
@@ -7,9 +7,7 @@ export default async function SingleRecordPage({ params }: { params: Promise<{ t
   const { type } = await params
   const config = getSingle(type)
   if (!config) notFound()
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.can(config.slug, 'read')) redirect('/admin/dashboard')
+  const result = await requireAdminSession((r) => r.can(config.slug, 'read'), '/admin/dashboard')
   return (
     <SingleRecordEditor
       config={config}

package/src/admin/pages/site-settings.tsx

@@ -1,9 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { SiteSettingsEditor } from '../SiteSettingsEditor'
 
 export default async function SettingsPage() {
-  const result = await getSessionWithPermissions()
-  if (!result || !result.can('settings', 'read')) redirect('/admin/login')
+  const result = await requireAdminSession((r) => r.can('settings', 'read'), '/admin/login')
   return <SiteSettingsEditor userName={result.session.user.name} />
 }

package/src/admin/pages/user-edit.tsx

@@ -1,11 +1,8 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { UserEditor } from '../UserEditor'
 
 export default async function UserEditPage({ params }: { params: Promise<{ id: string }> }) {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.hasSystem('users.manage')) redirect('/admin')
+  const result = await requireAdminSession((r) => r.hasSystem('users.manage'), '/admin')
   const { id } = await params
   return <UserEditor id={id} userName={result.session.user.name} />
 }

package/src/admin/pages/user-new.tsx

@@ -1,10 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { UserEditor } from '../UserEditor'
 
 export default async function NewUserPage() {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.hasSystem('users.manage')) redirect('/admin')
+  const result = await requireAdminSession((r) => r.hasSystem('users.manage'), '/admin')
   return <UserEditor id="new" userName={result.session.user.name} />
 }

package/src/admin/pages/users.tsx

@@ -1,10 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { UsersEditor } from '../UsersEditor'
 
 export default async function UsersPage() {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.hasSystem('users.manage')) redirect('/admin')
+  const result = await requireAdminSession((r) => r.hasSystem('users.manage'), '/admin')
   return <UsersEditor userName={result.session.user.name} />
 }

package/src/admin/pages/webhooks-settings.tsx

@@ -1,10 +1,7 @@
-import { redirect } from 'next/navigation'
-import { getSessionWithPermissions } from '../../permissions'
+import { requireAdminSession } from '../require-session'
 import { WebhooksEditor } from '../WebhooksEditor'
 
 export default async function WebhooksPage() {
-  const result = await getSessionWithPermissions()
-  if (!result) redirect('/admin/login')
-  if (!result.hasSystem('developers.manage')) redirect('/admin/settings')
+  const result = await requireAdminSession((r) => r.hasSystem('developers.manage'), '/admin/settings')
   return <WebhooksEditor userName={result.session.user.name} />
 }

package/src/admin/require-session.ts

@@ -0,0 +1,21 @@
+import { redirect } from 'next/navigation'
+import { getSessionWithPermissions, type SessionWithPermissions } from '../permissions'
+
+/** For Server Component admin pages only — `redirect()` from `next/navigation` only works
+ *  inside the RSC render tree, never call this from a Route Handler (use `requireAction`/
+ *  `requireSystem` from `../permissions` there instead, which return null on failure and let
+ *  the route decide how to respond).
+ *
+ *  Replaces the repeated
+ *    const result = await getSessionWithPermissions()
+ *    if (!result) redirect('/admin/login')
+ *    if (!result.can(...)) redirect('/admin/dashboard')
+ *  pattern with one call. `check` is optional — omit it for a page that only needs "is logged
+ *  in" (its real authorization logic is more than a single predicate, e.g. it depends on data
+ *  computed from the session first). */
+export async function requireAdminSession(check?: (result: SessionWithPermissions) => boolean, redirectTo = '/admin/dashboard'): Promise<SessionWithPermissions> {
+  const result = await getSessionWithPermissions()
+  if (!result) redirect('/admin/login')
+  if (check && !check(result)) redirect(redirectTo)
+  return result
+}

package/src/cli/index.mjs

@@ -128,6 +128,49 @@ function migrate() {
   console.log('\nRun your own `db:generate`/`db:migrate` next for this app\'s own content tables.')
 }
 
+// --- init -----------------------------------------------------------------------------------
+
+function parseFlags(argv) {
+  const flags = {}
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]
+    if (arg.startsWith('--')) flags[arg.slice(2)] = argv[i + 1]
+  }
+  return flags
+}
+
+async function init(argv) {
+  const flags = parseFlags(argv)
+  const url = flags.url ?? 'http://localhost:3000'
+  const token = flags.token ?? process.env.CMS_SETUP_TOKEN
+  const { name, email, password } = flags
+
+  if (!token) fail('missing --token (or set CMS_SETUP_TOKEN in your environment before running this).')
+  if (!name || !email || !password) fail('usage: kilo-cms init --name "..." --email you@example.com --password "..." [--url http://localhost:3000] [--token ...]')
+
+  migrate()
+
+  console.log(`\nCreating first admin at ${url}/api/setup/admin ...`)
+  console.log('(this requires your app to already be running — start it in another terminal first if it isn\'t.)')
+
+  let response
+  try {
+    response = await fetch(`${url}/api/setup/admin`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+      body: JSON.stringify({ name, email, password }),
+    })
+  } catch (error) {
+    fail(`could not reach ${url} — is the app running? (${error instanceof Error ? error.message : String(error)})`)
+    return
+  }
+
+  const body = await response.json().catch(() => null)
+  if (!response.ok) fail(`setup failed (${response.status}): ${body?.error ?? 'unknown error'}`)
+
+  console.log(`\nDone — admin user created (${email}). You can log in at ${url}/admin/login.`)
+}
+
 // --- dispatch -------------------------------------------------------------------------------
 
 switch (command) {
@@ -140,10 +183,15 @@ switch (command) {
   case 'migrate':
     migrate()
     break
+  case 'init':
+    await init(args)
+    break
   default:
     console.log(`kilo-cms — usage:
   kilo-cms add-collection <slug>   scaffold a new collection's fields.ts + table.ts
   kilo-cms sync                    regenerate .kilo/types.gen.ts from src/collections/*
-  kilo-cms migrate                 apply kilo-cms's own package-owned migrations`)
+  kilo-cms migrate                 apply kilo-cms's own package-owned migrations
+  kilo-cms init                    migrate, then create the first admin user
+                                    (--name, --email, --password, [--url], [--token or $CMS_SETUP_TOKEN])`)
     process.exit(command ? 1 : 0)
 }

package/src/middleware.ts

@@ -0,0 +1,28 @@
+import { NextResponse, type NextRequest } from 'next/server'
+import { getSessionCookie } from 'better-auth/cookies'
+
+/** Optimistic, Edge-safe redirect for unauthenticated requests to admin pages — a fast
+ *  pre-filter based on cookie PRESENCE only (`getSessionCookie` reads the cookie, no DB call,
+ *  safe to run in Edge middleware where a raw Postgres connection isn't available). This is
+ *  NOT the real security boundary: a forged or expired cookie passes this check. Every admin
+ *  page still calls `requireAdminSession()` (pages) or `requireAction`/`requireSystem` (API
+ *  routes), which validate the session for real and check actual RBAC permissions — this only
+ *  saves an unauthenticated visitor the round trip of hitting a page that would reject them
+ *  anyway, and centralizes what used to be an `if (!result) redirect('/admin/login')` repeated
+ *  on every single admin page.
+ *
+ *  The host's own `middleware.ts` re-exports this as `middleware` and defines `config.matcher`
+ *  itself (Next.js statically analyzes `matcher` at build time — it has to be a literal array
+ *  in the file Next.js is scanning, not re-exported through another module). */
+export function kiloAdminMiddleware(request: NextRequest): NextResponse {
+  const { pathname } = request.nextUrl
+  if (pathname === '/admin/login') return NextResponse.next()
+
+  const sessionCookie = getSessionCookie(request)
+  if (!sessionCookie) {
+    const url = request.nextUrl.clone()
+    url.pathname = '/admin/login'
+    return NextResponse.redirect(url)
+  }
+  return NextResponse.next()
+}