import { pgTable, uuid, text, timestamp } from 'drizzle-orm/pg-core';
import { tenants } from './tenants';

export const habits = pgTable('habits', {
  id: uuid('id').primaryKey().defaultRandom(),
  tenantId: uuid('tenant_id')
    .notNull()
    .references(() => tenants.id, { onDelete: 'cascade' }),
  name: text('name').notNull(),
  createdAt: timestamp('created_at', { withTimezone: true })
    .notNull()
    .defaultNow(),
});

npm run db:generate

ALTER TABLE habits ENABLE ROW LEVEL SECURITY;

CREATE POLICY "habits_select" ON habits FOR SELECT USING (
  EXISTS (SELECT 1 FROM tenant_users
    WHERE tenant_id = habits.tenant_id AND user_id = auth.uid())
);

CREATE POLICY "habits_insert" ON habits FOR INSERT WITH CHECK (
  EXISTS (SELECT 1 FROM tenant_users
    WHERE tenant_id = habits.tenant_id AND user_id = auth.uid())
);

CREATE POLICY "habits_update" ON habits FOR UPDATE USING (
  EXISTS (SELECT 1 FROM tenant_users
    WHERE tenant_id = habits.tenant_id AND user_id = auth.uid())
) WITH CHECK (
  EXISTS (SELECT 1 FROM tenant_users
    WHERE tenant_id = habits.tenant_id AND user_id = auth.uid())
);

CREATE POLICY "habits_delete" ON habits FOR DELETE USING (
  EXISTS (SELECT 1 FROM tenant_users
    WHERE tenant_id = habits.tenant_id AND user_id = auth.uid())
);

npm run db:migrate

import { habits } from '../schema/habits';
import { desc, eq } from 'drizzle-orm';
import { NodePgDatabase } from 'drizzle-orm/node-postgres';

export async function getHabits(db: NodePgDatabase, tenantId: string) {
  return db
    .select()
    .from(habits)
    .where(eq(habits.tenantId, tenantId))
    .orderBy(desc(habits.createdAt));
}

export async function createHabit(db: NodePgDatabase, input: {...}) {
  const [habit] = await db.insert(habits).values(input).returning();
  return habit;
}

import { z } from 'zod';

export const createHabitSchema = z.object({
  name: z.string().min(1).max(255),
});

export type CreateHabitInput = z.infer<typeof createHabitSchema>;

import { requireUser } from '@/lib/auth/requireUser';
import { withAuthDb } from '@/lib/db/withAuthDb';
import { ok, fail, created } from '@/lib/api/responses';
import { getActiveTenantId } from '@/lib/tenants/activeTenant';

export async function GET() {
  const { user, session } = await requireUser();
  if (!user || !session) return fail('UNAUTHENTICATED', 'Auth required', 401);

  const tenantId = await getActiveTenantId();
  if (!tenantId) return fail('BAD_REQUEST', 'No tenant', 400);

  const data = await withAuthDb(session.access_token, (db) =>
    getHabits(db, tenantId)
  );
  return ok(data);
}

export async function POST(req: Request) {
  const { user, session } = await requireUser();
  if (!user || !session) return fail('UNAUTHENTICATED', 'Auth required', 401);

  const body = await req.json();
  const parsed = schema.safeParse(body);
  if (!parsed.success) return fail('VALIDATION_ERROR', 'Invalid input', 400);

  const tenantId = await getActiveTenantId();
  if (!tenantId) return fail('BAD_REQUEST', 'No tenant', 400);

  const result = await withAuthDb(session.access_token, (db) =>
    createHabit(db, { ...parsed.data, tenantId })
  );

  return created(result);
}

export async function fetchHabits() {
  const res = await fetch('/api/habits', { cache: 'no-store' });
  if (!res.ok) throw new Error('Failed');
  return (await res.json()).data;
}

import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { useAppStore } from '@/store/appStore';

// Include tenantId in queryKey for proper cache isolation
export const habitKeys = {
  all: (tenantId: string | null) => ['habits', tenantId] as const,
};

export function useHabits() {
  const activeTenant = useAppStore((s) => s.activeTenant);

  return useQuery({
    queryKey: habitKeys.all(activeTenant?.id ?? null),
    queryFn: fetchHabits,
    enabled: !!activeTenant,
  });
}

export function useCreateHabit() {
  const qc = useQueryClient();
  const activeTenant = useAppStore((s) => s.activeTenant);

  return useMutation({
    mutationFn: createHabit,
    onSuccess: () => qc.invalidateQueries({
      queryKey: habitKeys.all(activeTenant?.id ?? null)
    }),
  });
}

import { FeatureList } from '@/components/feature/FeatureList';

export default function FeaturePage() {
  return <FeatureList />;
}

const navItems = [
  { title: 'Feature', href: '/feature', icon: Icon },
];

export const DIALOG_TYPES = {
  HABIT: {
    CREATE: 'habit:create',
    EDIT: 'habit:edit',
  },
} as const;

case DIALOG_TYPES.HABIT.CREATE:
case DIALOG_TYPES.HABIT.EDIT:
  return <HabitDialog />;

import { openDialog } from '@/store/useDialogStore';
openDialog(DIALOG_TYPES.HABIT.CREATE);
openDialog(DIALOG_TYPES.HABIT.EDIT, { habit: data });