robodev 0.11.0 → 0.12.0

package/templates/space/README.md

@@ -1,17 +1,36 @@
 # {{NAME}}
 
-Starter app from `robodev create`: a `space` database (`planets`, `rockets`), file-based APIs in `api/`, and a React UI.
+Starter from `robodev create`: Tiny Template schema (`planets`, `aliens`, `media`, `planet_likes`), file-based APIs in `api/`, and a **local** Povio UI in `apps/fe`.
 
-The project host is the app. After create or deploy, open the printed App URL — no `npm run dev` required. Local Vite is optional:
+The project host is **API-only**. After create or deploy, the printed App URL serves APIs and Swagger — not the SPA. Run the UI with bun:
 
 ```bash
-npm run dev
+cd apps/fe
+bun install
+bun openapi:gen
+bun dev
 ```
 
-Local Vite reads `VITE_API_URL` from `.env` (written by `robodev create` / `robodev link`). Hosted builds use the same origin as the APIs.
+Vite defaults to port **3000** (`VITE_DEV_PORT`). `bun` is required for `apps/fe`.
 
-Docs: https://robodev.povio.dev/docs
+Auth, link, and deploy from this **root**:
+
+```bash
+npx robodev auth
+npx robodev link
+npx robodev deploy
+```
+
+`robodev create` / `robodev link` write `VITE_API_URL`, `VITE_PUBLIC_API_URL`, and `APP_PUBLIC_API_URL` in `.env`, and rewrite `.config/local.spa.yml` so the FE talks to the project host.
+
+Dashboard create deploys schema + APIs only. The Tiny FE tree is copied by `robodev create`.
 
-`GET /api/me` (`api/me.ts`) requires a Robodev Auth Bearer token. Planet and rocket routes stay public. Optional browser helper: `@robodev-ai/client`. Auth how-to: https://robodev.povio.dev/docs/auth
+Auth stays reserved at `/api/user/*`. Do not add `api/user/**`.
 
-Edit files in the dashboard Code page, or here, then Save / `npx robodev deploy`.
+Regenerate AI rules after editing `.rulesync/`:
+
+```bash
+bun rules:gen
+```
+
+Docs: https://robodev.povio.dev/docs

package/templates/space/api/_lib.ts

