Recipes by app type

npx mainsdk check

$ npx mainsdk check
mainsdk check · notes · env dev · Main 27

   config    secrets    policy    network    auth    data

Passed · 6 gates · 0 findings · 1.2s

schema: 1
project: prj_01JC8Q4N7V3X9B2D5F6G8H0JKM
baseline: main27
secrets: { driver: env }
auth: { driver: github, methods: [passkeys] }
data: { store: postgres, residency: { default: eu } }
db:
  driver: postgres
  regions: { eu: secret:DATABASE_URL_EU }
access: { driver: cedar, models: [rbac, abac] }
payments: { driver: stripe }
pay:
  stripe: { key: secret:STRIPE_SECRET_KEY, webhook: secret:STRIPE_WEBHOOK_SECRET }
email: { driver: resend, key: secret:RESEND_API_KEY }
jobs: { driver: inngest, dead-letter: true }
idempotency: { store: db, ttl: 24h }
overlays: { order: [env] }

import { auth, models, pay, s } from "mainsdk";

const { orders } = models({
  orders: s.object({ item: s.string(), total: s.int() }),
}); // declared once in lib/orders.ts

export async function POST(req: Request) {
  const session = await auth.require(req);
  const input = (await req.json()) as { item: string; total: number; cartId: string };
  const order = await orders
    .for(session.user)
    .create({ item: input.item, total: input.total }, { idempotencyKey: input.cartId });

  const checkout = await pay.checkout({
    order: order.id,
    amount: 125000,                 // minor units
    currency: "INR",
    successUrl: "/orders/done",
    cancelUrl: "/cart",
  });
  return Response.json(checkout);   // { url } or { clientSecret }
}

import { email, jobs, pay } from "mainsdk";

pay.on("payment.succeeded", async (event) => {
  // the fields of event are [to be decided]; the order id and customer email come from it
  await email.send({ to: "[to be decided]", template: "receipt", data: { orderId: "[to be decided]" } });
  await jobs.run("orders.fulfil", { orderId: "[to be decided]" });   // retries with backoff, dead-letter queue on
});

ai:
  driver: anthropic                  # bedrock needs an AWS account; gateway is the alternative
  key: secret:ANTHROPIC_API_KEY
  models: [anthropic/claude-*]
  data: { training: never, retention: zero }
  redact: [personal, sensitive, child, phi]
  limits: { per-user: $1/day, per-feature: { chat: $200/month }, total: $500/month }
  label: true

import { ai, auth, MainError } from "mainsdk";

export async function POST(req: Request) {
  const session = await auth.require(req);
  const { messages } = (await req.json()) as { messages: { role: "user" | "assistant"; content: string }[] };

  const stream = ai.stream({
    model: "anthropic/claude-sonnet-4-5",
    feature: "chat",
    user: session.user,
    messages,
    maxCost: "$0.05",
  });

  const encoder = new TextEncoder();
  const body = new ReadableStream({
    async start(controller) {
      try {
        for await (const chunk of stream) controller.enqueue(encoder.encode(JSON.stringify(chunk) + "\n"));   // { type: "text", text } or { type: "done", usage, cost }
      } catch (err) {
        if (err instanceof MainError && err.code === "MAIN-AI-0007") {
          controller.enqueue(encoder.encode(JSON.stringify({ type: "limit" }) + "\n"));   // this app's own signal
        } else {
          throw err;
        }
      }
      controller.close();
    },
  });
  return new Response(body, { headers: { "content-type": "application/x-ndjson" } });
}

export async function readChat(
  messages: { role: string; content: string }[],
  onText: (text: string) => void,
) {
  const res = await fetch("/api/chat", {
    method: "POST",
    headers: { "content-type": "application/json" },
    body: JSON.stringify({ messages }),
  });
  if (!res.body) throw new Error("no stream");

  const reader = res.body.pipeThrough(new TextDecoderStream()).getReader();
  let buffer = "";
  while (true) {
    const { value, done } = await reader.read();
    if (done) break;
    buffer += value;
    const lines = buffer.split("\n");
    buffer = lines.pop() ?? "";
    for (const line of lines) {
      if (!line) continue;
      const chunk = JSON.parse(line);
      if (chunk.type === "text") onText(chunk.text);
      if (chunk.type === "done") return chunk;   // { usage, cost }
      if (chunk.type === "limit") throw new Error("limit reached");
    }
  }
}

import { ai, auth } from "mainsdk";
import { s } from "mainsdk/schema";

export async function POST(req: Request) {
  const session = await auth.require(req);
  const { text } = (await req.json()) as { text: string };

  const result = await ai.generate({
    model: "anthropic/claude-sonnet-4-5",
    feature: "tagging",
    user: session.user,
    prompt: `Tag this support message: ${text}`,
    schema: s.object({ tags: s.array(s.string()) }),
  });
  return Response.json(result.value);
}

