pnpm dlx shadcn@latest init

pnpm add prisma tsx @types/pg --save-dev
pnpm add @prisma/client @prisma/adapter-pg dotenv pg

pnpm dlx prisma init --db --output ../app/generated/prisma

DATABASE_URL="postgresql://username:password@ep-xxx.us-east-1.aws.neon.tech/neondb?sslmode=require"

// prisma.config.ts
import "dotenv/config";
import { defineConfig, env } from "prisma/config";
 
export default defineConfig({
  schema: "prisma/schema.prisma",
  migrations: {
    path: "prisma/migrations",
    seed: `tsx prisma/seed.ts`,
  },
  datasource: {
    url: env("DATABASE_URL"),
  },
});

generator client {
  provider = "prisma-client"
  output   = "../app/generated/prisma"
}
 
datasource db {
  provider = "postgresql"
}

# ⚠️ In Prisma 7, use db push instead of migrate dev for initial setup
pnpm dlx prisma db push
 
# Then generate the client
pnpm dlx prisma generate

// lib/prisma.ts
import { PrismaClient } from "../app/generated/prisma/client";
import { PrismaPg } from "@prisma/adapter-pg";
 
const globalForPrisma = global as unknown as {
  prisma: PrismaClient;
};
 
const adapter = new PrismaPg({
  connectionString: process.env.DATABASE_URL,
});
 
const db = globalForPrisma.prisma || new PrismaClient({ adapter });
 
if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = db;
 
export default db;

{
  "scripts": {
    "dev": "next dev"
  }
}

pnpm dlx shadcn@latest add https://better-auth-ui.desishub.com/r/auth-components.json

cp .env.example .env.local

# Better Auth
BETTER_AUTH_SECRET="run: openssl rand -base64 32"
BETTER_AUTH_URL="http://localhost:3000"
 
# Database
DATABASE_URL="your-neon-connection-string"
 
# Email (use Resend for production)
RESEND_API_KEY="re_xxxxxxxxxxxx"
 
# OAuth (optional but recommended)
GOOGLE_CLIENT_ID="your-google-client-id"
GOOGLE_CLIENT_SECRET="your-google-client-secret"
GITHUB_CLIENT_ID="your-github-client-id"
GITHUB_CLIENT_SECRET="your-github-client-secret"

// prisma/schema.prisma
 
generator client {
  provider = "prisma-client"
  output   = "../app/generated/prisma"
}
 
datasource db {
  provider = "postgresql"
}
 
// ... (Better Auth models above — do not remove them)
 
model Recipe {
  id           String   @id @default(cuid())
  name         String
  description  String?
  country      String   // e.g. "Uganda", "Nigeria"
  region       String?  // e.g. "Eastern Uganda"
  category     String   // e.g. "Main Course", "Breakfast"
  ingredients  String[] // Array of ingredient strings
  steps        String[] // Array of step-by-step instructions
  prepTime     Int      // in minutes
  cookTime     Int      // in minutes
  servings     Int
  imageUrl     String?
  tags         String[]
  createdAt    DateTime @default(now())
  updatedAt    DateTime @updatedAt
}
 
model ApiKey {
  id        String   @id @default(cuid())
  userId    String
  name      String
  key       String   @unique
  usageCount Int     @default(0)
  lastUsedAt DateTime?
  createdAt DateTime @default(now())
  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)
}
 
model ApiUsageLog {
  id        String   @id @default(cuid())
  apiKeyId  String
  endpoint  String
  method    String
  statusCode Int
  timestamp DateTime @default(now())
  apiKey    ApiKey   @relation(fields: [apiKeyId], references: [id], onDelete: Cascade)
}

pnpm dlx prisma db push
pnpm dlx prisma generate

// app/api/v1/recipes/route.ts
import { NextRequest, NextResponse } from "next/server";
import db from "@/lib/prisma";
import { validateApiKey } from "@/lib/api-key"; // We build this in Part 4
 
export async function GET(request: NextRequest) {
  // Validate the API key on every request
  const authResult = await validateApiKey(request);
  if (!authResult.valid) {
    return NextResponse.json(
      { error: "Unauthorized. Provide a valid API key." },
      { status: 401 }
    );
  }
 
  try {
    const { searchParams } = new URL(request.url);
 
    // Pagination
    const page = parseInt(searchParams.get("page") ?? "1");
    const limit = parseInt(searchParams.get("limit") ?? "20");
    const skip = (page - 1) * limit;
 
    // Filters
    const country = searchParams.get("country");
    const category = searchParams.get("category");
    const search = searchParams.get("search");
 
    // Build dynamic WHERE clause
    const where: any = {};
    if (country) where.country = { equals: country, mode: "insensitive" };
    if (category) where.category = { equals: category, mode: "insensitive" };
    if (search) {
      where.OR = [
        { name: { contains: search, mode: "insensitive" } },
        { description: { contains: search, mode: "insensitive" } },
        { tags: { has: search } },
      ];
    }
 
    const [recipes, total] = await Promise.all([
      db.recipe.findMany({
        where,
        orderBy: { createdAt: "desc" },
        skip,
        take: limit,
      }),
      db.recipe.count({ where }),
    ]);
 
    return NextResponse.json({
      data: recipes,
      pagination: {
        page,
        limit,
        total,
        totalPages: Math.ceil(total / limit),
        hasNext: page * limit < total,
        hasPrev: page > 1,
      },
    });
  } catch (error) {
    console.error(error);
    return NextResponse.json(
      { error: "Failed to fetch recipes" },
      { status: 500 }
    );
  }
}

// Still in app/api/v1/recipes/route.ts
 