@@ -0,0 +1,359 @@
+import { asc, eq, type InferSelectModel } from "@robodev-ai/sdk";
+import type { ApiHandlerContext } from "@robodev-ai/sdk";
+import { aliens, media, planetLikes, planets } from "../database";
+
+export const PLANET_IMAGE_RESOURCE = "planet-image";
+const DEFAULT_ORDER = "+name";
+const SORTABLE = new Set(["id", "name", "discoveryDate", "createdAt", "updatedAt"]);
+
+export const ALIEN_NAMES = [
+  "Andromedan",
+  "Arcturian",
+  "Betelgeusian",
+  "Centaurian",
+  "Denebian",
+  "Eridanian",
+  "Fomalhautian",
+  "Ganymedean",
+  "Hydran",
+  "Lyran",
+  "Orionid",
+  "Vegan",
+] as const;
+
+export const PLANET_SEEDS = [
+  ["Mercury", "Small rocky world closest to the system star"],
+  ["Venus", "Dense atmosphere with extreme surface temperatures"],
+  ["Earth", "Temperate ocean world with abundant life"],
+  ["Mars", "Cold desert world with polar ice caps"],
+  ["Jupiter", "Massive gas giant with a long-lived storm system"],
+  ["Saturn", "Ringed gas giant with many icy moons"],
+  ["Uranus", "Ice giant with a tilted rotation axis"],
+  ["Neptune", "Distant ice giant with high-speed winds"],
+  ["Kepler-22b", "Exoplanet candidate in a habitable-zone orbit"],
+  ["Proxima Centauri b", "Nearby terrestrial exoplanet orbiting a red dwarf"],
+  ["TRAPPIST-1e", "Compact-system rocky planet in a temperate orbit"],
+  ["HD 209458 b", "Hot gas giant with an observed atmosphere"],
+  ["Gliese 581g", "Candidate super-Earth in a nearby stellar system"],
+  ["LHS 1140 b", "Dense rocky super-Earth in a habitable-zone orbit"],
+  ["TOI-700 d", "Earth-size planet orbiting a small cool star"],
+  ["K2-18 b", "Sub-Neptune with detected atmospheric molecules"],
+  ["WASP-12b", "Ultra-hot gas giant closely orbiting its star"],
+  ["55 Cancri e", "Super-Earth with a very short orbital period"],
+  ["Kepler-452b", "Large terrestrial candidate orbiting a Sun-like star"],
+  ["GJ 1214 b", "Sub-Neptune with a hazy atmosphere"],
+  ["Ross 128 b", "Nearby temperate exoplanet around a quiet red dwarf"],
+  ["Tau Ceti e", "Candidate planet in a nearby Sun-like system"],
+  ["Wolf 1061 c", "Rocky candidate near the inner habitable zone"],
+  ["Teegarden's Star b", "Temperate Earth-mass candidate around a red dwarf"],
+  ["Kapteyn b", "Candidate super-Earth around an old nearby star"],
+  ["Kepler-186f", "Earth-size planet in a cool star's habitable zone"],
+  ["OGLE-2005-BLG-390Lb", "Cold distant world found by microlensing"],
+  ["HAT-P-7b", "Hot Jupiter with unusual atmospheric circulation"],
+  ["WASP-19b", "Hot Jupiter with a compact orbit"],
+  ["CoRoT-7b", "Rocky exoplanet with extreme dayside heating"],
+] as const;
+
+export type PlanetRow = InferSelectModel<typeof planets>;
+export type AlienRow = InferSelectModel<typeof aliens>;
+export type MediaRow = InferSelectModel<typeof media>;
+
+export type PlanetFilter = {
+  search?: string | null;
+  alienId?: string | null;
+  discoveryDate?: { start?: string | null; end?: string | null } | null;
+};
+
+export type PlanetDto = {
+  id: string;
+  userId: string;
+  alienId?: string | null;
+  discoveryDate?: string | null;
+  name: string;
+  description?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  image?: { id: string; url: string } | null;
+  creatorName?: string;
+  alienName?: string;
+  likesCount: number;
+  likedByMe: boolean;
+};
+
+export function fail(status: number, message: string) {
+  return { status, body: { message } };
+}
+
+export function iso(value: Date | string | null | undefined): string | null {
+  if (!value) return null;
+  return value instanceof Date ? value.toISOString() : value;
+}
+
+export function requiredIso(value: Date | string | null | undefined): string {
+  return iso(value) ?? new Date().toISOString();
+}
+
+export function parseFilter(query: Record<string, unknown>): PlanetFilter {
+  const raw = query.filter;
+  if (typeof raw === "string" && raw.trim()) {
+    try {
+      return parseFilter(JSON.parse(raw) as Record<string, unknown>);
+    } catch {
+      return { search: raw };
+    }
+  }
+  if (raw && typeof raw === "object") {
+    const filter = raw as Record<string, unknown>;
+    const discovery = filter.discoveryDate;
+    return {
+      search: typeof filter.search === "string" ? filter.search : undefined,
+      alienId: typeof filter.alienId === "string" ? filter.alienId : null,
+      discoveryDate:
+        discovery && typeof discovery === "object"
+          ? (discovery as PlanetFilter["discoveryDate"])
+          : undefined,
+    };
+  }
+  const start = query["filter[discoveryDate][start]"] ?? query.discoveryDateStart;
+  const end = query["filter[discoveryDate][end]"] ?? query.discoveryDateEnd;
+  return {
+    search:
+      typeof query["filter[search]"] === "string"
+        ? (query["filter[search]"] as string)
+        : typeof query.search === "string"
+          ? query.search
+          : undefined,
+    alienId:
+      typeof query["filter[alienId]"] === "string"
+        ? (query["filter[alienId]"] as string)
+        : typeof query.alienId === "string"
+          ? query.alienId
+          : undefined,
+    discoveryDate:
+      typeof start === "string" || typeof end === "string"
+        ? {
+            start: typeof start === "string" ? start : null,
+            end: typeof end === "string" ? end : null,
+          }
+        : undefined,
+  };
+}
+
+function parseOrder(order: string | null | undefined) {
+  return (order || DEFAULT_ORDER)
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .map((item) => {
+      const direction = item.startsWith("-") ? "desc" : "asc";
+      const key = item.replace(/^[+-]/, "");
+      return SORTABLE.has(key) ? { key, direction } : undefined;
+    })
+    .filter((item): item is { key: string; direction: "asc" | "desc" } => Boolean(item));
+}
+
+function compare(a: PlanetRow, b: PlanetRow, key: string, direction: "asc" | "desc") {
+  const aValue = a[key as keyof PlanetRow];
+  const bValue = b[key as keyof PlanetRow];
+  if (!aValue && !bValue) return 0;
+  if (!aValue) return 1;
+  if (!bValue) return -1;
+  const left = aValue instanceof Date ? aValue.toISOString() : String(aValue);
+  const right = bValue instanceof Date ? bValue.toISOString() : String(bValue);
+  const result = left.localeCompare(right);
+  return direction === "asc" ? result : -result;
+}
+
+export function sortPlanets(rows: PlanetRow[], order: string | null | undefined) {
+  const sorting = parseOrder(order);
+  return [...rows].sort((a, b) => {
+    for (const sort of sorting) {
+      const result = compare(a, b, sort.key, sort.direction);
+      if (result !== 0) return result;
+    }
+    return a.name.localeCompare(b.name);
+  });
+}
+
+export function filterPlanetRows(
+  rows: PlanetRow[],
+  alienById: Map<string, AlienRow>,
+  filters: PlanetFilter | undefined,
+) {
+  if (!filters) return rows;
+  const search = filters.search?.trim().toLocaleLowerCase();
+  return rows.filter((planet) => {
+    if (search) {
+      const haystack = [
+        planet.name,
+        planet.description,
+        planet.creatorName,
+        planet.alienId ? alienById.get(planet.alienId)?.name : undefined,
+      ];
+      if (!haystack.some((value) => value?.toLocaleLowerCase().includes(search))) {
+        return false;
+      }
+    }
+    if (filters.alienId && planet.alienId !== filters.alienId) return false;
+    const range = filters.discoveryDate;
+    if (range?.start || range?.end) {
+      if (!planet.discoveryDate) return false;
+      const timestamp = Date.parse(requiredIso(planet.discoveryDate));
+      if (range.start && timestamp < Date.parse(range.start)) return false;
+      if (range.end && timestamp > Date.parse(range.end)) return false;
+    }
+    return true;
+  });
+}
+
+export function paginate<T>(items: T[], page?: number, limit?: number) {
+  const currentPage = page && page > 0 ? page : 1;
+  const currentLimit = limit && limit > 0 ? Math.min(limit, 20) : 20;
+  const start = (currentPage - 1) * currentLimit;
+  const nextPage = currentPage * currentLimit < items.length ? currentPage + 1 : null;
+  return {
+    items: items.slice(start, start + currentLimit),
+    page: currentPage,
+    cursor: String(currentPage),
+    nextCursor: nextPage ? String(nextPage) : null,
+    limit: currentLimit,
+    totalItems: items.length,
+  };
+}
+
+export async function ensureSeed(db: ApiHandlerContext<unknown, unknown>["db"], userId: string) {
+  const existingAliens = await db.select({ id: aliens.id }).from(aliens).limit(1);
+  if (existingAliens.length === 0) {
+    const now = new Date();
+    try {
+      await db.insert(aliens).values(
+        ALIEN_NAMES.map((name) => ({
+          name,
+          createdAt: now,
+          updatedAt: now,
+        })),
+      );
+    } catch {
+      // First request won the seed race.
+    }
+  }
+
+  const existingPlanets = await db.select({ id: planets.id }).from(planets).limit(1);
+  if (existingPlanets.length > 0) return;
+
+  const alienRows = await db.select().from(aliens).orderBy(asc(aliens.name));
+  if (alienRows.length === 0) return;
+  const now = new Date();
+  try {
+    await db.insert(planets).values(
+      PLANET_SEEDS.map(([name, description], index) => ({
+        userId,
+        creatorName: "Demo User",
+        alienId: alienRows[index % alienRows.length]?.id ?? null,
+        discoveryDate:
+          index % 2 === 0
+            ? new Date(`20${String(index + 1).padStart(2, "0")}-01-01T00:00:00.000Z`)
+            : null,
+        name,
+        description,
+        createdAt: now,
+        updatedAt: now,
+      })),
+    );
+  } catch {
+    // First request won the seed race.
+  }
+}
+
+export async function resolveImage(
+  ctx: ApiHandlerContext<unknown, unknown>,
+  imageId: string | null | undefined,
+): Promise<{ id: string; url: string } | null> {
+  if (!imageId) return null;
+  const [row] = await ctx.db.select().from(media).where(eq(media.id, imageId)).limit(1);
+  if (!row?.uploaded) return null;
+  try {
+    const url = await ctx.storage.getUrl(row.key);
+    return { id: row.id, url };
+  } catch {
+    return { id: row.id, url: `/storage/objects/${encodeURIComponent(row.key)}` };
+  }
+}
+
+export async function enrichPlanet(
+  ctx: ApiHandlerContext<unknown, unknown>,
+  planet: PlanetRow,
+  currentUserId: string,
+  alienById: Map<string, AlienRow>,
+  likes: { planetId: string; userId: string }[],
+): Promise<PlanetDto> {
+  const planetLikes = likes.filter((like) => like.planetId === planet.id);
+  return {
+    id: planet.id,
+    userId: planet.userId,
+    alienId: planet.alienId,
+    discoveryDate: iso(planet.discoveryDate),
+    name: planet.name,
+    description: planet.description,
+    createdAt: requiredIso(planet.createdAt),
+    updatedAt: requiredIso(planet.updatedAt),
+    image: await resolveImage(ctx, planet.imageId),
+    creatorName: planet.creatorName ?? undefined,
+    alienName: planet.alienId ? alienById.get(planet.alienId)?.name : undefined,
+    likesCount: planetLikes.length,
+    likedByMe: planetLikes.some((like) => like.userId === currentUserId),
+  };
+}
+
+export async function loadLookups(db: ApiHandlerContext<unknown, unknown>["db"]) {
+  const [alienRows, likeRows] = await Promise.all([
+    db.select().from(aliens),
+    db.select({ planetId: planetLikes.planetId, userId: planetLikes.userId }).from(planetLikes),
+  ]);
+  return {
+    alienById: new Map(alienRows.map((row) => [row.id, row])),
+    likes: likeRows,
+  };
+}
+
+export async function enrichOne(
+  ctx: ApiHandlerContext<unknown, unknown>,
+  planet: PlanetRow,
+  currentUserId: string,
+) {
+  const lookups = await loadLookups(ctx.db);
+  return enrichPlanet(ctx, planet, currentUserId, lookups.alienById, lookups.likes);
+}
+
+export async function findPlanet(db: ApiHandlerContext<unknown, unknown>["db"], id: string) {
+  const [row] = await db.select().from(planets).where(eq(planets.id, id)).limit(1);
+  return row ?? null;
+}
+
+export async function validateAlien(
+  db: ApiHandlerContext<unknown, unknown>["db"],
+  alienId: string | null | undefined,
+) {
+  if (!alienId) return null;
+  const [row] = await db.select().from(aliens).where(eq(aliens.id, alienId)).limit(1);
+  return row ?? null;
+}
+
+export async function validateImage(
+  db: ApiHandlerContext<unknown, unknown>["db"],
+  image: { id: string } | null | undefined,
+  userId: string,
+) {
+  if (!image) return null;
+  const [row] = await db.select().from(media).where(eq(media.id, image.id)).limit(1);
+  if (!row) return { error: fail(404, "Media not found") };
+  if (row.userId !== userId) return { error: fail(403, "You can only use your own media") };
+  if (row.resourceName !== PLANET_IMAGE_RESOURCE) {
+    return { error: fail(400, "Media cannot be used as a planet image") };
+  }
+  if (!row.uploaded)
+    return { error: fail(400, "Media must be uploaded before it can be attached") };
+  return { id: row.id };
+}
+
+export { aliens, media, planetLikes, planets };

