@gigamusic/links 3.0.0 → 4.2.0

package/README.md

@@ -1,14 +1,16 @@
 # @gigamusic/links
 
-Linktree-style per-release link pages for the gigamusic platform. Ships a Drizzle schema (`linkPages`, `linkPageItems`), a typed queries factory, admin API handler factories, platform-detection helpers, and a small SVG `LinkPlatformIcon` component.
+Linktree-style per-release link pages for the gigamusic platform. Ships admin API handler factories, platform-detection helpers, and a small SVG `LinkPlatformIcon` component.
+
+The `link_pages` / `link_page_items` Drizzle schema **and** the link-page queries live in `@gigamusic/db` — they're folded into the single `createQueries(db)` so a consumer builds one query object for every table. This package re-exports the link-page row types for convenience.
 
 ```ts
 import {
-  createLinkPageQueries,
   detectLinkPlatform,
   PLATFORM_LABELS,
   LinkPlatformIcon,
   type KnownLinkPlatform,
+  type LinkPageWithItems,
 } from "@gigamusic/links";
 
 // Admin handler factories live on the /server subpath
@@ -19,43 +21,32 @@ import {
 } from "@gigamusic/links/server";
 ```
 
-The public link-page UI is the consumer's responsibility — fetch with `createLinkPageQueries(db).getPublicLinkPageBySlug(slug)` and render whatever you want.
-
-## Schema subpath
+## Reads and writes
 
-`@gigamusic/links/schema` exports the table objects and relations:
+All link-page DB access comes from `@gigamusic/db`'s queries:
 
 ```ts
-import {
-  linkPages,
-  linkPageItems,
-  linkPagesRelations,
-  linkPageItemsRelations,
-  linkPageColumns,
-  linkPageItemColumns,
-} from "@gigamusic/links/schema";
+import { createQueries } from "@gigamusic/db";
+
+const queries = createQueries(db); // one object, every table
+
+// Public link-page UI — fetch and render whatever you want:
+const page = await queries.getPublicLinkPageBySlug(slug);
 ```
 
-Merge with `@gigamusic/db/schema` when constructing your Drizzle instance:
+The admin handler factories from `@gigamusic/links/server` take that same `queries` object:
 
 ```ts
-import { drizzle } from "drizzle-orm/node-postgres";
-import { Pool } from "pg";
-import * as dbSchema from "@gigamusic/db/schema";
-import * as linksSchema from "@gigamusic/links/schema";
-
-const schema = { ...dbSchema, ...linksSchema };
-export const db = drizzle(new Pool({ connectionString: process.env.DATABASE_URL }), { schema });
+const handlers = createAdminLinkPagesHandlers({ queries });
 ```
 
 ## Release back-reference
 