export async function POST(request: NextRequest) {
  const authResult = await validateApiKey(request);
  if (!authResult.valid) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }
 
  try {
    const body = await request.json();
    const {
      name,
      description,
      country,
      region,
      category,
      ingredients,
      steps,
      prepTime,
      cookTime,
      servings,
      imageUrl,
      tags,
    } = body;
 
    // Basic validation
    if (!name || !country || !category || !ingredients || !steps) {
      return NextResponse.json(
        {
          error:
            "Missing required fields: name, country, category, ingredients, steps",
        },
        { status: 400 }
      );
    }
 
    const recipe = await db.recipe.create({
      data: {
        name,
        description,
        country,
        region,
        category,
        ingredients,
        steps,
        prepTime,
        cookTime,
        servings,
        imageUrl,
        tags: tags ?? [],
      },
    });
 
    return NextResponse.json({ data: recipe }, { status: 201 });
  } catch (error) {
    console.error(error);
    return NextResponse.json(
      { error: "Failed to create recipe" },
      { status: 500 }
    );
  }
}

// app/api/v1/recipes/[id]/route.ts
import { NextRequest, NextResponse } from "next/server";
import db from "@/lib/prisma";
import { validateApiKey } from "@/lib/api-key";
 
type Params = { params: Promise<{ id: string }> };
 
export async function GET(request: NextRequest, { params }: Params) {
  const authResult = await validateApiKey(request);
  if (!authResult.valid) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }
 
  try {
    const { id } = await params;
    const recipe = await db.recipe.findUnique({ where: { id } });
 
    if (!recipe) {
      return NextResponse.json({ error: "Recipe not found" }, { status: 404 });
    }
 
    return NextResponse.json({ data: recipe });
  } catch (error) {
    return NextResponse.json(
      { error: "Failed to fetch recipe" },
      { status: 500 }
    );
  }
}
 
export async function PATCH(request: NextRequest, { params }: Params) {
  const authResult = await validateApiKey(request);
  if (!authResult.valid) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }
 
  try {
    const { id } = await params;
    const body = await request.json();
 
    const recipe = await db.recipe.update({
      where: { id },
      data: body,
    });
 
    return NextResponse.json({ data: recipe });
  } catch (error) {
    return NextResponse.json(
      { error: "Failed to update recipe" },
      { status: 500 }
    );
  }
}
 
export async function DELETE(request: NextRequest, { params }: Params) {
  const authResult = await validateApiKey(request);
  if (!authResult.valid) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }
 
  try {
    const { id } = await params;
    await db.recipe.delete({ where: { id } });
    return new NextResponse(null, { status: 204 });
  } catch (error) {
    return NextResponse.json(
      { error: "Failed to delete recipe" },
      { status: 500 }
    );
  }
}

// lib/generate-api-key.ts
import crypto from "crypto";
 
export function generateApiKey(): string {
  // Format: lapi_<32 random hex chars>
  // The prefix makes it easy to identify and scan for accidental leaks
  const random = crypto.randomBytes(32).toString("hex");
  return `lapi_${random}`;
}

// actions/api-keys.ts
"use server";
 
import { generateApiKey } from "@/lib/generate-api-key";
import db from "@/lib/prisma";
import { getAuthenticatedUser } from "@/lib/auth"; // from Better Auth setup
import { revalidatePath } from "next/cache";
 
export async function createApiKey(name: string) {
  const user = await getAuthenticatedUser();
  if (!user) {
    return { success: false, data: null, error: "Not authenticated" };
  }
 
  const key = generateApiKey();
 
  // Ensure uniqueness (astronomically unlikely but worth checking)
  const existing = await db.apiKey.findUnique({ where: { key } });
  if (existing) {
    return {
      success: false,
      data: null,
      error: "Key collision, please try again",
    };
  }
 
  const apiKey = await db.apiKey.create({
    data: { userId: user.id, name, key },
  });
 
  revalidatePath("/dashboard/api-keys");
  return { success: true, data: apiKey, error: null };
}
 
export async function getUserApiKeys() {
  const user = await getAuthenticatedUser();
  if (!user) return [];
 
  return db.apiKey.findMany({
    where: { userId: user.id },
    orderBy: { createdAt: "desc" },
  });
}
 
export async function deleteApiKey(id: string) {
  const user = await getAuthenticatedUser();
  if (!user) return { success: false };
 
  await db.apiKey.delete({
    where: { id, userId: user.id }, // Ensures users can only delete their own keys
  });
 
  revalidatePath("/dashboard/api-keys");
  return { success: true };
}

// lib/api-key.ts
import { NextRequest } from "next/server";
import db from "@/lib/prisma";
 
interface ValidationResult {
  valid: boolean;
  apiKeyId?: string;
  userId?: string;
}
 
export async function validateApiKey(
  request: NextRequest
): Promise<ValidationResult> {
  // Clients should send the key in the Authorization header:
  // Authorization: Bearer lapi_xxxxx
  // OR as a custom header: x-api-key: lapi_xxxxx
  const authHeader = request.headers.get("authorization");
  const xApiKey = request.headers.get("x-api-key");
 
  let key: string | null = null;
 
  if (authHeader?.startsWith("Bearer ")) {
    key = authHeader.slice(7);
  } else if (xApiKey) {
    key = xApiKey;
  }
 
  if (!key) {
    return { valid: false };
  }
 
  const apiKey = await db.apiKey.findUnique({
    where: { key },
    select: { id: true, userId: true },
  });
 
  if (!apiKey) {
    return { valid: false };
  }
 
  // Update usage stats asynchronously (do not await — do not slow down the response)
  db.apiKey
    .update({
      where: { id: apiKey.id },
      data: {
        usageCount: { increment: 1 },
        lastUsedAt: new Date(),
      },
    })
    .catch(console.error);
 
  return { valid: true, apiKeyId: apiKey.id, userId: apiKey.userId };
}