package/templates/space/api/aliens/labels.ts

@@ -0,0 +1,19 @@
+import { defineApi, z } from "@robodev-ai/sdk";
+import { aliens, ensureSeed } from "../_lib";
+
+export const get = defineApi({
+  auth: "required",
+  query: z.object({
+    search: z.string().optional(),
+  }),
+  handler: async (ctx) => {
+    await ensureSeed(ctx.db, ctx.user!.id);
+    const search = ctx.query.search?.trim().toLocaleLowerCase();
+    const rows = await ctx.db.select().from(aliens);
+    return rows
+      .filter((row) => !search || row.name.toLocaleLowerCase().includes(search))
+      .sort((a, b) => a.name.localeCompare(b.name))
+      .slice(0, 50)
+      .map((row) => ({ id: row.id, label: row.name }));
+  },
+});

package/templates/space/api/files/presigned-url.ts

@@ -0,0 +1,48 @@
+import { defineApi, z } from "@robodev-ai/sdk";
+import { media, PLANET_IMAGE_RESOURCE } from "../_lib";
+
+const ALLOWED = new Set(["image/jpeg", "image/png", "image/webp"]);
+const MAX_BYTES = 2 * 1024 * 1024;
+
+export const post = defineApi({
+  auth: "required",
+  body: z.object({
+    resourceName: z.string().optional(),
+    fileName: z.string().min(1),
+    fileSize: z.number().int().positive(),
+    mimeType: z.string().optional(),
+    method: z.string().optional(),
+  }),
+  handler: async (ctx) => {
+    const mimeType = ctx.body.mimeType || "application/octet-stream";
+    if (ctx.body.fileSize > MAX_BYTES) {
+      return { status: 400, body: { message: "File is too large" } };
+    }
+    if (ctx.body.resourceName === PLANET_IMAGE_RESOURCE && !ALLOWED.has(mimeType)) {
+      return { status: 400, body: { message: "Unsupported image type" } };
+    }
+
+    const key = `planet-images/${ctx.user!.id}/${crypto.randomUUID()}-${ctx.body.fileName.replaceAll("/", "-")}`;
+    const [row] = await ctx.db
+      .insert(media)
+      .values({
+        key,
+        userId: ctx.user!.id,
+        resourceName: ctx.body.resourceName || PLANET_IMAGE_RESOURCE,
+        fileName: ctx.body.fileName,
+        fileSize: ctx.body.fileSize,
+        mimeType,
+      })
+      .returning();
+
+    return {
+      id: row!.id,
+      method: "post",
+      url: "/api/files/upload",
+      fields: [
+        ["id", row!.id],
+        ["key", key],
+      ],
+    };
+  },
+});

