@flaredev/cli 0.4.0 → 0.5.0

package/templates/next/lib/dashboard.ts

@@ -0,0 +1,161 @@
+import { headers } from "next/headers";
+import { notFound, redirect } from "next/navigation";
+import { allowedActions, can, columnName, type Policy, type PolicyAction, type Resource } from "@flaredev/core";
+import { createResourceStore, prismaRows, type PrismaDelegate, type ResourceStore } from "@flaredev/core/server";
+import { prisma } from "@/lib/db";
+import { policies } from "@/policies";
+import { resourceTables } from "@/resources/server";
+import { currentUser } from "./api";
+import { auth } from "./auth";
+import { cached, resourceTag, revalidateResource, TTL } from "./cache";
+
+/**
+ * The dashboard's view of a resource, on the Next.js stack.
+ *
+ * The same shape as the Cloudflare one — same exports, same behaviour — over Prisma and
+ * Postgres instead of Drizzle and D1. The store itself is shared: only where its rows
+ * come from differs.
+ */
+
+export const ADMIN_ROLES = ["admin", "staff"];
+
+export function policyFor(resourceName: string): Policy | undefined {
+  return (policies as Record<string, Policy | undefined>)[resourceName];
+}
+
+export async function dashboardSession() {
+  const session = await auth.api.getSession({ headers: await headers() });
+  if (!session) return { session: null, role: null, allowed: false } as const;
+  const role = (session.user as { role?: string | null }).role ?? null;
+  const readable = allResources().some((resource) => can(policyFor(resource.name), role, "read"));
+  return { session, role, allowed: (role !== null && ADMIN_ROLES.includes(role)) || readable } as const;
+}
+
+/** For admin pages: redirects signed-out visitors to sign-in and users without access to the home page. */
+export async function requireDashboard(returnTo = "/dashboard") {
+  const { session, role, allowed } = await dashboardSession();
+  if (!session) redirect(`/sign-in?next=${encodeURIComponent(returnTo)}`);
+  if (!allowed) redirect("/?error=forbidden");
+  return { session, role };
+}
+
+/**
+ * For resource pages: also requires the policy to allow `action` on this resource.
+ * Sends the user somewhere they can actually go — the list when they may read it,
+ * the dashboard when they may not.
+ */
+export async function requireAccess(resource: Resource, action: PolicyAction) {
+  const { session, role } = await requireDashboard(resourcePath(resource));
+  const policy = policyFor(resource.name);
+  if (!can(policy, role, action)) {
+    redirect(action !== "read" && can(policy, role, "read") ? resourcePath(resource) : "/dashboard?error=forbidden");
+  }
+  return { session, role };
+}
+
+/** What the current user may do with a resource, for hiding actions they can't use. */
+export async function adminPermissions(resourceName: string) {
+  const { role } = await dashboardSession();
+  return allowedActions(policyFor(resourceName), role);
+}
+
+const stores = new Map<string, ResourceStore>();
+
+/** CRUD store for a resource by name (404 for unknown names). */
+export function dashboardStore(name: string): ResourceStore {
+  const entry = (resourceTables as unknown as Record<string, { resource: Resource; delegate: PrismaDelegate } | undefined>)[name];
+  if (!entry) notFound();
+  let store = stores.get(name);
+  if (!store) {
+    store = createResourceStore({
+      resource: entry.resource,
+      rows: prismaRows(entry.delegate, prisma),
+      onChange: revalidateResource,
+      currentUser,
+    });
+    stores.set(name, store);
+  }
+  return store;
+}
+
+/**
+ * Every number the stats above a resource's table need, in one query.
+ *
+ * The total, how many arrived in the last week and the week before, and how many hold
+ * each value of a status field — one grouped scan, summed up here. Written as SQL
+ * because Prisma's aggregation API can't express "count these rows, and also count the
+ * subset of them created since Tuesday" in a single round trip.
+ *
+ * The table and column names come from the descriptor, never from a request, and are
+ * quoted; nothing a visitor types reaches this.
+ */
+export interface ResourceStats {
+  total: number;
+  /** Created in the last `days` days, and in the `days` before that. */
+  current: number;
+  previous: number;
+  /** Rows per value of the grouped field, when one was asked for. */
+  values: Record<string, number>;
+}
+
+export function resourceStats(name: string, field?: string, days = 7): Promise<ResourceStats> {
+  const read = cached(
+    async (resourceName: string, key: string | undefined, windowDays: number): Promise<ResourceStats> => {
+      const entry = (resourceTables as unknown as Record<string, { resource: Resource } | undefined>)[resourceName];
+      if (!entry) return { total: 0, current: 0, previous: 0, values: {} };
+
+      const table = `"${entry.resource.table}"`;
+      const grouped = key && entry.resource.fields[key] ? `"${columnName(key)}"` : undefined;
+      const window = windowDays * 86_400_000;
+      const since = new Date(Date.now() - window).toISOString();
+      const before = new Date(Date.now() - window * 2).toISOString();
+
+      const select = [
+        "count(*)::int as total",
+        `count(*) filter (where "created_at" >= '${since}')::int as current`,
+        `count(*) filter (where "created_at" >= '${before}' and "created_at" < '${since}')::int as previous`,
+        ...(grouped ? [`${grouped} as value`] : []),
+      ].join(", ");
+      const query = `select ${select} from ${table}${grouped ? ` group by ${grouped}` : ""}`;
+
+      const rows = (await prisma.$queryRawUnsafe(query)) as { total: number; current: number; previous: number; value?: unknown }[];
+      const stats: ResourceStats = { total: 0, current: 0, previous: 0, values: {} };
+      for (const row of rows) {
+        stats.total += Number(row.total ?? 0);
+        stats.current += Number(row.current ?? 0);
+        stats.previous += Number(row.previous ?? 0);
+        if (grouped) stats.values[String(row.value ?? "")] = Number(row.total ?? 0);
+      }
+      return stats;
+    },
+    ["flare", "resource-stats"],
+    { tags: [resourceTag(name)], revalidate: TTL.medium },
+  );
+  return read(name, field, days);
+}
+
+/** How many records a resource has. One field of {@link resourceStats}. */
+export async function recordCount(name: string): Promise<number> {
+  return (await resourceStats(name)).total;
+}
+
+/** Percentage change between two periods, or undefined when there's nothing to compare. */
+export function trend(current: number, previous: number): number | undefined {
+  if (previous === 0) return current === 0 ? undefined : 100;
+  return ((current - previous) / previous) * 100;
+}
+
+/** Every resource descriptor (unfiltered): navigation uses `visibleResources()` instead. */
+export function allResources(): Resource[] {
+  return Object.values(resourceTables as unknown as Record<string, { resource: Resource }>).map((entry) => entry.resource);
+}
+
+/** Resources the current user may read, for the sidebar and dashboard. */
+export async function visibleResources(): Promise<Resource[]> {
+  const { role } = await dashboardSession();
+  return allResources().filter((resource) => can(policyFor(resource.name), role, "read"));
+}
+
+export function resourcePath(resource: Resource, ...parts: string[]) {
+  return ["/dashboard", resource.slug, ...parts].join("/");
+}