# Option 1: Authorization header (recommended)
curl https://your-api.com/api/v1/recipes \
  -H "Authorization: Bearer lapi_your_key_here"
 
# Option 2: x-api-key header
curl https://your-api.com/api/v1/recipes \
  -H "x-api-key: lapi_your_key_here"

const response = await fetch(
  "https://your-api.com/api/v1/recipes?country=Uganda",
  {
    headers: {
      Authorization: "Bearer lapi_your_key_here",
      "Content-Type": "application/json",
    },
  }
);
 
const data = await response.json();
console.log(data);

pnpm dlx shadcn@latest add https://ui-components.desishub.com/r/scalar-api-docs.json

// data/openapi.ts
export const openApiSpec = {
  openapi: "3.0.3",
  info: {
    title: "Uganda Local Recipes API",
    description:
      "A comprehensive API for traditional Ugandan and East African recipes. Perfect for food apps, AI assistants, and culinary platforms.",
    version: "1.0.0",
    contact: {
      name: "API Support",
      email: "support@your-api.com",
      url: "https://your-api.com/help",
    },
  },
  servers: [
    {
      url: "https://your-api.com",
      description: "Production",
    },
    {
      url: "http://localhost:3000",
      description: "Development",
    },
  ],
  components: {
    securitySchemes: {
      ApiKeyAuth: {
        type: "apiKey",
        in: "header",
        name: "x-api-key",
        description:
          "Your API key. Get one from your dashboard at https://your-api.com/dashboard",
      },
    },
    schemas: {
      Recipe: {
        type: "object",
        properties: {
          id: { type: "string", example: "clx1abc123" },
          name: { type: "string", example: "Rolex (Ugandan Street Food)" },
          description: {
            type: "string",
            example: "A popular Ugandan street snack...",
          },
          country: { type: "string", example: "Uganda" },
          region: { type: "string", example: "Central Uganda" },
          category: { type: "string", example: "Street Food" },
          ingredients: { type: "array", items: { type: "string" } },
          steps: { type: "array", items: { type: "string" } },
          prepTime: { type: "integer", example: 10 },
          cookTime: { type: "integer", example: 15 },
          servings: { type: "integer", example: 1 },
        },
      },
    },
  },
  security: [{ ApiKeyAuth: [] }],
  paths: {
    "/api/v1/recipes": {
      get: {
        summary: "List all recipes",
        description:
          "Returns a paginated list of recipes. Supports filtering by country, category, and full-text search.",
        operationId: "getRecipes",
        tags: ["Recipes"],
        parameters: [
          {
            name: "country",
            in: "query",
            schema: { type: "string" },
            example: "Uganda",
          },
          {
            name: "category",
            in: "query",
            schema: { type: "string" },
            example: "Main Course",
          },
          {
            name: "search",
            in: "query",
            schema: { type: "string" },
            example: "matooke",
          },
          {
            name: "page",
            in: "query",
            schema: { type: "integer", default: 1 },
          },
          {
            name: "limit",
            in: "query",
            schema: { type: "integer", default: 20 },
          },
        ],
        responses: {
          "200": {
            description: "Successful response",
            content: {
              "application/json": {
                schema: {
                  type: "object",
                  properties: {
                    data: {
                      type: "array",
                      items: { $ref: "#/components/schemas/Recipe" },
                    },
                    pagination: { type: "object" },
                  },
                },
              },
            },
          },
          "401": { description: "Unauthorized — invalid or missing API key" },
        },
      },
    },
    "/api/v1/recipes/{id}": {
      get: {
        summary: "Get a single recipe",
        operationId: "getRecipeById",
        tags: ["Recipes"],
        parameters: [
          {
            name: "id",
            in: "path",
            required: true,
            schema: { type: "string" },
          },
        ],
        responses: {
          "200": { description: "Recipe found" },
          "404": { description: "Recipe not found" },
        },
      },
    },
  },
};

# Install zustand cart (required dependency)
pnpm dlx shadcn@latest add https://jb.desishub.com/r/zustand-cart.json
 
# Install the full Stripe UI component
pnpm dlx shadcn@latest add https://stripe-ui-component.desishub.com/r/stripe-ui-component.json

STRIPE_SECRET_KEY="sk_test_your_stripe_secret_key"
STRIPE_WEBHOOK_SECRET="whsec_your_webhook_secret"
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY="pk_test_your_publishable_key"

STRIPE_FREE_PRICE_ID="price_xxx"
STRIPE_STARTER_PRICE_ID="price_xxx"
STRIPE_GROWTH_PRICE_ID="price_xxx"
STRIPE_PRO_PRICE_ID="price_xxx"

// lib/api-key.ts — updated validateApiKey function
 
export async function validateApiKey(
  request: NextRequest
): Promise<ValidationResult> {
  // ... (key extraction from header, same as before)
 
  const apiKey = await db.apiKey.findUnique({
    where: { key },
    include: {
      user: {
        include: { subscription: true }, // Include their active plan
      },
    },
  });
 
  if (!apiKey) return { valid: false };
 
  // Check if they have exceeded their plan's monthly limit
  const plan = apiKey.user.subscription?.plan ?? "free";
  const limits: Record<string, number> = {
    free: 500,
    starter: 10_000,
    growth: 100_000,
    pro: Infinity,
  };
 
  const monthlyUsage = await db.apiUsageLog.count({
    where: {
      apiKeyId: apiKey.id,
      timestamp: {
        gte: new Date(new Date().getFullYear(), new Date().getMonth(), 1),
      },
    },
  });
 
  if (monthlyUsage >= limits[plan]) {
    return {
      valid: false,
      error: `Monthly limit of ${limits[plan]} requests reached. Upgrade your plan at https://your-api.com/pricing`,
    };
  }
 
  // Log this request
  db.apiUsageLog
    .create({
      data: {
        apiKeyId: apiKey.id,
        endpoint: request.nextUrl.pathname,
        method: request.method,
        statusCode: 200,
      },
    })
    .catch(console.error);
 
  return { valid: true, apiKeyId: apiKey.id, userId: apiKey.user.id };
}