package/templates/space/api/files/upload.ts

@@ -0,0 +1,29 @@
+import { defineApi, eq } from "@robodev-ai/sdk";
+import { fail, media } from "../_lib";
+
+export const post = defineApi({
+  auth: "required",
+  multipart: true,
+  handler: async (ctx) => {
+    const id =
+      typeof ctx.body === "object" && ctx.body && "id" in ctx.body ? String(ctx.body.id) : "";
+    const file = ctx.files?.[0];
+    if (!id || !file) return fail(400, "Missing file upload");
+
+    const [row] = await ctx.db.select().from(media).where(eq(media.id, id)).limit(1);
+    if (!row) return fail(404, "Media not found");
+    if (row.userId !== ctx.user!.id) return fail(403, "You can only upload your own media");
+
+    try {
+      await ctx.storage.upload(row.key, file.data, {
+        public: true,
+        contentType: file.mimetype || row.mimeType,
+      });
+    } catch (error) {
+      return fail(503, error instanceof Error ? error.message : "Storage is not configured");
+    }
+
+    await ctx.db.update(media).set({ uploaded: new Date() }).where(eq(media.id, row.id));
+    return { ok: true, id: row.id };
+  },
+});

package/templates/space/api/planets/[id]/like.ts

@@ -0,0 +1,36 @@
+import { and, defineApi, eq } from "@robodev-ai/sdk";
+import { enrichOne, fail, findPlanet, planetLikes } from "../../_lib";
+
+export const post = defineApi({
+  auth: "required",
+  handler: async (ctx) => {
+    const planet = await findPlanet(ctx.db, ctx.params.id);
+    if (!planet) return fail(404, "Planet not found");
+    const [existing] = await ctx.db
+      .select({ id: planetLikes.id })
+      .from(planetLikes)
+      .where(and(eq(planetLikes.planetId, planet.id), eq(planetLikes.userId, ctx.user!.id)))
+      .limit(1);
+    if (!existing) {
+      await ctx.db.insert(planetLikes).values({
+        planetId: planet.id,
+        userId: ctx.user!.id,
+      });
+    }
+    return enrichOne(ctx, planet, ctx.user!.id);
+  },
+});
+
+const unlikePlanet = defineApi({
+  auth: "required",
+  handler: async (ctx) => {
+    const planet = await findPlanet(ctx.db, ctx.params.id);
+    if (!planet) return fail(404, "Planet not found");
+    await ctx.db
+      .delete(planetLikes)
+      .where(and(eq(planetLikes.planetId, planet.id), eq(planetLikes.userId, ctx.user!.id)));
+    return enrichOne(ctx, planet, ctx.user!.id);
+  },
+});
+
+export { unlikePlanet as delete };