package/templates/next/lib/db.ts

@@ -0,0 +1,24 @@
+import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "@/lib/generated/prisma/client";
+
+/**
+ * The Prisma client, one per process.
+ *
+ * Prisma 7 needs a driver adapter rather than a connection string in the schema. This
+ * one is the ordinary Postgres driver, which talks to anything that speaks Postgres:
+ * Neon's pooled endpoint, Supabase, RDS, or the container you run while developing.
+ * Next runs on Node, so there is nothing to gain from a serverless HTTP driver and a
+ * great deal to lose — `@prisma/adapter-neon` can't reach a database on localhost.
+ *
+ * Next reloads modules on every edit in development, and a fresh client each time would
+ * exhaust the connection limit within a few saves; hence the global.
+ */
+const makeClient = () => new PrismaClient({ adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL }) });
+
+const globalForPrisma = globalThis as unknown as { prisma?: ReturnType<typeof makeClient> };
+
+export const prisma = globalForPrisma.prisma ?? makeClient();
+if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;
+
+/** Named to match the Cloudflare stack, so code that takes a database reads the same. */
+export const getDb = () => prisma;

package/templates/next/lib/mail.ts

@@ -0,0 +1,35 @@
+import { createMailer, renderTransactionalEmail, type TransactionalEmail } from "@flaredev/core";
+
+/**
+ * Transactional email via Resend.
+ *
+ * Without RESEND_API_KEY (e.g. local dev) emails are printed to the console
+ * instead of sent. MAIL_FROM must use a domain verified in Resend. The fallback
+ * sandbox sender only delivers to your own Resend account address.
+ */
+export const mailer = createMailer({
+  apiKey: process.env.RESEND_API_KEY,
+  from: process.env.MAIL_FROM || "__APP_NAME__ <onboarding@resend.dev>",
+});
+
+/**
+ * Render and send a transactional email. Resolves to `{ data, error }` and never throws for API errors.
+ *
+ *   const { error } = await sendTransactionalEmail({
+ *     to: user.email,
+ *     subject: "Your order has shipped",
+ *     heading: "On its way",
+ *     paragraphs: [`Order #${order.id} left our warehouse today.`],
+ *     action: { label: "Track order", url: `https://example.com/orders/${order.id}` },
+ *     idempotencyKey: `order-shipped/${order.id}`,
+ *   });
+ */
+export async function sendTransactionalEmail({
+  to,
+  subject,
+  idempotencyKey,
+  ...content
+}: Omit<TransactionalEmail, "appName"> & { to: string | string[]; subject: string; idempotencyKey?: string }) {
+  const { html, text } = renderTransactionalEmail({ appName: "__APP_NAME__", ...content });
+  return mailer.send({ to, subject, html, text, idempotencyKey });
+}