pnpm dlx shadcn@latest add https://ui-components.desishub.com/r/website-ui.json

// config/site.ts
export const siteConfig = {
  name: "UgandaRecipes API",
  tagline: "The World's First Comprehensive Ugandan Recipe API",
  description:
    "Give your app authentic Ugandan and East African recipe data. Trusted by food delivery platforms, AI assistants, and culinary apps.",
  url: "https://ugandafoodsapi.com",
  ogImage: "https://ugandafoodsapi.com/og.png",
  links: {
    twitter: "https://twitter.com/yourhandle",
    github: "https://github.com/yourorg",
    docs: "/api-docs",
    pricing: "/pricing",
  },
};

// app/dashboard/api-keys/page.tsx
import { getUserApiKeys } from "@/actions/api-keys";
import { ApiKeyManagement } from "@/components/dashboard/api-key-management";
import { getAuthenticatedUser } from "@/lib/auth";
import { redirect } from "next/navigation";
 
export default async function ApiKeysPage() {
  const user = await getAuthenticatedUser();
  if (!user) redirect("/auth/sign-in");
 
  const apiKeys = await getUserApiKeys();
 
  return (
    <div className="container mx-auto py-8 px-4">
      <div className="mb-6">
        <h1 className="text-2xl font-bold">API Keys</h1>
        <p className="text-muted-foreground">
          Manage your API keys. Keep them secret — treat them like passwords.
        </p>
      </div>
      <ApiKeyManagement orgKeys={apiKeys} />
    </div>
  );
}

docker run -d \
  --name postgres \
  -e POSTGRES_PASSWORD=strongpassword \
  -e POSTGRES_DB=myapi \
  -p 5432:5432 \
  -v pgdata:/var/lib/postgresql/data \
  postgres:16-alpine

// prisma/seed.ts
import db from "../lib/prisma";
import { Prisma } from "../app/generated/prisma/client";
 
const recipes = [
  {
    name: "Rolex",
    description:
      "Uganda's most popular street food — a chapati rolled around a fried egg and vegetables.",
    country: "Uganda",
    region: "Central Uganda",
    category: "Street Food",
    ingredients: [
      "2 eggs",
      "1 chapati",
      "1/4 cabbage shredded",
      "1 tomato sliced",
      "1/4 onion sliced",
      "Salt to taste",
      "Cooking oil",
    ],
    steps: [
      "Beat the eggs with a pinch of salt.",
      "Heat oil in a pan over medium heat.",
      "Fry the egg like an omelette, placing the chapati on top before it fully sets.",
      "Flip briefly, then remove from heat.",
      "Add shredded cabbage, tomato, and onion on the egg.",
      "Roll the chapati tightly around the filling.",
      "Serve immediately.",
    ],
    prepTime: 5,
    cookTime: 10,
    servings: 1,
    tags: ["street food", "breakfast", "quick", "popular"],
  },
  // Add 20+ more recipes before launching
];
 
async function main() {
  console.log("Seeding database...");
  for (const recipe of recipes) {
    await db.recipe.upsert({
      where: { name: recipe.name } as any,
      update: recipe,
      create: recipe,
    });
  }
  console.log(`Seeded ${recipes.length} recipes.`);
}
 
main()
  .catch(console.error)
  .finally(() => db.$disconnect());

// lib/rate-limiter.ts
 
interface RateLimitEntry {
  count: number;
  windowStart: number;
}
 
// In-memory store: apiKeyId → { count, windowStart }
// Note: this resets on server restart and does not work across multiple
// server instances. For multi-instance production, use Redis (Option 2).
const store = new Map<string, RateLimitEntry>();
 
interface RateLimitConfig {
  windowMs: number; // e.g. 60_000 for 1 minute
  maxRequests: number; // e.g. 60 requests per window
}
 
const PLAN_LIMITS: Record<string, RateLimitConfig> = {
  free: { windowMs: 60_000, maxRequests: 10 }, // 10 req/min
  starter: { windowMs: 60_000, maxRequests: 60 }, // 60 req/min
  growth: { windowMs: 60_000, maxRequests: 300 }, // 300 req/min
  pro: { windowMs: 60_000, maxRequests: 1000 }, // 1000 req/min
};
 
export interface RateLimitResult {
  allowed: boolean;
  limit: number;
  remaining: number;
  resetAt: number; // Unix timestamp (ms) when the window resets
}
 
export function checkRateLimit(
  identifier: string,
  plan: string
): RateLimitResult {
  const config = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
  const now = Date.now();
  const entry = store.get(identifier);
 
  // If no entry or window has expired, start a fresh window
  if (!entry || now - entry.windowStart >= config.windowMs) {
    store.set(identifier, { count: 1, windowStart: now });
    return {
      allowed: true,
      limit: config.maxRequests,
      remaining: config.maxRequests - 1,
      resetAt: now + config.windowMs,
    };
  }
 
  // Within the current window
  if (entry.count >= config.maxRequests) {
    return {
      allowed: false,
      limit: config.maxRequests,
      remaining: 0,
      resetAt: entry.windowStart + config.windowMs,
    };
  }
 
  entry.count += 1;
  return {
    allowed: true,
    limit: config.maxRequests,
    remaining: config.maxRequests - entry.count,
    resetAt: entry.windowStart + config.windowMs,
  };
}

// lib/api-key.ts — add rate limiting
import { NextRequest, NextResponse } from "next/server";
import db from "@/lib/prisma";
import { checkRateLimit } from "@/lib/rate-limiter";
 
