{
  "workspaces": ["packages/*", "apps/*", "packages/email/*"]
}

{
  "dependencies": {
    "@midday/ui": "workspace:*",
    "@midday/db": "workspace:*"
  }
}

{
  "packageManager": "bun@1.2.22"
}

{
  "$schema": "https://turborepo.org/schema.json",
  "globalDependencies": ["**/.env"],
  "ui": "stream",
  "tasks": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": [".next/**", "dist/**", "build/**", "lib/**"]
    },
    "dev": {
      "persistent": true,
      "cache": false
    },
    "lint": {
      "dependsOn": ["^topo"]
    },
    "typecheck": {
      "dependsOn": ["^build"]
    }
  }
}

# Run all apps in dev mode
bun run dev
 
# Run specific app
bun run dev:dashboard
bun run dev:api
 
# Build all packages
bun run build
 
# Typecheck everything
bun run typecheck
 
# Lint everything
bun run lint

{
  "$schema": "./node_modules/@biomejs/biome/configuration_schema.json",
  "organizeImports": { "enabled": true },
  "files": {
    "ignore": ["dist", "node_modules", ".turbo", ".next"]
  },
  "linter": {
    "enabled": true,
    "rules": {
      "recommended": true,
      "a11y": {
        "noSvgWithoutTitle": "off",
        "useKeyWithClickEvents": "off"
      },
      "style": {
        "noNonNullAssertion": "off"
      },
      "correctness": {
        "useExhaustiveDependencies": "off"
      },
      "suspicious": {
        "noExplicitAny": "off"
      }
    }
  },
  "formatter": {
    "indentStyle": "space"
  }
}

# Format all files
bun run format
 
# Lint check
bun run lint
 
# Auto-fix linting issues (in apps)
biome check --write .

{
  "compilerOptions": {
    "esModuleInterop": true,
    "isolatedModules": true,
    "lib": ["es2022", "DOM", "DOM.Iterable"],
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "noUncheckedIndexedAccess": true,
    "strict": true,
    "target": "ES2022",
    "skipLibCheck": true
  }
}

{
  "extends": "./base.json",
  "compilerOptions": {
    "plugins": [{ "name": "next" }],
    "module": "ESNext",
    "moduleResolution": "Bundler",
    "jsx": "preserve",
    "noEmit": true
  }
}

// apps/dashboard/tsconfig.json
{
  "extends": "@midday/tsconfig/nextjs.json",
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"]
    }
  }
}

bun run lint  # Includes "manypkg check"

{
  "build": {
    "passThroughEnv": [
      "SUPABASE_SERVICE_KEY",
      "RESEND_API_KEY",
      "OPENAI_API_KEY",
      // ... 40+ variables
    ]
  }
}

{
  "globalDependencies": ["**/.env"]
}

# 1. Initialize with Bun
bun init
 
# 2. Install core dependencies
bun add -D turbo @biomejs/biome @manypkg/cli typescript
 
# 3. Create workspace structure
mkdir -p apps packages
 
# 4. Configure package.json
{
  "private": true,
  "workspaces": ["packages/*", "apps/*"],
  "packageManager": "bun@1.2.22",
  "scripts": {
    "build": "turbo build",
    "dev": "turbo dev --parallel",
    "lint": "turbo lint && manypkg check",
    "format": "biome format --write ."
  }
}
 
# 5. Create turbo.json and biome.json (see examples above)
 
# 6. Create packages/tsconfig with base configs

// next.config.ts
{
  experimental: {
    optimizePackageImports: [
      "lucide-react", "react-icons", "date-fns",
      "framer-motion", "recharts"
    ]
  },
  transpilePackages: ["@midday/ui", "@midday/invoice", "@midday/api"]
}

import { trpcServer } from "@hono/trpc-server";
import { OpenAPIHono } from "@hono/zod-openapi";
import { Scalar } from "@scalar/hono-api-reference";
 
const app = new OpenAPIHono();
 
// tRPC integration
app.use("/trpc/*", trpcServer({
  router: appRouter,
  createContext: createTRPCContext,
}));
 
// REST API routes
app.route("/", routers);
 
// OpenAPI documentation
app.get("/", Scalar({ url: "/openapi" }));

graph TD
    Dashboard --> API
    Dashboard --> Engine
    Desktop --> Dashboard[Dashboard Web]
    Worker --> API
    API --> DB[(Packages)]
    Engine --> DB

import { Button } from "@midday/ui/button";
import { Dialog } from "@midday/ui/dialog";
import { cn } from "@midday/ui/cn";

{
  "exports": {
    "./client": "./src/client.ts",
    "./schema": "./src/schema.ts",
    "./queries": "./src/queries/index.ts"
  }
}

graph TD
    UI[ui] --> Utils[utils]
    DB[db] --> Cache[cache]
    DB --> Categories[categories]
    DB --> Logger[logger]
    Jobs[jobs] --> DB
    Jobs --> Email[email]
    Jobs --> Engine[engine-client]
    Invoice[invoice] --> Utils
    API[api] --> DB
    API --> Jobs
    API --> Cache
    Dashboard[dashboard] --> UI
    Dashboard --> Invoice

