fix(db): stop /feed.xml crashing on "cannot infer relation posts.tags"

The schema barrel re-exports four tables under camelCase aliases for app
ergonomics (post_votes as postVotes, etc.). Passing the whole module
namespace to drizzle put two keys per table into its tableNamesMap; the
collision made drizzle attach each join table's relations to the alias
key and leave the canonical key with none. Relational queries that walk a
many-relation on those tables (with: { tags }, with: { votes }) then threw
"There is not enough information to infer relation posts.tags" — which is
exactly what /feed.xml does, so the RSS feed 500'd.

Strip the aliases from the schema object handed to drizzle so each table
is registered once; app code still imports the aliases from the barrel
unchanged. Adds a regression test that builds the /feed.xml query.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: NiallJoeMaher

server/db/index.ts

@@ -4,7 +4,20 @@ import { type Logger } from "drizzle-orm/logger";
 import postgres from "postgres";
 
 import { env } from "@/config/env";
-import * as schema from "@/server/db/schema";
+import * as schemaExports from "@/server/db/schema";
+
+// The schema barrel re-exports four tables under camelCase aliases for app-code
+// ergonomics (`post_votes as postVotes`, etc.). Those alias keys point at the
+// SAME table object as their snake_case originals, so handing the whole module
+// namespace to drizzle puts two keys per table into its tableNamesMap. The
+// collision makes drizzle attach each join table's relations to the alias key
+// and leave the canonical key with none, silently breaking relational queries
+// like `with: { tags }` / `with: { votes }` ("not enough information to infer
+// relation posts.tags"). Strip the aliases so each table reaches drizzle once;
+// app code still imports them from the schema barrel unchanged.
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const { postVotes, commentVotes, postTags, feedSources, ...schema } =
+  schemaExports;
 
 /**
  * Cache the database connection in development. This avoids creating a new connection on every HMR

server/db/relations.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect, beforeAll } from "vitest";
+
+// Regression guard for the tableNamesMap collision: the schema barrel re-exports
+// a few tables under camelCase aliases (postVotes/postTags/...), and feeding both
+// keys to drizzle dropped the join tables' relations — which broke `with: { tags }`
+// / `with: { votes }` on /feed.xml ("not enough information to infer relation
+// posts.tags"). server/db/index.ts strips the aliases before handing the schema
+// to drizzle; these tests fail if that regresses.
+describe("posts relational config", () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let db: any;
+
+  beforeAll(async () => {
+    process.env.SKIP_ENV_VALIDATION = "1";
+    process.env.DATABASE_URL ??= "postgres://user:pass@localhost:5432/test";
+    // Dynamic import so the env stubs above land before the module reads them.
+    ({ db } = await import("@/server/db"));
+  });
+
+  it("registers relations on the join tables (no alias collision)", () => {
+    const schema = db._.schema;
+    expect(Object.keys(schema.post_tags.relations)).toContain("post");
+    expect(Object.keys(schema.post_tags.relations)).toContain("tag");
+    expect(Object.keys(schema.post_votes.relations)).toContain("post");
+  });
+
+  it("builds the nested relational query used by /feed.xml", () => {
+    expect(() =>
+      db.query.posts
+        .findMany({
+          columns: { title: true },
+          with: {
+            author: { columns: { username: true } },
+            tags: { with: { tag: true } },
+          },
+          limit: 1,
+        })
+        .toSQL(),
+    ).not.toThrow();
+  });
+});