export async function withApiKeyAuth(
  request: NextRequest,
  handler: (req: NextRequest, userId: string) => Promise<NextResponse>
): Promise<NextResponse> {
  const key =
    request.headers.get("x-api-key") ??
    request.headers.get("authorization")?.replace("Bearer ", "");
 
  if (!key) {
    return NextResponse.json(
      {
        error:
          "Missing API key. Include it as x-api-key or Authorization: Bearer <key>",
      },
      { status: 401 }
    );
  }
 
  const apiKey = await db.apiKey.findUnique({
    where: { key },
    include: { user: { include: { subscription: true } } },
  });
 
  if (!apiKey) {
    return NextResponse.json({ error: "Invalid API key" }, { status: 401 });
  }
 
  const plan = apiKey.user.subscription?.plan ?? "free";
 
  // Check rate limit
  const rateLimit = checkRateLimit(apiKey.id, plan);
 
  if (!rateLimit.allowed) {
    return NextResponse.json(
      {
        error: "Rate limit exceeded. Slow down your requests.",
        retryAfter: Math.ceil((rateLimit.resetAt - Date.now()) / 1000),
      },
      {
        status: 429,
        headers: {
          "X-RateLimit-Limit": String(rateLimit.limit),
          "X-RateLimit-Remaining": "0",
          "X-RateLimit-Reset": String(rateLimit.resetAt),
          "Retry-After": String(
            Math.ceil((rateLimit.resetAt - Date.now()) / 1000)
          ),
        },
      }
    );
  }
 
  // Fire-and-forget usage tracking
  db.apiKey
    .update({
      where: { id: apiKey.id },
      data: { usageCount: { increment: 1 }, lastUsedAt: new Date() },
    })
    .catch(console.error);
 
  db.apiUsageLog
    .create({
      data: {
        apiKeyId: apiKey.id,
        endpoint: request.nextUrl.pathname,
        method: request.method,
        statusCode: 200,
      },
    })
    .catch(console.error);
 
  // Attach rate limit headers to every successful response too
  const response = await handler(request, apiKey.userId);
  response.headers.set("X-RateLimit-Limit", String(rateLimit.limit));
  response.headers.set("X-RateLimit-Remaining", String(rateLimit.remaining));
  response.headers.set("X-RateLimit-Reset", String(rateLimit.resetAt));
  return response;
}

// app/api/v1/recipes/route.ts — cleaner with wrapper
import { NextRequest, NextResponse } from "next/server";
import db from "@/lib/prisma";
import { withApiKeyAuth } from "@/lib/api-key";
 
export async function GET(request: NextRequest) {
  return withApiKeyAuth(request, async (req, userId) => {
    // Your full GET handler logic here
    const recipes = await db.recipe.findMany({ take: 20 });
    return NextResponse.json({ data: recipes });
  });
}

pnpm add @upstash/ratelimit @upstash/redis

// lib/redis-rate-limiter.ts
import { Ratelimit } from "@upstash/ratelimit";
import { Redis } from "@upstash/redis";
 
const redis = new Redis({
  url: process.env.UPSTASH_REDIS_REST_URL!,
  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
});
 
// Plan-specific limiters using sliding window algorithm
export const rateLimiters: Record<string, Ratelimit> = {
  free: new Ratelimit({
    redis,
    limiter: Ratelimit.slidingWindow(10, "1 m"), // 10/min
    prefix: "rl:free",
  }),
  starter: new Ratelimit({
    redis,
    limiter: Ratelimit.slidingWindow(60, "1 m"), // 60/min
    prefix: "rl:starter",
  }),
  growth: new Ratelimit({
    redis,
    limiter: Ratelimit.slidingWindow(300, "1 m"), // 300/min
    prefix: "rl:growth",
  }),
  pro: new Ratelimit({
    redis,
    limiter: Ratelimit.slidingWindow(1000, "1 m"), // 1000/min
    prefix: "rl:pro",
  }),
};

UPSTASH_REDIS_REST_URL="https://xxx.upstash.io"
UPSTASH_REDIS_REST_TOKEN="your_token"

const limiter = rateLimiters[plan] ?? rateLimiters.free;
const { success, limit, remaining, reset } = await limiter.limit(apiKey.id);
 
if (!success) {
  return NextResponse.json(
    {
      error: "Rate limit exceeded",
      retryAfter: Math.ceil((reset - Date.now()) / 1000),
    },
    {
      status: 429,
      headers: {
        "Retry-After": String(Math.ceil((reset - Date.now()) / 1000)),
      },
    }
  );
}

// src/types.ts
 
export interface Recipe {
  id: string;
  name: string;
  description: string | null;
  country: string;
  region: string | null;
  category: string;
  ingredients: string[];
  steps: string[];
  prepTime: number;
  cookTime: number;
  servings: number;
  imageUrl: string | null;
  tags: string[];
  createdAt: string;
  updatedAt: string;
}
 
export interface PaginatedResponse<T> {
  data: T[];
  pagination: {
    page: number;
    limit: number;
    total: number;
    totalPages: number;
    hasNext: boolean;
    hasPrev: boolean;
  };
}
 
export interface ListRecipesParams {
  country?: string;
  category?: string;
  search?: string;
  page?: number;
  limit?: number;
}
 
export interface ApiError {
  error: string;
  status: number;
  message: string;
}

// src/resources/recipes.ts
import type { Recipe, PaginatedResponse, ListRecipesParams } from "../types";
 
export class RecipesResource {
  constructor(
    private readonly client: {
      request: <T>(path: string, options?: RequestInit) => Promise<T>;
    }
  ) {}
 