mkdir -p packages/my-package/src

{
  "name": "@midday/my-package",
  "version": "1.0.0",
  "private": true,
  "exports": {
    ".": "./src/index.ts",
    "./utils": "./src/utils.ts"
  },
  "dependencies": {
    "@midday/utils": "workspace:*"
  }
}

{
  "extends": "@midday/tsconfig/base.json",
  "compilerOptions": {
    "outDir": "dist"
  },
  "include": ["src"]
}

{
  "dependencies": {
    "@midday/my-package": "workspace:*"
  }
}

{
  "exports": {
    "./client": "./src/client.ts",
    "./server": "./src/server.ts"
  }
}

{
  "exports": {
    "./emails/*": "./emails/*.tsx"
  }
}

{
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "default": "./dist/index.js"
    }
  }
}

// packages/db/drizzle.config.ts
import type { Config } from "drizzle-kit";
 
export default {
  schema: "./src/schema.ts",
  out: "./migrations",
  dialect: "postgresql",
  dbCredentials: {
    url: process.env.DATABASE_SESSION_POOLER!,
  },
} satisfies Config;

// packages/db/src/schema.ts
import { pgEnum, pgTable, uuid, text, timestamp } from "drizzle-orm/pg-core";
 
// Define enums
export const accountTypeEnum = pgEnum("account_type", [
  "depository",
  "credit",
  "other_asset",
  "loan",
  "other_liability",
]);
 
export const bankProvidersEnum = pgEnum("bank_providers", [
  "gocardless",
  "plaid",
  "teller",
  "enablebanking",
]);
 
export const connectionStatusEnum = pgEnum("connection_status", [
  "disconnected",
  "connected",
  "unknown",
]);

// Custom tsvector for full-text search
export const tsvector = customType<{ data: string }>({
  dataType() {
    return "tsvector";
  },
});
 
// Numeric with proper casting
export const numericCasted = customType<{
  data: number;
  driverData: string;
  config: { precision?: number; scale?: number };
}>({
  dataType: (config) => {
    if (config?.precision && config?.scale) {
      return `numeric(${config.precision}, ${config.scale})`;
    }
    return "numeric";
  },
  fromDriver: (value: string) => Number.parseFloat(value),
  toDriver: (value: number) => value.toString(),
});

// Example: Users table
export const users = pgTable("users", {
  id: uuid("id").primaryKey().defaultRandom(),
  email: text("email").notNull(),
  fullName: text("full_name"),
  avatarUrl: text("avatar_url"),
  createdAt: timestamp("created_at").defaultNow(),
  updatedAt: timestamp("updated_at").defaultNow(),
});
 
// Example: Teams table with relations
export const teams = pgTable("teams", {
  id: uuid("id").primaryKey().defaultRandom(),
  name: text("name").notNull(),
  slug: text("slug").unique().notNull(),
  baseCurrency: text("base_currency").default("USD"),
  createdAt: timestamp("created_at").defaultNow(),
});
 
// Relations
export const teamsRelations = relations(teams, ({ many }) => ({
  members: many(usersOnTeam),
  transactions: many(transactions),
  invoices: many(invoices),
}));

// Vector embeddings for AI
export const transactionEmbeddings = pgTable("transaction_embeddings", {
  id: uuid("id").primaryKey().defaultRandom(),
  transactionId: uuid("transaction_id").references(() => transactions.id),
  embedding: vector("embedding", { dimensions: 1536 }),
});
 
// Full-text search
export const documents = pgTable("documents", {
  id: uuid("id").primaryKey().defaultRandom(),
  name: text("name"),
  searchVector: tsvector("search_vector"),
}, (table) => ({
  searchIdx: index("documents_search_idx").using("gin", table.searchVector),
}));
 
// Row-Level Security policies
export const invoices = pgTable("invoices", {
  id: uuid("id").primaryKey().defaultRandom(),
  teamId: uuid("team_id").references(() => teams.id),
  // ...
}, (table) => ({
  teamPolicy: pgPolicy("invoices_team_policy", {
    for: "all",
    using: sql`team_id = current_setting('app.current_team_id')::uuid`,
  }),
}));

// packages/db/src/client.ts
import { drizzle } from "drizzle-orm/postgres-js";
import postgres from "postgres";
import * as schema from "./schema";
 
const connectionString = process.env.DATABASE_SESSION_POOLER!;
 
const client = postgres(connectionString, {
  prepare: false,
  idle_timeout: 20,
  max: 10,
});
 
export const db = drizzle(client, { schema });
export type Database = typeof db;

// packages/db/src/replicas.ts
import { withReplicas } from "drizzle-orm/pg-core";
 
export const db = withReplicas(primaryDb, [replicaDb]);

// packages/db/src/queries/transactions.ts
import { db } from "../client";
import { transactions, transactionCategories } from "../schema";
import { eq, and, between, desc } from "drizzle-orm";
 