package/templates/next/lib/realtime.ts

@@ -0,0 +1,23 @@
+/**
+ * Realtime, on the Next.js stack.
+ *
+ * The Cloudflare stack gives every channel a Durable Object: one address, one thread,
+ * its own storage, and websockets that stay open. Vercel has no equivalent — functions
+ * don't hold connections — so rather than pretend, this says so, and publishing is a
+ * no-op that never breaks a write.
+ *
+ * If you need it here, the shape to reach for is a hosted pub/sub (Ably, Pusher,
+ * Upstash) behind these same two functions.
+ */
+import type { RealtimeAuthorize } from "@flaredev/core/realtime/server";
+
+export const authorizeRealtime: RealtimeAuthorize = () => false;
+
+export interface RealtimeChannel {
+  publish(event: string, data: unknown): Promise<void>;
+}
+
+/** A channel that accepts publishes and drops them, so callers need no special case. */
+export function realtimeChannel(_name: string): RealtimeChannel {
+  return { publish: async () => undefined };
+}

package/templates/next/lib/redis.ts

@@ -0,0 +1,17 @@
+import { Redis } from "@upstash/redis";
+
+/**
+ * Upstash Redis, over HTTP.
+ *
+ * Next's own data cache (`cached()` in lib/cache.ts) handles query caching. This is for
+ * the things a cache can't do: rate limits, locks, anything that has to be true across
+ * every instance at once. It talks HTTP rather than a socket, so a serverless function
+ * needs no connection pool.
+ *
+ * Unset credentials give you `null` rather than a crash, so an app that doesn't use it
+ * doesn't have to configure it.
+ */
+export const redis =
+  process.env.UPSTASH_REDIS_REST_URL && process.env.UPSTASH_REDIS_REST_TOKEN
+    ? new Redis({ url: process.env.UPSTASH_REDIS_REST_URL, token: process.env.UPSTASH_REDIS_REST_TOKEN })
+    : null;

package/templates/next/lib/storage.ts