  async list(
    params: ListRecipesParams = {}
  ): Promise<PaginatedResponse<Recipe>> {
    const qs = new URLSearchParams();
    if (params.country) qs.set("country", params.country);
    if (params.category) qs.set("category", params.category);
    if (params.search) qs.set("search", params.search);
    if (params.page) qs.set("page", String(params.page));
    if (params.limit) qs.set("limit", String(params.limit));
 
    const query = qs.toString() ? `?${qs.toString()}` : "";
    return this.client.request<PaginatedResponse<Recipe>>(
      `/api/v1/recipes${query}`
    );
  }
 
  async get(id: string): Promise<{ data: Recipe }> {
    return this.client.request<{ data: Recipe }>(`/api/v1/recipes/${id}`);
  }
}

// src/client.ts
import { RecipesResource } from "./resources/recipes";
 
export interface LocalApiClientOptions {
  apiKey: string;
  baseUrl?: string;
}
 
export class LocalApiClient {
  private readonly apiKey: string;
  private readonly baseUrl: string;
 
  public readonly recipes: RecipesResource;
 
  constructor(options: LocalApiClientOptions) {
    if (!options.apiKey) {
      throw new Error("LocalApiClient: apiKey is required");
    }
    this.apiKey = options.apiKey;
    this.baseUrl = options.baseUrl ?? "https://your-api.com";
    this.recipes = new RecipesResource({ request: this.request.bind(this) });
  }
 
  async request<T>(path: string, options: RequestInit = {}): Promise<T> {
    const url = `${this.baseUrl}${path}`;
 
    const response = await fetch(url, {
      ...options,
      headers: {
        "Content-Type": "application/json",
        "x-api-key": this.apiKey,
        ...options.headers,
      },
    });
 
    if (!response.ok) {
      const body = await response.json().catch(() => ({}));
      throw Object.assign(
        new Error(body.error ?? `API request failed: ${response.status}`),
        { status: response.status, body }
      );
    }
 
    return response.json() as Promise<T>;
  }
}

// src/index.ts
export { LocalApiClient } from "./client";
export type { LocalApiClientOptions } from "./client";
export type {
  Recipe,
  PaginatedResponse,
  ListRecipesParams,
  ApiError,
} from "./types";

{
  "name": "uganda-recipes-api",
  "version": "1.0.0",
  "description": "Official JavaScript/TypeScript SDK for the Uganda Recipes API",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "exports": {
    ".": {
      "import": "./dist/index.mjs",
      "require": "./dist/index.js",
      "types": "./dist/index.d.ts"
    }
  },
  "scripts": {
    "build": "tsup src/index.ts --format cjs,esm --dts",
    "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
  },
  "devDependencies": {
    "tsup": "^8.0.0",
    "typescript": "^5.0.0"
  }
}

pnpm add -D tsup typescript
pnpm build

# Login to npm (create account at npmjs.com if needed)
npm login
 
# Publish
npm publish --access public

// In a developer's project
import { LocalApiClient } from "uganda-recipes-api";
 
const client = new LocalApiClient({ apiKey: "lapi_your_key_here" });
 
// List Ugandan street food
const result = await client.recipes.list({
  country: "Uganda",
  category: "Street Food",
  page: 1,
  limit: 10,
});
 
console.log(result.data); // Array of Recipe objects
console.log(result.pagination); // { page, total, totalPages, ... }
 
// Get a single recipe
const { data: recipe } = await client.recipes.get("clx1abc123");
console.log(recipe.name); // "Rolex"
console.log(recipe.ingredients); // ["2 eggs", "1 chapati", ...]

# python-sdk/uganda_recipes_api/__init__.py
from .client import LocalApiClient
from .types import Recipe, PaginatedResponse
 
__all__ = ["LocalApiClient", "Recipe", "PaginatedResponse"]

# python-sdk/uganda_recipes_api/client.py
from dataclasses import dataclass
from typing import Optional, List, Any, Dict
import urllib.request
import urllib.parse
import json
 
 
@dataclass
class Recipe:
    id:          str
    name:        str
    country:     str
    category:    str
    ingredients: List[str]
    steps:       List[str]
    prep_time:   int
    cook_time:   int
    servings:    int
    description: Optional[str] = None
    region:      Optional[str] = None
    image_url:   Optional[str] = None
    tags:        Optional[List[str]] = None
 
    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> "Recipe":
        return cls(
            id=data["id"],
            name=data["name"],
            country=data["country"],
            category=data["category"],
            ingredients=data["ingredients"],
            steps=data["steps"],
            prep_time=data["prepTime"],
            cook_time=data["cookTime"],
            servings=data["servings"],
            description=data.get("description"),
            region=data.get("region"),
            image_url=data.get("imageUrl"),
            tags=data.get("tags", []),
        )
 
 
class LocalApiClient:
    def __init__(self, api_key: str, base_url: str = "https://your-api.com"):
        if not api_key:
            raise ValueError("api_key is required")
        self.api_key  = api_key
        self.base_url = base_url.rstrip("/")
 
    def _request(self, path: str, params: Optional[Dict] = None) -> Any:
        url = f"{self.base_url}{path}"
        if params:
            filtered = {k: str(v) for k, v in params.items() if v is not None}
            url += "?" + urllib.parse.urlencode(filtered)
 
        req = urllib.request.Request(url, headers={"x-api-key": self.api_key})
        with urllib.request.urlopen(req) as response:
            return json.loads(response.read().decode())
 
    def list_recipes(
        self,
        country:  Optional[str] = None,
        category: Optional[str] = None,
        search:   Optional[str] = None,
        page:     int = 1,
        limit:    int = 20,
    ) -> Dict[str, Any]:
        raw = self._request("/api/v1/recipes", {
            "country":  country,
            "category": category,
            "search":   search,
            "page":     page,
            "limit":    limit,
        })
        raw["data"] = [Recipe.from_dict(r) for r in raw["data"]]
        return raw
 
    def get_recipe(self, recipe_id: str) -> Recipe:
        raw = self._request(f"/api/v1/recipes/{recipe_id}")
        return Recipe.from_dict(raw["data"])