export async function getTransactions(params: {
  teamId: string;
  startDate?: Date;
  endDate?: Date;
  categoryId?: string;
}) {
  const conditions = [eq(transactions.teamId, params.teamId)];
 
  if (params.startDate && params.endDate) {
    conditions.push(
      between(transactions.date, params.startDate, params.endDate)
    );
  }
 
  if (params.categoryId) {
    conditions.push(eq(transactions.categoryId, params.categoryId));
  }
 
  return db.query.transactions.findMany({
    where: and(...conditions),
    with: {
      category: true,
      attachments: true,
    },
    orderBy: [desc(transactions.date)],
    limit: 50,
  });
}

// packages/db/src/queries/reports.ts
import { db } from "../client";
import { transactions } from "../schema";
import { eq, sql, sum } from "drizzle-orm";
 
export async function getSpendingByCategory(teamId: string) {
  return db
    .select({
      categoryId: transactions.categoryId,
      totalAmount: sum(transactions.amount),
      count: sql<number>`count(*)`,
    })
    .from(transactions)
    .where(eq(transactions.teamId, teamId))
    .groupBy(transactions.categoryId);
}

// packages/supabase/src/client/server.ts
import { createServerClient } from "@supabase/ssr";
import { cookies } from "next/headers";
 
export async function createClient() {
  const cookieStore = await cookies();
 
  return createServerClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
    {
      cookies: {
        getAll() {
          return cookieStore.getAll();
        },
        setAll(cookiesToSet) {
          try {
            cookiesToSet.forEach(({ name, value, options }) => {
              cookieStore.set(name, value, options);
            });
          } catch {
            // Server Component context
          }
        },
      },
    }
  );
}

// packages/supabase/src/client/client.ts
import { createBrowserClient } from "@supabase/ssr";
 
export function createClient() {
  return createBrowserClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
  );
}

# Generate migration from schema changes
bun run drizzle-kit generate
 
# Push schema directly (dev only)
bun run drizzle-kit push
 
# Run migrations
bun run drizzle-kit migrate

-- migrations/0001_add_report_types.sql
ALTER TABLE "reports" 
ADD COLUMN "type" text DEFAULT 'profit_loss';
 
-- migrations/0005_add_line_item_tax.sql
ALTER TABLE "invoice_line_items"
ADD COLUMN "tax_rate" numeric(5, 2) DEFAULT 0;

# Supabase
NEXT_PUBLIC_SUPABASE_URL=https://xxx.supabase.co
NEXT_PUBLIC_SUPABASE_ANON_KEY=xxx
SUPABASE_SERVICE_KEY=xxx
 
# Direct Database (for Drizzle)
DATABASE_SESSION_POOLER=postgres://user:pass@host:6543/db
DATABASE_PRIMARY=postgres://user:pass@host:5432/db

// apps/api/src/index.ts
import { trpcServer } from "@hono/trpc-server";
import { OpenAPIHono } from "@hono/zod-openapi";
import { Scalar } from "@scalar/hono-api-reference";
import { cors } from "hono/cors";
import { secureHeaders } from "hono/secure-headers";
 
const app = new OpenAPIHono<Context>();
 
// Middleware
app.use(secureHeaders());
app.use("*", cors({
  origin: process.env.ALLOWED_API_ORIGINS?.split(",") ?? [],
  allowMethods: ["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"],
}));
 
// tRPC integration
app.use("/trpc/*", trpcServer({
  router: appRouter,
  createContext: createTRPCContext,
}));
 
// REST routes
app.route("/", routers);
 
// OpenAPI documentation
app.doc("/openapi", { openapi: "3.1.0", info: { title: "Midday API" } });
app.get("/", Scalar({ url: "/openapi", theme: "saturn" }));
 
// Health check
app.get("/health", (c) => c.json({ status: "ok" }));
 
export default {
  port: process.env.PORT ?? 3000,
  fetch: app.fetch,
};

// apps/api/src/trpc/init.ts
import { initTRPC, TRPCError } from "@trpc/server";
import superjson from "superjson";
 
type TRPCContext = {
  session: Session | null;
  supabase: SupabaseClient;
  db: Database;
  geo: GeoContext;
  teamId?: string;
  forcePrimary?: boolean;
};
 
export const createTRPCContext = async (_, c: Context): Promise<TRPCContext> => {
  const accessToken = c.req.header("Authorization")?.split(" ")[1];
  const session = await verifyAccessToken(accessToken);
  const supabase = await createClient(accessToken);
  const geo = getGeoContext(c.req);
  const forcePrimary = c.req.header("x-force-primary") === "true";
 
  return { session, supabase, db, geo, forcePrimary };
};
 
const t = initTRPC.context<TRPCContext>().create({
  transformer: superjson,
});
 
export const createTRPCRouter = t.router;

// Public procedure (no auth required)
export const publicProcedure = t.procedure
  .use(withPrimaryDbMiddleware);
 