package/templates/space/api/planets/[id].ts

@@ -1,21 +1,64 @@
-/** GET /api/planets/:id — one planet by path param. */
 import { defineApi, eq, z } from "@robodev-ai/sdk";
-import { planets } from "../../database";
+import { enrichOne, fail, findPlanet, planets, validateAlien, validateImage } from "../_lib";
 
-const Planet = z.object({
-  id: z.string(),
-  name: z.string(),
-  climate: z.string(),
-  moons: z.coerce.number(),
+const planetBody = z.object({
+  name: z.string().min(1),
+  alienId: z.string().nullish(),
+  discoveryDate: z.string().nullish(),
+  description: z.string().nullish(),
+  image: z.object({ id: z.string() }).nullish(),
 });
 
 export const get = defineApi({
-  response: Planet,
-  handler: async ({ db, params }) => {
-    const [row] = await db.select().from(planets).where(eq(planets.id, params.id)).limit(1);
-    if (!row) {
-      return { status: 404, body: { error: "not_found" } };
+  auth: "required",
+  handler: async (ctx) => {
+    const planet = await findPlanet(ctx.db, ctx.params.id);
+    if (!planet) return fail(404, "Planet not found");
+    return enrichOne(ctx, planet, ctx.user!.id);
+  },
+});
+
+export const put = defineApi({
+  auth: "required",
+  body: planetBody,
+  handler: async (ctx) => {
+    const planet = await findPlanet(ctx.db, ctx.params.id);
+    if (!planet) return fail(404, "Planet not found");
+    if (planet.userId !== ctx.user!.id) return fail(403, "You can only update your own planets");
+
+    const alienId = ctx.body.alienId || null;
+    if (alienId && !(await validateAlien(ctx.db, alienId))) {
+      return fail(404, "Alien not found");
     }
-    return Planet.parse(row);
+    const image = await validateImage(ctx.db, ctx.body.image, ctx.user!.id);
+    if (image && "error" in image) return image.error;
+
+    const [updated] = await ctx.db
+      .update(planets)
+      .set({
+        name: ctx.body.name,
+        alienId,
+        discoveryDate: ctx.body.discoveryDate ? new Date(ctx.body.discoveryDate) : null,
+        description: ctx.body.description ?? null,
+        imageId: image?.id ?? null,
+        updatedAt: new Date(),
+      })
+      .where(eq(planets.id, planet.id))
+      .returning();
+    if (!updated) return fail(404, "Planet not found");
+    return enrichOne(ctx, updated, ctx.user!.id);
   },
 });
+
+const deletePlanet = defineApi({
+  auth: "required",
+  handler: async (ctx) => {
+    const planet = await findPlanet(ctx.db, ctx.params.id);
+    if (!planet) return fail(404, "Planet not found");
+    if (planet.userId !== ctx.user!.id) return fail(403, "You can only delete your own planets");
+    await ctx.db.delete(planets).where(eq(planets.id, planet.id));
+    return { status: 204, body: null };
+  },
+});
+
+export { deletePlanet as delete };

package/templates/space/api/planets/paginate.ts

@@ -0,0 +1,36 @@
+import { defineApi } from "@robodev-ai/sdk";
+import {
+  ensureSeed,
+  enrichPlanet,
+  filterPlanetRows,
+  loadLookups,
+  paginate,
+  parseFilter,
+  planets,
+  sortPlanets,
+} from "../_lib";
+
+export const get = defineApi({
+  auth: "required",
+  handler: async (ctx) => {
+    await ensureSeed(ctx.db, ctx.user!.id);
+    const query = ctx.query as Record<string, unknown>;
+    const rows = await ctx.db.select().from(planets);
+    const lookups = await loadLookups(ctx.db);
+    const filter = parseFilter(query);
+    const filtered = filterPlanetRows(rows, lookups.alienById, filter);
+    const page = paginate(
+      sortPlanets(filtered, typeof query.order === "string" ? query.order : undefined),
+      Number(query.page) || undefined,
+      Number(query.limit) || undefined,
+    );
+    return {
+      ...page,
+      items: await Promise.all(
+        page.items.map((row) =>
+          enrichPlanet(ctx, row, ctx.user!.id, lookups.alienById, lookups.likes),
+        ),
+      ),
+    };
+  },
+});