search:
  driver: pgvector

import { ai, search } from "mainsdk";

export async function answer(question: string, user: { type: "user"; id: string }) {
  const hits = await search.query({ index: "notes", q: question, for: user, limit: 5 });   // results are limited to what this person may see
  return ai.generate({
    model: "anthropic/claude-sonnet-4-5",
    feature: "support-answer",
    user,
    prompt: `Answer from these notes only:\n${JSON.stringify(hits)}\n\nQuestion: ${question}`,
  });
}

files: { driver: getqr, key: secret:GETQR_API_KEY, scan: true, max-size: 25MB }
share: { default-expiry: 7d, max-expiry: 90d }
payments: { in: razorpay, default: stripe }
pay:
  stripe:   { key: secret:STRIPE_SECRET_KEY, webhook: secret:STRIPE_WEBHOOK_SECRET }
  razorpay: { key: secret:RAZORPAY_KEY, webhook: secret:RAZORPAY_WEBHOOK_SECRET, methods: [upi, cards] }
notify:
  channels: [push, whatsapp, sms, email]
  sms: msg91
  whatsapp: whatsapp-cloud
  quiet: { from: "22:00", to: "08:00" }

import { auth, models, notify, s, share } from "mainsdk";

const { works } = models({
  works: s.object({ title: s.string() }),
}); // declared once in lib/works.ts

export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const session = await auth.require(req);
  const work = await works.for(session.user).get(id);

  const { url, qr } = await share({ url: `https://app.example.com/works/${work.id}`, title: work.title }, { expiresIn: "7d", access: "read" });   // a getqr.id link
  await notify(session.user, { template: "work.shared", data: { workId: work.id }, category: "orders" });
  return Response.json({ url, qr });
}

realtime:
  driver: pusher

import { auth, realtime } from "mainsdk";

export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  await auth.require(req);
  const move = (await req.json()) as { card: string; column: string };
  await realtime.publish(`board:${id}`, "moved", move);   // channel access is checked per user and tenant
  return Response.json({ ok: true });
}

targets:
  web:    { framework: nextjs }
  mobile: { framework: expo, platforms: [ios, android], bundleId: dev.acme.orders }
notify:
  push: { drivers: [fcm, apns], via: expo }      # or fcm and apns directly

import { MainProvider } from "mainsdk/expo";      // wraps the app; loads the core

export default function Layout({ children }: { children: React.ReactNode }) {
  return <MainProvider>{children}</MainProvider>;
}

import { notify } from "mainsdk";

await notify.push.register();                      // asks permission, stores the token
await notify(user, { template: "order.shipped", category: "transactional" });

auth: { methods: [passkeys, wallet], wallet: { driver: siwe } }
access: { attributes: { token.balance: { driver: evm-balance } } }
agents:
  trader-bot:
    budget: { spend: $5/day, calls: 500/day }
    approve: { spend-over: $1 }
pay: { payees: { weather-api: { host: api.weather.example, max: $0.05/call } } }

import { auth } from "mainsdk";

export async function POST(req: Request) {
  const { message, signature } = (await req.json()) as { message: string; signature: string };
  const session = await auth.challenge.verify({ message, signature });   // MAIN-AUTH-0040 if the challenge was used before
  return Response.json({ ok: true });
}

schema: 1
project: prj_01JC8Q4N7V3X9B2D5F6G8H0JKM
baseline: main27
secrets: { driver: env }
auth: { driver: github, methods: [passkeys] }
db:
  driver: postgres
  regions: { eu: secret:DATABASE_URL_EU }
ai:
  driver: anthropic
  key: secret:ANTHROPIC_API_KEY
  models: [anthropic/claude-*]
  data: { training: never, retention: zero }
  limits: { per-user: $1/day, total: $500/month }
files:
  driver: s3
  bucket: acme-avatars
  region: eu-west-1
  access-key-id: AKIA…                      # an identifier, not a secret; on AWS omit it and key to use the runtime's IAM role
  key: secret:S3_SECRET_ACCESS_KEY
  scan: true
overlays: { order: [env] }

import { auth, files } from "mainsdk";

export async function POST(req: Request) {
  const session = await auth.require(req);
  const upload = await files.uploadUrl({
    owner: session.user,
    maxSize: "2MB",
    types: ["image/png", "image/jpeg"],
  });
  return Response.json(upload);   // { method, url, headers?, fields?, ref }
}

import { auth, files } from "mainsdk";

export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const session = await auth.require(req);
  const ref = await files.complete(id, { owner: session.user });  // only the uploader can finish it
  const url = await files.url(ref, { for: session.user, expiresIn: "1h" });
  return Response.json({ url });
}

secrets: { driver: local }
auth: { driver: local }
db: { driver: sqlite }
ai: { driver: local }
files: { driver: local }