@@ -0,0 +1,57 @@
+import { AwsClient } from "aws4fetch";
+import { createObjectKey, createStorage } from "@flaredev/core";
+
+/**
+ * File storage on R2, over its S3-compatible API.
+ *
+ * R2 rather than Vercel Blob for one reason: R2 charges nothing to serve what it
+ * stores. On a file-heavy app that is the difference between a small bill and a large
+ * one, and it costs nothing to use from outside Cloudflare — see the cost guide.
+ *
+ * `aws4fetch` signs the requests; it is a few kilobytes and works in any runtime, unlike
+ * the AWS SDK. Everything above this — the upload widget, the signed-URL helpers, the
+ * file field — is the same code the Cloudflare stack runs.
+ */
+const client = new AwsClient({
+  accessKeyId: process.env.R2_ACCESS_KEY_ID ?? "",
+  secretAccessKey: process.env.R2_SECRET_ACCESS_KEY ?? "",
+  service: "s3",
+  region: "auto",
+});
+
+const endpoint = `${process.env.R2_ENDPOINT ?? ""}/${process.env.R2_BUCKET ?? ""}`;
+
+/** The bucket, shaped the way @flaredev/core expects, over plain HTTP calls. */
+const bucket = {
+  async get(key: string) {
+    const response = await client.fetch(`${endpoint}/${encodeURIComponent(key)}`);
+    if (!response.ok || !response.body) return null;
+    return {
+      body: response.body,
+      httpMetadata: { contentType: response.headers.get("content-type") ?? undefined },
+      size: Number(response.headers.get("content-length") ?? 0),
+      // R2 returns the object's ETag quoted, which is what the header wants back.
+      httpEtag: response.headers.get("etag") ?? "",
+    };
+  },
+  async put(key: string, value: ReadableStream | ArrayBuffer | string | null, options?: { httpMetadata?: { contentType?: string } }) {
+    await client.fetch(`${endpoint}/${encodeURIComponent(key)}`, {
+      method: "PUT",
+      body: value,
+      headers: options?.httpMetadata?.contentType ? { "content-type": options.httpMetadata.contentType } : undefined,
+    });
+  },
+  async delete(keys: string | string[]) {
+    for (const key of [keys].flat()) {
+      await client.fetch(`${endpoint}/${encodeURIComponent(key)}`, { method: "DELETE" });
+    }
+  },
+};
+
+export const storage = createStorage({
+  bucket,
+  // Signing keys are derived from the auth secret with a storage-specific label.
+  secret: process.env.BETTER_AUTH_SECRET ?? "",
+});
+
+export { createObjectKey };

package/templates/next/lib/theme.ts

@@ -0,0 +1,83 @@
+import { site } from "./site";
+
+/**
+ * The six looks every Flare app ships with. The active one sets `data-theme` on <html>;
+ * app/globals.css maps it to colours, radius and type, and the auth screens pick the
+ * layout below.
+ */
+export const THEMES = {
+  default: {
+    label: "Default",
+    description: "Calm and centred, indigo accents.",
+    auth: "centered",
+    social: "after",
+    socialStyle: "full",
+    signIn: (name: string) => ({ title: `Sign in to ${name}` }),
+    signUp: (name: string) => ({ title: `Create your ${name} account` }),
+  },
+  coral: {
+    label: "Coral",
+    description: "Warm and rounded, a card floating over the page.",
+    auth: "modal",
+    social: "after",
+    socialStyle: "icon",
+    signIn: () => ({ title: "Log in or sign up" }),
+    signUp: () => ({ title: "Create your account" }),
+  },
+  amber: {
+    label: "Amber",
+    description: "Plain and direct, a boxed form with pill buttons.",
+    auth: "boxed",
+    social: "after",
+    socialStyle: "full",
+    signIn: () => ({ title: "Sign in" }),
+    signUp: () => ({ title: "Create account" }),
+  },
+  sky: {
+    label: "Sky",
+    description: "Crisp blue, a bold heading with social sign-in first.",
+    auth: "banner",
+    social: "before",
+    socialStyle: "full",
+    signIn: (name: string) => ({ title: `Log in to ${name}` }),
+    signUp: (name: string) => ({ title: `Get started with ${name}` }),
+  },
+  mono: {
+    label: "Mono",
+    description: "Black and white on a fine grid, a showcase beside the form.",
+    auth: "showcase",
+    social: "after",
+    socialStyle: "full",
+    signIn: (name: string) => ({ title: `Log in to your ${name} account` }),
+    signUp: (name: string) => ({ title: `Create your ${name} account` }),
+  },
+  emerald: {
+    label: "Emerald",
+    description: "Fresh green, the form beside a customer quote.",
+    auth: "quote",
+    social: "before",
+    socialStyle: "full",
+    signIn: () => ({ title: "Welcome back", subtitle: "Sign in to your account" }),
+    signUp: () => ({ title: "Get started", subtitle: "Create a new account" }),
+  },
+} as const;
+
+export type ThemeName = keyof typeof THEMES;
+export type AuthLayout = (typeof THEMES)[ThemeName]["auth"];
+
+/** Set from FLARE_THEME by vite.config.ts when the app is built or run. */
+/**
+ * On Cloudflare this comes from a Vite define, so `FLARE_THEME=mono flare dev` can
+ * switch the look without editing code. Next has no such constant, so the theme is
+ * whatever lib/site.ts says — change it there, or with `flare theme <name>`.
+ */
+
+export function isThemeName(value: unknown): value is ThemeName {
+  return typeof value === "string" && value in THEMES;
+}
+
+/** The theme in use: FLARE_THEME if it names one, else lib/site.ts. */
+export const activeTheme: ThemeName = isThemeName(site.theme) ? site.theme : "default";
+
+export const theme = THEMES[activeTheme];
+export const authLayout: AuthLayout = theme.auth;