// Protected procedure (auth required)
export const protectedProcedure = t.procedure
  .use(withTeamPermissionMiddleware)
  .use(withPrimaryDbMiddleware)
  .use(async (opts) => {
    const { session, teamId } = opts.ctx;
    
    if (!session) {
      throw new TRPCError({ code: "UNAUTHORIZED" });
    }
    
    return opts.next({ ctx: { teamId, session } });
  });

// apps/api/src/trpc/routers/transactions.ts
import { z } from "zod";
import { createTRPCRouter, protectedProcedure } from "../init";
import { getTransactions, createTransaction } from "@midday/db/queries";
 
export const transactionsRouter = createTRPCRouter({
  list: protectedProcedure
    .input(z.object({
      startDate: z.date().optional(),
      endDate: z.date().optional(),
      categoryId: z.string().optional(),
      cursor: z.string().optional(),
      limit: z.number().min(1).max(100).default(50),
    }))
    .query(async ({ ctx, input }) => {
      const transactions = await getTransactions({
        teamId: ctx.teamId,
        ...input,
      });
      
      return {
        items: transactions,
        nextCursor: transactions.length === input.limit 
          ? transactions[transactions.length - 1].id 
          : null,
      };
    }),
 
  create: protectedProcedure
    .input(z.object({
      amount: z.number(),
      description: z.string(),
      date: z.date(),
      categoryId: z.string().optional(),
    }))
    .mutation(async ({ ctx, input }) => {
      return createTransaction({
        teamId: ctx.teamId,
        ...input,
      });
    }),
});

// apps/api/src/trpc/routers/_app.ts
import { createTRPCRouter } from "../init";
import { transactionsRouter } from "./transactions";
import { invoicesRouter } from "./invoices";
import { customersRouter } from "./customers";
// ... more routers
 
export const appRouter = createTRPCRouter({
  transactions: transactionsRouter,
  invoices: invoicesRouter,
  customers: customersRouter,
  bankAccounts: bankAccountsRouter,
  bankConnections: bankConnectionsRouter,
  documents: documentsRouter,
  inbox: inboxRouter,
  tracker: trackerRouter,
  // ... 40+ routers
});
 
export type AppRouter = typeof appRouter;

// apps/api/src/rest/routers/transactions.ts
import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
import { z } from "zod";
 
const listTransactionsRoute = createRoute({
  method: "get",
  path: "/v1/transactions",
  request: {
    query: z.object({
      limit: z.number().optional(),
      offset: z.number().optional(),
    }),
  },
  responses: {
    200: {
      content: {
        "application/json": {
          schema: z.object({
            data: z.array(TransactionSchema),
            meta: PaginationSchema,
          }),
        },
      },
      description: "List of transactions",
    },
  },
  security: [{ token: [] }],
});
 
const app = new OpenAPIHono();
 
app.openapi(listTransactionsRoute, async (c) => {
  const { limit, offset } = c.req.valid("query");
  const transactions = await getTransactions({ limit, offset });
  
  return c.json({
    data: transactions,
    meta: { limit, offset, total: transactions.length },
  });
});
 
export { app as transactionsRouter };

// apps/api/src/trpc/middleware/team-permission.ts
export const withTeamPermission = async ({ ctx, next }) => {
  const teamId = ctx.session?.teamId;
  
  if (!teamId) {
    throw new TRPCError({ code: "FORBIDDEN" });
  }
  
  // Verify user has access to this team
  const hasAccess = await checkTeamAccess(ctx.session.userId, teamId);
  
  if (!hasAccess) {
    throw new TRPCError({ code: "FORBIDDEN" });
  }
  
  return next({ ctx: { ...ctx, teamId } });
};

// apps/api/src/trpc/middleware/primary-read-after-write.ts
export const withPrimaryReadAfterWrite = async ({ ctx, type, next }) => {
  // For mutations, always use primary
  // For queries after recent mutations, use primary
  const shouldUsePrimary = 
    type === "mutation" || 
    ctx.forcePrimary || 
    await hasRecentMutation(ctx.session?.userId);
  
  return next({
    ctx: {
      ...ctx,
      db: shouldUsePrimary ? primaryDb : replicaDb,
    },
  });
};

// apps/api/src/ai/agents/assistant.ts
import { createAgent } from "@ai-sdk-tools/agents";
import { openai } from "@ai-sdk/openai";
 
export const assistantAgent = createAgent({
  model: openai("gpt-4-turbo"),
  tools: [
    getTransactionsTool,
    categorizeTransactionTool,
    generateReportTool,
    searchDocumentsTool,
  ],
  systemPrompt: `You are a helpful business assistant...`,
});

// apps/api/src/mcp/tools/transactions.ts
import { tool } from "@modelcontextprotocol/sdk";
 
export const listTransactionsTool = tool({
  name: "list_transactions",
  description: "List transactions for the current team",
  parameters: z.object({
    startDate: z.string().optional(),
    endDate: z.string().optional(),
  }),
  execute: async (params, context) => {
    return getTransactions({
      teamId: context.teamId,
      ...params,
    });
  },
});

// apps/api/src/utils/auth.ts
import { jwtVerify } from "jose";
 