-`linkPages.releaseId` is a nullable FK to `releases.id` from `@gigamusic/db`. Drizzle relations are declared independently on each side, so this package's `linkPagesRelations` already declares the `linkPage.release` direction. If you want a `release.linkPages` back-reference (for `db.query.releases.findFirst({ with: { linkPages: true } })`), add it in your own schema file by composing onto the base `releasesRelations`:
+`linkPages.releaseId` is a nullable FK to `releases.id`. Both tables and their relations live in `@gigamusic/db/schema`; `linkPagesRelations` already declares the `linkPage.release` direction. If you want a `release.linkPages` back-reference (for `db.query.releases.findFirst({ with: { linkPages: true } })`), compose it onto the base `releasesRelations` in your own schema file:
 
 ```ts
 import { relations } from "drizzle-orm";
-import { releases } from "@gigamusic/db/schema";
-import { linkPages } from "@gigamusic/links/schema";
+import { releases, linkPages } from "@gigamusic/db/schema";
 
 export const releasesRelations = relations(releases, ({ many }) => ({
   // ...keep the existing many() relations from @gigamusic/db/schema if you need them...

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gigamusic/links",
-  "version": "3.0.0",
-  "description": "Editable Linktree-style link pages for gigamusic artist sites. Ships a Drizzle schema, admin API handler factories, and platform-detection helpers.",
+  "version": "4.2.0",
+  "description": "Editable Linktree-style link pages for gigamusic artist sites. Ships admin API handler factories and platform-detection helpers (the Drizzle schema + queries live in @gigamusic/db).",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,10 +17,6 @@
     "./server": {
       "types": "./src/server.ts",
       "default": "./src/server.ts"
-    },
-    "./schema": {
-      "types": "./src/schema/index.ts",
-      "default": "./src/schema/index.ts"
     }
   },
   "files": [
@@ -32,23 +28,18 @@
   },
   "dependencies": {
     "zod": "^3.24.1",
-    "@gigamusic/db": "3.0.0",
-    "@gigamusic/core": "3.0.0"
+    "@gigamusic/db": "4.2.0",
+    "@gigamusic/core": "4.2.0"
   },
   "peerDependencies": {
-    "drizzle-orm": ">=0.45",
     "next": ">=15",
     "react": ">=18 <20",
     "react-dom": ">=18 <20"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",
-    "@types/pg": "^8.11.10",
     "@types/react": "^19.0.0",
-    "drizzle-kit": "^0.31.10",
-    "drizzle-orm": "^0.45.2",
     "next": "^16.0.0",
-    "pg": "^8.21.0",
     "react": "^19.0.0",
     "typescript": "^5.7.3",
     "vitest": "^2.1.8"

package/src/api/handlers.ts

@@ -1,13 +1,8 @@
 import { revalidateTag } from "next/cache";
 import { z } from "zod";
 import { LinkPageInputSchema, LinkPageItemInputSchema } from "@gigamusic/core";
-import type {
-  DefaultLinkPageTables,
-  LinkPageInput,
-  LinkPageItemInput,
-  LinkPageQueries,
-  LinkPageQueryTables,
-} from "../types";
+import type { LinkPageInput, LinkPageItemInput } from "@gigamusic/core";
+import type { DefaultTables, Queries, QueryTables } from "@gigamusic/db";
 import {
   INVALID_SLUG_MESSAGE,
   RESERVED_SLUGS,
@@ -32,7 +27,7 @@ export type RouteHandler<Params = Record<string, string>> = (
 /**
  * Deps for the admin-side link-page handler factories.
  *
- * Generic over the consumer's `LinkPageQueryTables` so the `Queries` and the
+ * Generic over the consumer's `QueryTables` so the `Queries` and the
  * `afterWrite` callbacks see consumer-extended `linkPages` / `linkPageItems`
  * row shapes when the consumer built tables via `buildLinkPages(...)` /
  * `buildLinkPageItems(...)`.
@@ -41,11 +36,11 @@ export type RouteHandler<Params = Record<string, string>> = (
  * `proxy.ts` / middleware. These handlers don't verify a session.
  */
 export interface LinkPagesAdminDeps<
-  T extends LinkPageQueryTables = DefaultLinkPageTables,
+  T extends QueryTables = DefaultTables,
   TPageInput extends z.ZodObject<any> = typeof LinkPageInputSchema,
   TItemInput extends z.ZodObject<any> = typeof LinkPageItemInputSchema,
 > {
-  queries: LinkPageQueries<T>;
+  queries: Queries<T>;
   /** Defaults to `LinkPageInputSchema`. Pass an `.extend()`ed schema for extras. */
   pageInputSchema?: TPageInput;
   /** Defaults to `LinkPageItemInputSchema`. Pass an `.extend()`ed schema for extras. */
@@ -80,7 +75,7 @@ function validateSlug(slug: string): { ok: true } | { ok: false; res: Response }
  * `app/api/admin/link-pages/route.ts` handlers — list + create.
  */
 export function createAdminLinkPagesHandlers<
-  T extends LinkPageQueryTables = DefaultLinkPageTables,
+  T extends QueryTables = DefaultTables,
   TPageInput extends z.ZodObject<any> = typeof LinkPageInputSchema,
   TItemInput extends z.ZodObject<any> = typeof LinkPageItemInputSchema,
 >(deps: LinkPagesAdminDeps<T, TPageInput, TItemInput>): {
@@ -139,7 +134,7 @@ export function createAdminLinkPagesHandlers<
  * `app/api/admin/link-pages/[id]/route.ts` handlers — single-page CRUD.
  */
 export function createAdminLinkPageByIdHandlers<
-  T extends LinkPageQueryTables = DefaultLinkPageTables,
+  T extends QueryTables = DefaultTables,
   TPageInput extends z.ZodObject<any> = typeof LinkPageInputSchema,
   TItemInput extends z.ZodObject<any> = typeof LinkPageItemInputSchema,
 >(deps: LinkPagesAdminDeps<T, TPageInput, TItemInput>): {
@@ -229,7 +224,7 @@ interface LinkPageItemBody {
  * DELETE removes an item by `itemId` in the query string.
  */
 export function createAdminLinkPageItemsHandlers<
-  T extends LinkPageQueryTables = DefaultLinkPageTables,
+  T extends QueryTables = DefaultTables,
   TPageInput extends z.ZodObject<any> = typeof LinkPageInputSchema,
   TItemInput extends z.ZodObject<any> = typeof LinkPageItemInputSchema,
 >(deps: LinkPagesAdminDeps<T, TPageInput, TItemInput>): {

package/src/index.ts

@@ -1,22 +1,16 @@
-// Public entry — server-safe types, queries, and platform helpers.
-// Admin handler factories live on the `./server` subpath.
+// Public entry — platform helpers + UI, plus a convenience re-export of the
+// link-page DB types. The queries themselves come from `@gigamusic/db`'s
+// `createQueries(db, site)`; admin handler factories live on `./server`.
 
-// ── Types ────────────────────────────────────────────────────────────────
+// ── Types (re-exported from @gigamusic/db, the single source for DB types) ─
 export type {
-  DefaultLinkPageTables,
   LinkPage,
   LinkPageItem,
   LinkPageReleaseRef,
   LinkPageWithItems,
-  LinkPageQueries,
-  LinkPageQueryTables,
   LinkPageInput,
   LinkPageItemInput,
-} from "./types";
-
-// ── Queries factory ─────────────────────────────────────────────────────
-export { createLinkPageQueries } from "./queries/link-pages";
-export type { LinkPagesDb } from "./queries/link-pages";
+} from "@gigamusic/db";
 
 // ── Platform detection ──────────────────────────────────────────────────
 export { detectLinkPlatform, PLATFORM_LABELS } from "./platforms/detect";

package/src/server.ts

@@ -1,9 +1,7 @@
-// Server-only entry — admin API handler factories and the queries factory.
-// Importing from here in a `"use client"` file will cause a build error
-// because the handlers depend on `next/cache`.
+// Server-only entry — admin API handler factories. Importing from here in a
+// `"use client"` file will cause a build error because the handlers depend on
+// `next/cache`. (The query factory lives in `@gigamusic/db`'s `createQueries`.)
 
-export { createLinkPageQueries } from "./queries/link-pages";
-export type { LinkPagesDb } from "./queries/link-pages";
 export {
   createAdminLinkPagesHandlers,
   createAdminLinkPageByIdHandlers,

package/src/queries/link-pages.ts

@@ -1,211 +0,0 @@
-import { and, asc, desc, eq, max } from "drizzle-orm";
-import type { NodePgDatabase } from "drizzle-orm/node-postgres";
-import type * as gigamusicDbSchema from "@gigamusic/db/schema";
-import type * as linksSchema from "../schema/index";
-import {
-  linkPageItems as baseLinkPageItems,
-  linkPages as baseLinkPages,
-} from "../schema/index";
-import type {
-  DefaultLinkPageTables,
-  LinkPage,
-  LinkPageInput,
-  LinkPageItem,
-  LinkPageItemInput,
-  LinkPageQueries,
-  LinkPageQueryTables,
-  LinkPageWithItems,
-} from "../types";
-
-type RequiredSchema = typeof gigamusicDbSchema & typeof linksSchema;
-
-/** Drizzle DB type the link-pages factory needs — a superset that includes both link-pages tables and `releases`. */
-export type LinkPagesDb = NodePgDatabase<RequiredSchema>;
-
-/**
- * Factory that binds a Drizzle database into the `LinkPageQueries` contract.
- * Consumers typically merge the result with `@gigamusic/db`'s `createQueries`.
- *
- * Pass a `tables` arg to thread consumer-extended `linkPages` / `linkPageItems`
- * (built via the `buildLinkPages` / `buildLinkPageItems` factories) through
- * every query — the returned `LinkPageQueries<T>` rows carry the consumer's
- * extra columns. Single-arg callers fall back to the un-extended convenience
- * tables.
- *
- * The `db` instance must have been built with a schema that includes the
- * union of `@gigamusic/db/schema` and `@gigamusic/links/schema`; otherwise
- * the relational `with: { release: ... }` clause won't resolve at runtime.
- */
-export function createLinkPageQueries(db: LinkPagesDb): LinkPageQueries;
-export function createLinkPageQueries<T extends LinkPageQueryTables>(
-  db: LinkPagesDb,
-  tables: T,
-): LinkPageQueries<T>;
-export function createLinkPageQueries<T extends LinkPageQueryTables>(
-  db: LinkPagesDb,
-  tables?: T,
-): LinkPageQueries<T> {
-  // Identity is preserved at runtime; the casts only widen for the type
-  // checker so consumer-extended tables don't have to match the base shape
-  // exactly.
-  const linkPages = (tables?.linkPages ?? baseLinkPages) as unknown as typeof baseLinkPages;
-  const linkPageItems = (tables?.linkPageItems ??
-    baseLinkPageItems) as unknown as typeof baseLinkPageItems;
-
-  return {
-    listPublishedLinkPages: async (): Promise<LinkPage<T>[]> => {
-      const rows = await db.query.linkPages.findMany({
-        where: eq(linkPages.isPublished, true),
-        orderBy: desc(linkPages.updatedAt),
-      });
-      return rows as unknown as LinkPage<T>[];
-    },
-
-    listAllLinkPages: async (): Promise<LinkPage<T>[]> => {
-      const rows = await db.query.linkPages.findMany({
-        orderBy: desc(linkPages.updatedAt),
-      });
-      return rows as unknown as LinkPage<T>[];
-    },
-
-    getPublicLinkPageBySlug: async (slug: string): Promise<LinkPageWithItems<T> | null> => {
-      const row = await db.query.linkPages.findFirst({
-        where: and(eq(linkPages.slug, slug), eq(linkPages.isPublished, true)),
-        with: {
-          release: {
-            columns: {
-              id: true,
-              name: true,
-              slug: true,
-              coverImageUrl: true,
-              isPublished: true,
-            },
-          },
-          items: {
-            where: eq(linkPageItems.isVisible, true),
-            orderBy: asc(linkPageItems.position),
-          },
-        },
-      });
-      return (row ?? null) as unknown as LinkPageWithItems<T> | null;
-    },
-
-    getLinkPageById: async (id: number): Promise<LinkPageWithItems<T> | null> => {
-      const row = await db.query.linkPages.findFirst({
-        where: eq(linkPages.id, id),
-        with: {
-          release: {
-            columns: {
-              id: true,
-              name: true,
-              slug: true,
-              coverImageUrl: true,
-              isPublished: true,
-            },
-          },
-          items: { orderBy: asc(linkPageItems.position) },
-        },
-      });
-      return (row ?? null) as unknown as LinkPageWithItems<T> | null;
-    },
-
-    createLinkPage: async (input: LinkPageInput): Promise<LinkPage<T>> => {
-      const [row] = await db
-        .insert(linkPages)
-        .values({
-          title: input.title,
-          slug: input.slug,
-          description: input.description ?? null,
-          releaseId: input.releaseId ?? null,
-          coverImageUrl: input.coverImageUrl ?? null,
-          isPublished: input.isPublished ?? true,
-        })
-        .returning();
-      return row! as unknown as LinkPage<T>;
-    },
-
-    updateLinkPage: async (id: number, input: Partial<LinkPageInput>): Promise<LinkPage<T>> => {
-      const data: Record<string, unknown> = {};
-      if (input.title !== undefined) data.title = input.title;
-      if (input.slug !== undefined) data.slug = input.slug;
-      if (input.description !== undefined) data.description = input.description;
-      if (input.releaseId !== undefined) data.releaseId = input.releaseId;
-      if (input.coverImageUrl !== undefined) data.coverImageUrl = input.coverImageUrl;
-      if (input.isPublished !== undefined) data.isPublished = input.isPublished;
-      const [row] = await db.update(linkPages).set(data).where(eq(linkPages.id, id)).returning();
-      return row! as unknown as LinkPage<T>;
-    },
-
-    deleteLinkPage: async (id: number): Promise<void> => {
-      await db.delete(linkPages).where(eq(linkPages.id, id));
-    },
-
-    addLinkPageItem: async (
-      pageId: number,
-      input: LinkPageItemInput,
-    ): Promise<LinkPageItem<T>> => {
-      const [maxRow] = await db
-        .select({ max: max(linkPageItems.position) })
-        .from(linkPageItems)
-        .where(eq(linkPageItems.pageId, pageId));
-      const nextPosition = input.position ?? ((maxRow?.max ?? -1) + 1);
-      const [row] = await db
-        .insert(linkPageItems)
-        .values({
-          pageId,
-          title: input.title,
-          url: input.url,
-          position: nextPosition,
-          isVisible: input.isVisible ?? true,
-        })
-        .returning();
-      return row! as unknown as LinkPageItem<T>;
-    },
-
-    updateLinkPageItem: async (
-      id: number,
-      input: Partial<LinkPageItemInput>,
-    ): Promise<LinkPageItem<T>> => {
-      const data: Record<string, unknown> = {};
-      if (input.title !== undefined) data.title = input.title;
-      if (input.url !== undefined) data.url = input.url;
-      if (input.position !== undefined) data.position = input.position;
-      if (input.isVisible !== undefined) data.isVisible = input.isVisible;
-      const [row] = await db
-        .update(linkPageItems)
-        .set(data)
-        .where(eq(linkPageItems.id, id))
-        .returning();
-      return row! as unknown as LinkPageItem<T>;
-    },
-
-    deleteLinkPageItem: async (id: number): Promise<void> => {
-      await db.delete(linkPageItems).where(eq(linkPageItems.id, id));
-    },
-
-    /**
-     * Rewrite every item's `position` to match the caller's preferred order
-     * inside a single transaction. IDs not present in `orderedItemIds` keep
-     * their current position — callers must include the full set to fully
-     * resort.
-     */
-    reorderLinkPageItems: async (pageId: number, orderedItemIds: number[]): Promise<void> => {
-      await db.transaction(async (tx) => {
-        for (let position = 0; position < orderedItemIds.length; position++) {
-          await tx
-            .update(linkPageItems)
-            .set({ position })
-            .where(
-              and(
-                eq(linkPageItems.id, orderedItemIds[position]!),
-                eq(linkPageItems.pageId, pageId),
-              ),
-            );
-        }
-      });
-    },
-  };
-}
-
-// Re-export DefaultLinkPageTables so the consumer can import it if they want.
-export type { DefaultLinkPageTables };

package/src/schema/index.ts

@@ -1,2 +0,0 @@
-export * from "./link-pages";
-export * from "./relations";

package/src/schema/link-pages.ts

@@ -1,56 +0,0 @@
-import { boolean, index, integer, pgTable, serial, text, timestamp } from "drizzle-orm/pg-core";
-import { releases } from "@gigamusic/db/schema";
-import type { ExtraColumns } from "@gigamusic/db/schema";
-
-// See @gigamusic/db/schema/releases.ts for the rationale on inlining
-// columns inside the factory (TTableName generic resolution).
-export function buildLinkPages<TExtras extends ExtraColumns = {}>(
-  extras: TExtras = {} as TExtras,
-) {
-  return pgTable(
-    "link_pages",
-    {
-      id:            serial("id").primaryKey(),
-      slug:          text("slug").notNull().unique("link_pages_slug_key"),
-      title:         text("title").notNull(),
-      description:   text("description"),
-      coverImageUrl: text("coverImageUrl"),
-      releaseId:     integer("releaseId").references(() => releases.id, { onDelete: "set null" }),
-      isPublished:   boolean("isPublished").notNull().default(true),
-      createdAt:     timestamp("createdAt", { mode: "date", precision: 3 }).notNull().defaultNow(),
-      updatedAt:     timestamp("updatedAt", { mode: "date", precision: 3 })
-        .notNull()
-        .$defaultFn(() => new Date())
-        .$onUpdateFn(() => new Date()),
-      ...extras,
-    },
-    (t) => [index("link_pages_releaseId_idx").on(t.releaseId)],
-  );
-}
-
-export const linkPages = buildLinkPages();
-
-export function buildLinkPageItems<TExtras extends ExtraColumns = {}>(
-  extras: TExtras = {} as TExtras,
-) {
-  return pgTable(
-    "link_page_items",
-    {
-      id:     serial("id").primaryKey(),
-      pageId: integer("pageId").notNull().references(() => linkPages.id, { onDelete: "cascade" }),
-      title:     text("title").notNull(),
-      url:       text("url").notNull(),
-      position:  integer("position").notNull().default(0),
-      isVisible: boolean("isVisible").notNull().default(true),
-      createdAt: timestamp("createdAt", { mode: "date", precision: 3 }).notNull().defaultNow(),
-      updatedAt: timestamp("updatedAt", { mode: "date", precision: 3 })
-        .notNull()
-        .$defaultFn(() => new Date())
-        .$onUpdateFn(() => new Date()),
-      ...extras,
-    },
-    (t) => [index("link_page_items_pageId_idx").on(t.pageId)],
-  );
-}
-
-export const linkPageItems = buildLinkPageItems();

package/src/schema/relations.ts

@@ -1,54 +0,0 @@
-import { relations } from "drizzle-orm";
-import type { PgTable } from "drizzle-orm/pg-core";
-import { releases as baseReleases } from "@gigamusic/db/schema";
-import {
-  linkPages as baseLinkPages,
-  linkPageItems as baseLinkPageItems,
-} from "./link-pages";
-
-// `PgTable<any>` so consumer concrete tables satisfy these factory params —
-// see @gigamusic/db's types.ts for the variance rationale.
-type AnyPgTableValue = PgTable<any>;
-
-export function createLinkPagesRelations(t: {
-  linkPages: AnyPgTableValue;
-  linkPageItems: AnyPgTableValue;
-  releases: AnyPgTableValue;
-}) {
-  const linkPages = t.linkPages as unknown as typeof baseLinkPages;
-  const linkPageItems = t.linkPageItems as unknown as typeof baseLinkPageItems;
-  const releases = t.releases as unknown as typeof baseReleases;
-  return relations(linkPages, ({ one, many }) => ({
-    release: one(releases, {
-      fields: [linkPages.releaseId],
-      references: [releases.id],
-    }),
-    items: many(linkPageItems),
-  }));
-}
-
-export function createLinkPageItemsRelations(t: {
-  linkPages: AnyPgTableValue;
-  linkPageItems: AnyPgTableValue;
-}) {
-  const linkPages = t.linkPages as unknown as typeof baseLinkPages;
-  const linkPageItems = t.linkPageItems as unknown as typeof baseLinkPageItems;
-  return relations(linkPageItems, ({ one }) => ({
-    page: one(linkPages, {
-      fields: [linkPageItems.pageId],
-      references: [linkPages.id],
-    }),
-  }));
-}
-
-// Convenience top-level exports bound to the un-extended convenience tables.
-export const linkPagesRelations = createLinkPagesRelations({
-  linkPages: baseLinkPages,
-  linkPageItems: baseLinkPageItems,
-  releases: baseReleases,
-});
-
-export const linkPageItemsRelations = createLinkPageItemsRelations({
-  linkPages: baseLinkPages,
-  linkPageItems: baseLinkPageItems,
-});

package/src/types.ts

@@ -1,76 +0,0 @@
-import type { PgTable } from "drizzle-orm/pg-core";
-import type { LinkPageInput, LinkPageItemInput } from "@gigamusic/core";
-import type * as linksSchema from "./schema/index";
-
-export type { LinkPageInput, LinkPageItemInput };
-
-// `PgTable<any>` (not `PgTable<TableConfig>`) so consumer concrete tables
-// satisfy this constraint — Drizzle's column generics are invariant on
-// column shape; see @gigamusic/db's types.ts for the full rationale.
-type AnyPgTableValue = PgTable<any>;
-
-/**
- * The bag of Drizzle table identities the link-page queries factory closes
- * over. Consumers can pass extended versions of these tables built via the
- * `buildLinkPages` / `buildLinkPageItems` factories; the `releases` reference
- * is the consumer's `releases` table (for the cover-image fallback join).
- */
-export interface LinkPageQueryTables {
-  linkPages: AnyPgTableValue;
-  linkPageItems: AnyPgTableValue;
-  releases: AnyPgTableValue;
-}
-
-export interface DefaultLinkPageTables extends LinkPageQueryTables {
-  linkPages: typeof linksSchema.linkPages;
-  linkPageItems: typeof linksSchema.linkPageItems;
-  // `releases` defaults to the gigamusic convenience table; consumers pass
-  // their own extended releases when they have one.
-  releases: AnyPgTableValue;
-}
-
-/** A single link button rendered inside a `LinkPage`. */
-export type LinkPageItem<T extends LinkPageQueryTables = DefaultLinkPageTables> =
-  T["linkPageItems"]["$inferSelect"];
-
-/** Optional `Release` reference exposed to the public view for cover fallback. */
-export interface LinkPageReleaseRef {
-  id: number;
-  name: string;
-  slug: string;
-  coverImageUrl: string | null;
-  isPublished: boolean;
-}
-
-/** Top-level "Linktree-style" page row. */
-export type LinkPage<T extends LinkPageQueryTables = DefaultLinkPageTables> =
-  T["linkPages"]["$inferSelect"];
-
-/** A `LinkPage` joined with its visible (or all) items and an optional release ref. */
-export type LinkPageWithItems<T extends LinkPageQueryTables = DefaultLinkPageTables> =
-  LinkPage<T> & {
-    items: LinkPageItem<T>[];
-    release?: LinkPageReleaseRef | null;
-  };
-
-/**
- * Query helpers that close over a Drizzle DB. Consumers merge this with
- * `@gigamusic/db`'s `Queries` factory result (or pass it through wherever a
- * `LinkPageQueries` is needed).
- */
-export interface LinkPageQueries<T extends LinkPageQueryTables = DefaultLinkPageTables> {
-  listPublishedLinkPages(): Promise<LinkPage<T>[]>;
-  listAllLinkPages(): Promise<LinkPage<T>[]>;
-  getPublicLinkPageBySlug(slug: string): Promise<LinkPageWithItems<T> | null>;
-  getLinkPageById(id: number): Promise<LinkPageWithItems<T> | null>;
-  createLinkPage(input: LinkPageInput): Promise<LinkPage<T>>;
-  updateLinkPage(id: number, input: Partial<LinkPageInput>): Promise<LinkPage<T>>;
-  deleteLinkPage(id: number): Promise<void>;
-  addLinkPageItem(pageId: number, input: LinkPageItemInput): Promise<LinkPageItem<T>>;
-  updateLinkPageItem(
-    id: number,
-    input: Partial<LinkPageItemInput>,
-  ): Promise<LinkPageItem<T>>;
-  deleteLinkPageItem(id: number): Promise<void>;
-  reorderLinkPageItems(pageId: number, orderedItemIds: number[]): Promise<void>;
-}