package/templates/next/lib/views.ts

@@ -0,0 +1,23 @@
+import { prisma } from "@/lib/db";
+import { dashboardSession } from "./dashboard";
+
+export interface SavedView {
+  id: string;
+  resource: string;
+  name: string;
+  query: string;
+}
+
+/** How many views one person may keep per resource, so the sidebar stays a sidebar. */
+export const MAX_VIEWS = 12;
+
+/** This person's saved views, oldest first so the sidebar doesn't reshuffle. */
+export async function listViews(resource?: string): Promise<SavedView[]> {
+  const { session } = await dashboardSession();
+  if (!session) return [];
+  return prisma.savedView.findMany({
+    where: { userId: session.user.id, ...(resource ? { resource } : {}) },
+    select: { id: true, resource: true, name: true, query: true },
+    orderBy: { createdAt: "asc" },
+  });
+}

package/templates/next/next.config.ts

@@ -0,0 +1,13 @@
+import type { NextConfig } from "next";
+
+const config: NextConfig = {
+  // The generated Prisma client is a real dependency of the server bundle; without this
+  // Next tries to trace it as application code and misses the query engine beside it.
+  serverExternalPackages: ["@prisma/client", "@prisma/adapter-pg"],
+  // Compile @flaredev/core from source rather than resolving it as an opaque package.
+  // Needed when it is linked from a checkout or a monorepo: the bundler won't follow a
+  // symlink out of the project root, and every import from it fails to resolve.
+  transpilePackages: ["@flaredev/core"],
+};
+
+export default config;

package/templates/next/prisma/schema/base.prisma