export async function verifyAccessToken(token?: string): Promise<Session | null> {
  if (!token) return null;
 
  try {
    const { payload } = await jwtVerify(
      token,
      new TextEncoder().encode(process.env.SUPABASE_JWT_SECRET)
    );
 
    return {
      userId: payload.sub!,
      email: payload.email as string,
      teamId: payload.team_id as string,
    };
  } catch {
    return null;
  }
}

// apps/api/src/utils/api-key.ts
import { verifyApiKey } from "@midday/db/utils/api-keys";
 
export async function authenticateApiKey(apiKey: string) {
  const result = await verifyApiKey(apiKey);
  
  if (!result.valid) {
    throw new Error("Invalid API key");
  }
  
  return {
    teamId: result.teamId,
    scopes: result.scopes,
  };
}

FROM oven/bun:1.2
 
WORKDIR /app
COPY . .
 
RUN bun install --frozen-lockfile
RUN bun run build
 
EXPOSE 3000
CMD ["bun", "run", "apps/api/src/index.ts"]

# apps/api/fly.toml
app = "midday-api"
primary_region = "ams"
 
[http_service]
  internal_port = 3000
  force_https = true
  auto_stop_machines = "suspend"
  auto_start_machines = true
  min_machines_running = 1
 
[env]
  NODE_ENV = "production"

// apps/dashboard/next.config.ts
import { withSentryConfig } from "@sentry/nextjs";
 
const config = {
  poweredByHeader: false,
  reactStrictMode: true,
  
  experimental: {
    optimizePackageImports: [
      "lucide-react",
      "react-icons",
      "date-fns",
      "framer-motion",
      "recharts",
      "@dnd-kit/core",
    ],
  },
  
  images: {
    loader: "custom",
    loaderFile: "./image-loader.ts",
    remotePatterns: [{ protocol: "https", hostname: "**" }],
  },
  
  transpilePackages: [
    "@midday/ui",
    "@midday/invoice",
    "@midday/api",
  ],
  
  serverExternalPackages: ["@react-pdf/renderer", "pino"],
};
 
export default withSentryConfig(config, { /* sentry options */ });

// apps/dashboard/tailwind.config.ts
import baseConfig from "@midday/ui/tailwind.config";
import desktopPlugin from "@midday/desktop-client/desktop-variants";
import type { Config } from "tailwindcss";
 
export default {
  content: [
    "./src/**/*.{ts,tsx}",
    "../../packages/ui/src/**/*.{ts,tsx}",
    "../../packages/invoice/src/**/*.{ts,tsx}",
  ],
  presets: [baseConfig],  // Extend shared config
  plugins: [desktopPlugin],
} satisfies Config;

// packages/ui/tailwind.config.ts
export default {
  darkMode: ["class"],
  theme: {
    extend: {
      colors: {
        border: "hsl(var(--border))",
        background: "hsl(var(--background))",
        foreground: "hsl(var(--foreground))",
        primary: {
          DEFAULT: "hsl(var(--primary))",
          foreground: "hsl(var(--primary-foreground))",
        },
        // ... more semantic colors
      },
      borderRadius: {
        lg: "var(--radius)",
        md: "calc(var(--radius) - 2px)",
        sm: "calc(var(--radius) - 4px)",
      },
      animation: {
        "accordion-down": "accordion-down 0.2s ease-out",
        shimmer: "shimmer 2.5s linear infinite",
        // ... more animations
      },
    },
  },
  plugins: [require("tailwindcss-animate")],
};

// Usage in dashboard
import { Button } from "@midday/ui/button";
import { Dialog, DialogContent, DialogTrigger } from "@midday/ui/dialog";
import { Form, FormField, FormItem } from "@midday/ui/form";
import { Input } from "@midday/ui/input";
import { cn } from "@midday/ui/cn";
 
export function MyComponent() {
  return (
    <Dialog>
      <DialogTrigger asChild>
        <Button variant="outline">Open</Button>
      </DialogTrigger>
      <DialogContent className={cn("sm:max-w-md")}>
        {/* Content */}
      </DialogContent>
    </Dialog>
  );
}

// apps/dashboard/src/store/transaction-store.ts
import { create } from "zustand";
 
interface TransactionStore {
  selectedIds: string[];
  filters: TransactionFilters;
  setFilters: (filters: TransactionFilters) => void;
  toggleSelection: (id: string) => void;
  clearSelection: () => void;
}
 
export const useTransactionStore = create<TransactionStore>((set) => ({
  selectedIds: [],
  filters: {},
  
  setFilters: (filters) => set({ filters }),
  
  toggleSelection: (id) => set((state) => ({
    selectedIds: state.selectedIds.includes(id)
      ? state.selectedIds.filter((i) => i !== id)
      : [...state.selectedIds, id],
  })),
  
  clearSelection: () => set({ selectedIds: [] }),
}));

// apps/dashboard/src/trpc/client.ts
import { createTRPCClient, httpBatchLink } from "@trpc/client";
import { QueryClient } from "@tanstack/react-query";
import type { AppRouter } from "@midday/api/trpc/routers/_app";
import superjson from "superjson";
 