from uganda_recipes_api import LocalApiClient
 
client = LocalApiClient(api_key="lapi_your_key_here")
 
# Use in a LangChain tool or n8n Python node
recipes = client.list_recipes(country="Uganda", category="Main Course")
 
for recipe in recipes["data"]:
    print(f"{recipe.name}: {', '.join(recipe.ingredients[:3])}...")
 
# Get a single recipe for an AI cooking assistant
recipe = client.get_recipe("clx1abc123")
print(f"To make {recipe.name}, you need {recipe.prep_time + recipe.cook_time} minutes total.")

cd python-sdk
pip install build twine
python -m build
twine upload dist/*

pnpm dlx prisma studio

// scripts/generate-recipes-with-ai.ts
import Anthropic from "@anthropic-ai/sdk";
import db from "../lib/prisma";
 
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
 
async function generateRecipes(country: string, count: number = 10) {
  console.log(`Generating ${count} recipes for ${country}...`);
 
  const message = await anthropic.messages.create({
    model: "claude-opus-4-6",
    max_tokens: 4096,
    messages: [
      {
        role: "user",
        content: `Generate ${count} authentic traditional ${country} recipes.
 
Return ONLY a valid JSON array. No explanation, no markdown, just the raw JSON array.
 
Each recipe must follow this exact structure:
{
  "name": "Recipe Name",
  "description": "One sentence description",
  "country": "${country}",
  "region": "Specific region or null",
  "category": "One of: Breakfast, Main Course, Side Dish, Snack, Street Food, Dessert, Drink",
  "ingredients": ["quantity + ingredient", ...],
  "steps": ["Step instruction", ...],
  "prepTime": <integer minutes>,
  "cookTime": <integer minutes>,
  "servings": <integer>,
  "tags": ["tag1", "tag2", ...]
}
 
Make sure:
- Ingredients include realistic quantities (e.g. "2 cups maize flour", "1 medium onion")
- Steps are clear and numbered in order
- Recipes are genuinely traditional and authentic to ${country}
- Include a variety of categories`,
      },
    ],
  });
 
  const text =
    message.content[0].type === "text" ? message.content[0].text : "";
 
  let recipes: any[];
  try {
    recipes = JSON.parse(text);
  } catch {
    // Sometimes the model adds a small preamble — strip it
    const jsonMatch = text.match(/\[[\s\S]*\]/);
    if (!jsonMatch) throw new Error("Could not parse AI response as JSON");
    recipes = JSON.parse(jsonMatch[0]);
  }
 
  console.log(`  Parsed ${recipes.length} recipes. Inserting into database...`);
 
  let inserted = 0;
  for (const recipe of recipes) {
    try {
      await db.recipe.create({ data: recipe });
      inserted++;
    } catch (err: any) {
      // Skip duplicates silently
      if (!err.message?.includes("Unique constraint")) {
        console.warn(`  Skipped "${recipe.name}":`, err.message);
      }
    }
  }
 
  console.log(`  Inserted ${inserted} new recipes for ${country}.`);
}
 
async function main() {
  const countries = ["Uganda", "Kenya", "Nigeria", "Ghana", "Ethiopia"];
 
  for (const country of countries) {
    await generateRecipes(country, 20);
    // Small delay to avoid hitting API rate limits
    await new Promise((r) => setTimeout(r, 1000));
  }
 
  const total = await db.recipe.count();
  console.log(`\nDone! Total recipes in database: ${total}`);
}
 
main()
  .catch(console.error)
  .finally(() => db.$disconnect());

pnpm add @anthropic-ai/sdk
ANTHROPIC_API_KEY=sk-ant-xxx npx ts-node --compiler-options '{"module":"CommonJS"}' scripts/generate-recipes-with-ai.ts

pnpm add cheerio axios
pnpm add -D @types/cheerio
# For JS-rendered pages:
pnpm add playwright

// scripts/scrape-university-courses.ts
import axios from "axios";
import * as cheerio from "cheerio";
import db from "../lib/prisma";
 
interface CourseData {
  name: string;
  code: string;
  faculty: string;
  level: string; // "Diploma", "Degree", "Masters", "PhD"
  duration: string; // e.g. "3 years"
  entryRequirements: string;
  university: string;
  country: string;
}
 
async function scrapeMakerereCoursesPage(url: string): Promise<CourseData[]> {
  const { data: html } = await axios.get(url, {
    headers: {
      // Mimic a real browser to avoid simple bot blocks
      "User-Agent": "Mozilla/5.0 (compatible; DataCollectionBot/1.0)",
    },
    timeout: 15_000,
  });
 
  const $ = cheerio.load(html);
  const courses: CourseData[] = [];
 
  // This selector will differ per site — inspect the HTML structure first
  $(".course-item, .programme-row, tr.course").each((_, element) => {
    const name = $(element).find(".course-name, td:nth-child(1)").text().trim();
    const code = $(element).find(".course-code, td:nth-child(2)").text().trim();
    const faculty = $(element).find(".faculty, td:nth-child(3)").text().trim();
    const level = $(element).find(".level, td:nth-child(4)").text().trim();
 
    if (name && faculty) {
      courses.push({
        name,
        code: code || "N/A",
        faculty,
        level: level || "Degree",
        duration: "3 years",
        entryRequirements: "A-Level passes or equivalent",
        university: "Makerere University",
        country: "Uganda",
      });
    }
  });
 
  return courses;
}
 
async function main() {
  console.log("Scraping university courses...");
 
  const courses = await scrapeMakerereCoursesPage(
    "https://www.mak.ac.ug/programmes"
  );
 
  console.log(`Found ${courses.length} courses. Inserting...`);
 
  for (const course of courses) {
    await db.course.upsert({
      where: {
        code_university: { code: course.code, university: course.university },
      },
      update: course,
      create: course,
    });
  }
 
  console.log("Done.");
}
 
main()
  .catch(console.error)
  .finally(() => db.$disconnect());

model Recipe {
  // ... existing fields
  status     String  @default("pending")   // "pending" | "approved" | "rejected"
  submittedBy String?
}

const where: any = { status: "approved" };

// lib/billing.ts — overage calculation example
 
const PLAN_MONTHLY_LIMITS: Record<string, number> = {
  free: 500,
  starter: 10_000,
  growth: 100_000,
};
 
const OVERAGE_RATE_PER_1000 = 0.5; // $0.50 per 1,000 extra calls
 
export function calculateOverageCharge(
  plan: string,
  totalCalls: number
): number {
  const limit = PLAN_MONTHLY_LIMITS[plan];
  if (!limit || totalCalls <= limit) return 0;
 
  const extraCalls = totalCalls - limit;
  return Math.ceil(extraCalls / 1000) * OVERAGE_RATE_PER_1000;
}

pnpm add flutterwave-node-v3

// lib/flutterwave.ts
const Flutterwave = require("flutterwave-node-v3");
 
const flw = new Flutterwave(
  process.env.FLW_PUBLIC_KEY,
  process.env.FLW_SECRET_KEY
);
 
export interface MobileMoneyPaymentParams {
  amount: number;
  currency: "UGX" | "KES" | "GHS" | "NGN";
  email: string;
  phoneNumber: string;
  network: "MTN" | "AIRTEL" | "MPESA" | "VODAFONE";
  userId: string;
  planId: string;
}
 
export async function initiateMobileMoneyPayment(
  params: MobileMoneyPaymentParams
) {
  const txRef = `api_sub_${params.userId}_${Date.now()}`;
 
  // Network-to-endpoint mapping
  const networkPayload: any = {
    amount: params.amount,
    currency: params.currency,
    email: params.email,
    tx_ref: txRef,
    phone_number: params.phoneNumber,
    network: params.network,
    meta: {
      userId: params.userId,
      planId: params.planId,
    },
  };
 
  let response;
  if (params.network === "MPESA") {
    // M-Pesa (Kenya) uses a different endpoint
    response = await flw.MobileMoney.mpesa(networkPayload);
  } else {
    response = await flw.MobileMoney.uganda(networkPayload);
  }
 
  return { txRef, response };
}

// app/api/webhooks/flutterwave/route.ts
import { NextRequest, NextResponse } from "next/server";
import db from "@/lib/prisma";
import crypto from "crypto";
 
export async function POST(request: NextRequest) {
  const secretHash = process.env.FLW_WEBHOOK_SECRET!;
  const signature = request.headers.get("verif-hash");
 
  // Verify the webhook is genuinely from Flutterwave
  if (signature !== secretHash) {
    return NextResponse.json({ error: "Invalid signature" }, { status: 401 });
  }
 
  const payload = await request.json();
 
  if (
    payload.event === "charge.completed" &&
    payload.data.status === "successful"
  ) {
    const { userId, planId } = payload.data.meta;
 
    // Activate the subscription
    await db.subscription.upsert({
      where: { userId },
      update: { plan: planId, status: "active", updatedAt: new Date() },
      create: { userId, plan: planId, status: "active" },
    });
 
    console.log(`Activated ${planId} plan for user ${userId} via Flutterwave`);
  }
 
  return NextResponse.json({ received: true });
}

model User {
  // ... existing fields
  apiCredits Int @default(0)  // Prepaid request credits
}

// In validateApiKey — check credits if no active subscription
if (!activeSubscription) {
  if (apiKey.user.apiCredits <= 0) {
    return {
      valid: false,
      error: "No credits remaining. Top up at /dashboard/billing",
    };
  }
  // Deduct one credit
  db.user
    .update({
      where: { id: apiKey.userId },
      data: { apiCredits: { decrement: 1 } },
    })
    .catch(console.error);
}

# Stripe
STRIPE_SECRET_KEY="sk_live_xxx"
STRIPE_WEBHOOK_SECRET="whsec_xxx"
NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY="pk_live_xxx"
 
# Flutterwave
FLW_PUBLIC_KEY="FLWPUBK_TEST-xxx"
FLW_SECRET_KEY="FLWSECK_TEST-xxx"
FLW_WEBHOOK_SECRET="your_custom_hash_secret"
 
# Currency conversion (for consistent pricing)
# Show USD to international users, local currency to African users
NEXT_PUBLIC_DEFAULT_CURRENCY="USD"

// lib/currency.ts
const EXCHANGE_RATES: Record<string, number> = {
  USD: 1,
  UGX: 3700, // Update periodically or use a live rates API
  KES: 130,
  NGN: 1500,
  GHS: 15,
};
 
const CURRENCY_SYMBOLS: Record<string, string> = {
  USD: "$",
  UGX: "UGX ",
  KES: "KES ",
  NGN: "₦",
  GHS: "₵",
};
 
export function formatPrice(usdAmount: number, currency: string): string {
  const rate = EXCHANGE_RATES[currency] ?? 1;
  const symbol = CURRENCY_SYMBOLS[currency] ?? "$";
  const local = Math.round(usdAmount * rate);
  return `${symbol}${local.toLocaleString()}`;
}
 
// Usage in your pricing page:
// formatPrice(9, "UGX")  → "UGX 33,300"
// formatPrice(9, "KES")  → "KES 1,170"
// formatPrice(9, "NGN")  → "₦13,500"