@@ -0,0 +1,162 @@
+// The part of the schema that is yours.
+//
+// Your resources live in resources.prisma beside this file, written by
+// `flare gen resource` from the descriptors in resources/. This file is never
+// regenerated: the generator, the datasource, the tables Better Auth needs and the two
+// Flare's own dashboard uses are all here, and yours to edit.
+
+generator client {
+  provider = "prisma-client"
+  output   = "../../lib/generated/prisma"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+/// Better Auth: the signed-in person.
+model User {
+  id              String    @id @default(uuid())
+  name            String
+  email           String    @unique
+  emailVerified   Boolean   @default(false) @map("email_verified")
+  image           String?
+  /// Set with `flare user:role`; the dashboard's policies read it.
+  role            String?
+  banned          Boolean?
+  banReason       String?   @map("ban_reason")
+  banExpires      DateTime? @map("ban_expires")
+  twoFactorEnabled Boolean? @map("two_factor_enabled")
+  createdAt       DateTime  @default(now()) @map("created_at")
+  updatedAt       DateTime  @updatedAt @map("updated_at")
+
+  sessions   Session[]
+  accounts   Account[]
+  passkeys   Passkey[]
+  twoFactors TwoFactor[]
+  auditLogs  AuditLog[]
+  savedViews SavedView[]
+
+  @@map("users")
+}
+
+model Session {
+  id             String   @id @default(uuid())
+  expiresAt      DateTime @map("expires_at")
+  token          String   @unique
+  ipAddress      String?  @map("ip_address")
+  userAgent      String?  @map("user_agent")
+  userId         String   @map("user_id")
+  impersonatedBy String?  @map("impersonated_by")
+  createdAt      DateTime @default(now()) @map("created_at")
+  updatedAt      DateTime @updatedAt @map("updated_at")
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@map("sessions")
+}
+
+model Account {
+  id                    String    @id @default(uuid())
+  accountId             String    @map("account_id")
+  providerId            String    @map("provider_id")
+  userId                String    @map("user_id")
+  accessToken           String?   @map("access_token")
+  refreshToken          String?   @map("refresh_token")
+  idToken               String?   @map("id_token")
+  accessTokenExpiresAt  DateTime? @map("access_token_expires_at")
+  refreshTokenExpiresAt DateTime? @map("refresh_token_expires_at")
+  scope                 String?
+  password              String?
+  createdAt             DateTime  @default(now()) @map("created_at")
+  updatedAt             DateTime  @updatedAt @map("updated_at")
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@map("accounts")
+}
+
+model Verification {
+  id         String   @id @default(uuid())
+  identifier String
+  value      String
+  expiresAt  DateTime @map("expires_at")
+  createdAt  DateTime @default(now()) @map("created_at")
+  updatedAt  DateTime @updatedAt @map("updated_at")
+
+  @@index([identifier])
+  @@map("verifications")
+}
+
+model Passkey {
+  id           String    @id @default(uuid())
+  name         String?
+  publicKey    String    @map("public_key")
+  userId       String    @map("user_id")
+  credentialID String    @map("credential_id")
+  counter      Int
+  deviceType   String    @map("device_type")
+  backedUp     Boolean   @map("backed_up")
+  transports   String?
+  aaguid       String?
+  createdAt    DateTime? @default(now()) @map("created_at")
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId])
+  @@map("passkeys")
+}
+
+model TwoFactor {
+  id                      String    @id @default(uuid())
+  secret                  String
+  backupCodes             String    @map("backup_codes")
+  userId                  String    @map("user_id")
+  /// Better Auth checks for these three at startup and refuses to run without them.
+  verified                Boolean?  @default(true)
+  failedVerificationCount Int?      @default(0) @map("failed_verification_count")
+  lockedUntil             DateTime? @map("locked_until")
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([secret])
+  @@index([userId])
+  @@map("two_factors")
+}
+
+/// Who changed what, written by the dashboard's actions.
+model AuditLog {
+  id           String   @id @default(uuid())
+  action       String
+  resource     String
+  recordId     String?  @map("record_id")
+  recordLabel  String?  @map("record_label")
+  userId       String?  @map("user_id")
+  userEmail    String?  @map("user_email")
+  changes      Json?
+  ip           String?
+  createdAt    DateTime @default(now()) @map("created_at")
+
+  user User? @relation(fields: [userId], references: [id], onDelete: SetNull)
+
+  @@index([resource])
+  @@index([createdAt])
+  @@map("audit_log")
+}
+
+/// A saved set of filters on a resource's table.
+model SavedView {
+  id        String   @id @default(uuid())
+  name      String
+  resource  String
+  query     String
+  userId    String   @map("user_id")
+  createdAt DateTime @default(now()) @map("created_at")
+
+  user User @relation(fields: [userId], references: [id], onDelete: Cascade)
+
+  @@index([userId, resource])
+  @@map("saved_views")
+}

package/templates/next/prisma.config.ts

@@ -0,0 +1,15 @@
+import "dotenv/config";
+import { defineConfig, env } from "prisma/config";
+
+/**
+ * Prisma 7 keeps the connection string out of the schema and loads env itself.
+ *
+ * `schema` points at a folder, not a file: `base.prisma` holds the generator, the
+ * datasource and the tables Flare's own features need, and `resources.prisma` is written
+ * by `flare gen resource` from your descriptors.
+ */
+export default defineConfig({
+  schema: "prisma/schema",
+  migrations: { path: "prisma/migrations" },
+  datasource: { url: env("DATABASE_URL") },
+});

package/templates/next/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "incremental": true,
+    "jsx": "preserve",
+    "types": ["node"],
+    "plugins": [{ "name": "next" }],
+    "paths": {
+      "@/*": ["./*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+  "exclude": ["node_modules", ".next", "lib/generated"]
+}