export const trpc = createTRPCClient<AppRouter>({
  links: [
    httpBatchLink({
      url: `${process.env.NEXT_PUBLIC_API_URL}/trpc`,
      transformer: superjson,
      headers: () => ({
        Authorization: `Bearer ${getAccessToken()}`,
      }),
    }),
  ],
});
 
export const queryClient = new QueryClient({
  defaultOptions: {
    queries: {
      staleTime: 1000 * 60, // 1 minute
      refetchOnWindowFocus: false,
    },
  },
});

// Using tRPC with React Query
import { trpc } from "@/trpc/client";
 
export function TransactionList() {
  const { data, isLoading } = trpc.transactions.list.useQuery({
    startDate: new Date("2024-01-01"),
    limit: 50,
  });
 
  const createMutation = trpc.transactions.create.useMutation({
    onSuccess: () => {
      queryClient.invalidateQueries(["transactions"]);
    },
  });
 
  if (isLoading) return <Skeleton />;
 
  return (
    <Table>
      {data?.items.map((tx) => (
        <TableRow key={tx.id}>{/* ... */}</TableRow>
      ))}
    </Table>
  );
}

// apps/dashboard/src/actions/invoice-actions.ts
"use server";
 
import { action } from "next-safe-action";
import { z } from "zod";
import { revalidatePath } from "next/cache";
 
const createInvoiceSchema = z.object({
  customerId: z.string(),
  items: z.array(z.object({
    description: z.string(),
    quantity: z.number(),
    price: z.number(),
  })),
});
 
export const createInvoiceAction = action
  .schema(createInvoiceSchema)
  .action(async ({ parsedInput }) => {
    const invoice = await db.insert(invoices).values({
      customerId: parsedInput.customerId,
      // ...
    });
 
    revalidatePath("/invoices");
    return { success: true, invoice };
  });

// apps/dashboard/src/locales/client.ts
import { createI18nClient } from "next-international/client";
 
export const { useI18n, I18nProvider } = createI18nClient({
  en: () => import("./en"),
  sv: () => import("./sv"),
});
 
// Usage
export function MyComponent() {
  const t = useI18n();
  return <h1>{t("dashboard.title")}</h1>;
}

// page.tsx
export default async function Page() {
  // Parallel data fetching
  const [transactions, categories, accounts] = await Promise.all([
    getTransactions(),
    getCategories(),
    getBankAccounts(),
  ]);
 
  return <Dashboard data={{ transactions, categories, accounts }} />;
}

const mutation = trpc.transactions.update.useMutation({
  onMutate: async (newData) => {
    await queryClient.cancelQueries(["transactions"]);
    const previous = queryClient.getQueryData(["transactions"]);
    queryClient.setQueryData(["transactions"], (old) => ({
      ...old,
      items: old.items.map((t) =>
        t.id === newData.id ? { ...t, ...newData } : t
      ),
    }));
    return { previous };
  },
  onError: (_, __, context) => {
    queryClient.setQueryData(["transactions"], context.previous);
  },
});

// packages/jobs/trigger.config.ts
import { defineConfig } from "@trigger.dev/sdk";
 
export default defineConfig({
  project: process.env.TRIGGER_PROJECT_ID!,
  runtime: "node",
  logLevel: "log",
  maxDuration: 60,
  
  experimental_processKeepAlive: true,
  
  retries: {
    enabledInDev: false,
    default: {
      maxAttempts: 3,
      minTimeoutInMs: 1000,
      maxTimeoutInMs: 10000,
      factor: 2,
      randomize: true,
    },
  },
  
  build: {
    external: ["sharp", "canvas", "pino"],
  },
  
  dirs: ["./src/tasks"],
});

// packages/jobs/src/tasks/bank/sync-account.ts
import { task, schedules } from "@trigger.dev/sdk";
import { z } from "zod";
import { db } from "@midday/db/client";
import { syncBankAccount } from "@midday/engine-client";
 
export const syncAccountTask = task({
  id: "bank-sync-account",
  
  run: async (payload: { accountId: string; teamId: string }) => {
    const { accountId, teamId } = payload;
    
    // Get account details
    const account = await db.query.bankAccounts.findFirst({
      where: eq(bankAccounts.id, accountId),
    });
    
    if (!account) {
      throw new Error(`Account ${accountId} not found`);
    }
    
    // Sync transactions from banking provider
    const transactions = await syncBankAccount({
      accountId,
      provider: account.provider,
      accessToken: account.accessToken,
    });
    
    // Upsert transactions
    for (const tx of transactions) {
      await db.insert(transactions).values({
        ...tx,
        teamId,
        accountId,
      }).onConflictDoUpdate({
        target: [transactions.externalId],
        set: { ...tx },
      });
    }
    
    return { synced: transactions.length };
  },
});

// packages/jobs/src/tasks/bank/scheduled-sync.ts
import { schedules } from "@trigger.dev/sdk";
 
export const scheduledBankSync = schedules.task({
  id: "scheduled-bank-sync",
  cron: "0 */6 * * *",  // Every 6 hours
  
  run: async () => {
    // Get all active bank connections
    const connections = await db.query.bankConnections.findMany({
      where: eq(bankConnections.status, "connected"),
      with: { accounts: true },
    });
    
    // Trigger sync for each account
    for (const connection of connections) {
      for (const account of connection.accounts) {
        await syncAccountTask.trigger({
          accountId: account.id,
          teamId: connection.teamId,
        });
      }
    }
    
    return { connections: connections.length };
  },
});

// packages/jobs/src/tasks/invoice/recurring.ts
import { schedules } from "@trigger.dev/sdk";
 
export const processRecurringInvoices = schedules.task({
  id: "process-recurring-invoices",
  cron: "0 9 * * *",  // Daily at 9 AM
  
  run: async () => {
    // Get invoices due for generation
    const recurringInvoices = await db.query.invoiceRecurring.findMany({
      where: and(
        eq(invoiceRecurring.status, "active"),
        lte(invoiceRecurring.nextDate, new Date()),
      ),
    });
    
    for (const recurring of recurringInvoices) {
      // Create new invoice from template
      const invoice = await createInvoiceFromRecurring(recurring);
      
      // Send invoice
      await sendInvoiceTask.trigger({ invoiceId: invoice.id });
      
      // Update next date
      await updateNextRecurringDate(recurring.id);
    }
    
    return { processed: recurringInvoices.length };
  },
});

// apps/api/src/trpc/routers/bank-connections.ts
import { syncAccountTask } from "@midday/jobs/tasks/bank/sync-account";
 
export const bankConnectionsRouter = createTRPCRouter({
  sync: protectedProcedure
    .input(z.object({ accountId: z.string() }))
    .mutation(async ({ ctx, input }) => {
      // Trigger background job
      await syncAccountTask.trigger({
        accountId: input.accountId,
        teamId: ctx.teamId,
      });
      
      return { triggered: true };
    }),
});

// apps/worker/src/queues/document.ts
import { Queue, Worker } from "bullmq";
import Redis from "ioredis";
 
const redis = new Redis(process.env.REDIS_URL!);
 
export const documentQueue = new Queue("document-processing", {
  connection: redis,
  defaultJobOptions: {
    attempts: 3,
    backoff: {
      type: "exponential",
      delay: 1000,
    },
  },
});
 
export const documentWorker = new Worker(
  "document-processing",
  async (job) => {
    switch (job.name) {
      case "process":
        return processDocument(job.data);
      case "extract-text":
        return extractText(job.data);
      case "generate-thumbnail":
        return generateThumbnail(job.data);
    }
  },
  {
    connection: redis,
    concurrency: 5,
  }
);

// apps/worker/src/handlers/convert-image.ts
import sharp from "sharp";
import heicConvert from "heic-convert";
 
export async function convertImage(data: {
  inputPath: string;
  outputPath: string;
  format: "jpeg" | "png" | "webp";
}) {
  const { inputPath, outputPath, format } = data;
  
  // Handle HEIC conversion
  if (inputPath.endsWith(".heic")) {
    const heicBuffer = await fs.readFile(inputPath);
    const jpegBuffer = await heicConvert({
      buffer: heicBuffer,
      format: "JPEG",
      quality: 0.9,
    });
    await fs.writeFile(outputPath, Buffer.from(jpegBuffer));
    return;
  }
  
  // Use Sharp for other formats
  await sharp(inputPath)
    .resize(1920, 1080, { fit: "inside" })
    .toFormat(format, { quality: 85 })
    .toFile(outputPath);
}

// apps/worker/src/handlers/generate-export.ts
import { format as formatCsv } from "@fast-csv/format";
import archiver from "archiver";
 
export async function generateTransactionExport(data: {
  teamId: string;
  startDate: Date;
  endDate: Date;
  format: "csv" | "xlsx";
}) {
  const transactions = await db.query.transactions.findMany({
    where: and(
      eq(transactions.teamId, data.teamId),
      between(transactions.date, data.startDate, data.endDate),
    ),
    with: { category: true, attachments: true },
  });
  
  if (data.format === "csv") {
    const stream = formatCsv({ headers: true });
    
    for (const tx of transactions) {
      stream.write({
        date: tx.date,
        description: tx.description,
        amount: tx.amount,
        category: tx.category?.name,
      });
    }
    
    stream.end();
    return stream;
  }
  
  // Handle xlsx...
}

// apps/worker/src/index.ts
import { Hono } from "hono";
import { documentWorker } from "./queues/document";
import { exportWorker } from "./queues/export";
import { imageWorker } from "./queues/image";
 
const app = new Hono();
 
// Health check
app.get("/health", (c) => {
  const workers = [documentWorker, exportWorker, imageWorker];
  const allRunning = workers.every((w) => w.isRunning());
  
  return c.json({ 
    status: allRunning ? "ok" : "degraded",
    workers: workers.map((w) => ({ 
      name: w.name, 
      running: w.isRunning() 
    })),
  });
});
 
// Graceful shutdown
process.on("SIGTERM", async () => {
  await Promise.all([
    documentWorker.close(),
    exportWorker.close(),
    imageWorker.close(),
  ]);
  process.exit(0);
});
 
export default {
  port: process.env.PORT ?? 3000,
  fetch: app.fetch,
};

// packages/job-client/src/index.ts
import { tasks } from "@trigger.dev/sdk";
 
export const jobClient = {
  syncBankAccount: async (data: { accountId: string; teamId: string }) => {
    return tasks.trigger("bank-sync-account", data);
  },
  
  processDocument: async (data: { documentId: string }) => {
    return tasks.trigger("document-process", data);
  },
  
  sendInvoice: async (data: { invoiceId: string }) => {
    return tasks.trigger("invoice-send", data);
  },
  
  generateExport: async (data: ExportParams) => {
    return tasks.trigger("export-generate", data);
  },
};

// Trigger multiple sub-jobs
const accounts = await getAccounts(connectionId);
await Promise.all(
  accounts.map((account) =>
    syncAccountTask.trigger({ accountId: account.id })
  )
);

task({
  id: "my-task",
  retry: {
    maxAttempts: 5,
    factor: 2,
    minTimeoutInMs: 1000,
    maxTimeoutInMs: 30000,
  },
  run: async () => { /* ... */ },
});

run: async (payload, { ctx }) => {
  const items = await getItems();
  
  for (let i = 0; i < items.length; i++) {
    await processItem(items[i]);
    await ctx.sendEvent("progress", { 
      current: i + 1, 
      total: items.length 
    });
  }
}

// apps/dashboard/vercel.json
{
  "crons": [],
  "framework": "nextjs"
}

# Supabase
NEXT_PUBLIC_SUPABASE_URL=
NEXT_PUBLIC_SUPABASE_ANON_KEY=
SUPABASE_SERVICE_KEY=
 
# API
NEXT_PUBLIC_API_URL=https://api.midday.ai
 
# Sentry
SENTRY_AUTH_TOKEN=
SENTRY_ORG=
SENTRY_PROJECT=
NEXT_PUBLIC_SENTRY_DSN=
 
# Analytics
NEXT_PUBLIC_OPENPANEL_CLIENT_ID=

# apps/api/fly.toml
app = "midday-api"
primary_region = "ams"
 
[build]
  dockerfile = "Dockerfile"
 
[http_service]
  internal_port = 3000
  force_https = true
  auto_stop_machines = "suspend"
  auto_start_machines = true
  min_machines_running = 1
 
[http_service.concurrency]
  type = "requests"
  hard_limit = 250
  soft_limit = 200
 
[[services]]
  protocol = "tcp"
  internal_port = 3000
 
  [[services.ports]]
    port = 80
    handlers = ["http"]
 
  [[services.ports]]
    port = 443
    handlers = ["tls", "http"]
 
[env]
  NODE_ENV = "production"
  TZ = "UTC"
 
[[vm]]
  cpu_kind = "shared"
  cpus = 2
  memory_mb = 1024

# apps/api/Dockerfile
FROM oven/bun:1.2 AS base
WORKDIR /app
 
# Install dependencies
FROM base AS deps
COPY package.json bun.lock ./
COPY packages ./packages
COPY apps/api/package.json ./apps/api/
RUN bun install --frozen-lockfile
 
# Build
FROM deps AS build
COPY . .
RUN bun run build --filter=@midday/api
 
# Production
FROM base AS production
COPY --from=build /app/node_modules ./node_modules
COPY --from=build /app/packages ./packages
COPY --from=build /app/apps/api ./apps/api
 
EXPOSE 3000
CMD ["bun", "run", "apps/api/src/index.ts"]

# apps/worker/fly.toml
app = "midday-worker"
primary_region = "ams"
 
[build]
  dockerfile = "Dockerfile"
 
[env]
  NODE_ENV = "production"
 
# No HTTP service - runs as a background process
 
[[vm]]
  cpu_kind = "shared"
  cpus = 2
  memory_mb = 2048  # More RAM for image processing

# Deploy API
fly deploy --config apps/api/fly.toml
 
# Deploy Worker
fly deploy --config apps/worker/fly.toml
 
# Scale machines
fly scale count 2 --region ams
 
# View logs
fly logs --app midday-api

# apps/engine/wrangler.toml
compatibility_date = "2024-11-11"
workers_dev = false
logpush = true
compatibility_flags = ["nodejs_compat_v2"]
 
[observability]
enabled = true
 
[env.production]
name = "engine"
route = { pattern = "engine.midday.ai/*", zone_name = "midday.ai" }
 
# KV for caching
kv_namespaces = [
  { binding = "KV", id = "xxx" }
]
 
# R2 for storage
r2_buckets = [
  { binding = "STORAGE", bucket_name = "engine-assets", jurisdiction = "eu" }
]
 
# mTLS for banking APIs
mtls_certificates = [
  { binding = "TELLER_CERT", certificate_id = "xxx" }
]
 
# Workers AI
[env.production.ai]
binding = "AI"
provider = "llama"
model = "llama-3.3"
jurisdiction = "eu"