@gigamusic/links 2.1.1 → 4.0.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": "2.1.1",
-  "description": "Editable Linktree-style link pages for gigamusic artist sites. Ships a Drizzle schema, admin API handler factories, and platform-detection helpers.",
+  "version": "4.0.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": [
@@ -31,23 +27,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@gigamusic/core": "1.0.0",
-    "@gigamusic/db": "2.1.0"
+    "zod": "^3.24.1",
+    "@gigamusic/core": "3.0.0",
+    "@gigamusic/db": "4.0.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,5 +1,8 @@
 import { revalidateTag } from "next/cache";
-import type { LinkPageQueries } from "../types";
+import { z } from "zod";
+import { LinkPageInputSchema, LinkPageItemInputSchema } from "@gigamusic/core";
+import type { LinkPageInput, LinkPageItemInput } from "@gigamusic/core";
+import type { DefaultTables, Queries, QueryTables } from "@gigamusic/db";
 import {
   INVALID_SLUG_MESSAGE,
   RESERVED_SLUGS,
@@ -24,11 +27,28 @@ export type RouteHandler<Params = Record<string, string>> = (
 /**
  * Deps for the admin-side link-page handler factories.
  *
+ * 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(...)`.
+ *
  * Auth: the package assumes the request has been gated by the consumer's
  * `proxy.ts` / middleware. These handlers don't verify a session.
  */
-export interface LinkPagesAdminDeps {
-  queries: LinkPageQueries;
+export interface LinkPagesAdminDeps<
+  T extends QueryTables = DefaultTables,
+  TPageInput extends z.ZodObject<any> = typeof LinkPageInputSchema,
+  TItemInput extends z.ZodObject<any> = typeof LinkPageItemInputSchema,
+> {
+  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. */
+  itemInputSchema?: TItemInput;
+  /** Invoked after `queries.createLinkPage` / `updateLinkPage` resolves. Not tx-atomic. */
+  afterPageWrite?: (pageId: number, input: z.infer<TPageInput>) => Promise<void>;
+  /** Invoked after `queries.addLinkPageItem` / `updateLinkPageItem` resolves. Not tx-atomic. */
+  afterItemWrite?: (itemId: number, input: z.infer<TItemInput>) => Promise<void>;
 }
 
 function json(body: unknown, init?: ResponseInit): Response {
@@ -41,15 +61,6 @@ function json(body: unknown, init?: ResponseInit): Response {
   });
 }
 
-interface LinkPageBody {
-  title?: string;
-  slug?: string;
-  description?: string | null;
-  releaseId?: number | null;
-  coverImageUrl?: string | null;
-  isPublished?: boolean;
-}
-
 function validateSlug(slug: string): { ok: true } | { ok: false; res: Response } {
   if (!SLUG_PATTERN.test(slug)) {
     return { ok: false, res: json({ error: INVALID_SLUG_MESSAGE }, { status: 400 }) };
@@ -63,21 +74,30 @@ function validateSlug(slug: string): { ok: true } | { ok: false; res: Response }
 /**
  * `app/api/admin/link-pages/route.ts` handlers — list + create.
  */
-export function createAdminLinkPagesHandlers(deps: LinkPagesAdminDeps): {
+export function createAdminLinkPagesHandlers<
+  T extends QueryTables = DefaultTables,
+  TPageInput extends z.ZodObject<any> = typeof LinkPageInputSchema,
+  TItemInput extends z.ZodObject<any> = typeof LinkPageItemInputSchema,
+>(deps: LinkPagesAdminDeps<T, TPageInput, TItemInput>): {
   GET: RouteHandler<Record<string, never>>;
   POST: RouteHandler<Record<string, never>>;
 } {
+  const pageInputSchema = (deps.pageInputSchema ??
+    LinkPageInputSchema) as TPageInput;
   return {
-    GET: async (_req) => {
-const pages = await deps.queries.listAllLinkPages();
+    GET: async () => {
+      const pages = await deps.queries.listAllLinkPages();
       return json(pages);
     },
 
     POST: async (req) => {
-const body = (await req.json()) as LinkPageBody;
-      const title = body.title?.trim();
-      const slug = body.slug?.trim().toLowerCase();
+      const body = await safeJson(req);
+      const parsed = pageInputSchema.safeParse(body);
+      if (!parsed.success) return json({ error: "Validation failed" }, { status: 400 });
 
+      const data = parsed.data as LinkPageInput;
+      const title = data.title?.trim();
+      const slug = data.slug?.trim().toLowerCase();
       if (!title) return json({ error: "Title is required" }, { status: 400 });
       if (!slug) return json({ error: INVALID_SLUG_MESSAGE }, { status: 400 });
       const slugCheck = validateSlug(slug);
@@ -87,11 +107,17 @@ const body = (await req.json()) as LinkPageBody;
         const page = await deps.queries.createLinkPage({
           title,
           slug,
-          description: body.description ?? null,
-          releaseId: body.releaseId ?? null,
-          coverImageUrl: body.coverImageUrl ?? null,
-          isPublished: body.isPublished ?? true,
+          description: data.description ?? null,
+          releaseId: data.releaseId ?? null,
+          coverImageUrl: data.coverImageUrl ?? null,
+          isPublished: data.isPublished ?? true,
         });
+        if (deps.afterPageWrite) {
+          await deps.afterPageWrite(
+            (page as { id: number }).id,
+            parsed.data as z.infer<TPageInput>,
+          );
+        }
         revalidateTag(LINK_PAGES_TAG, "max");
         return json(page, { status: 201 });
       } catch (err) {
@@ -107,14 +133,22 @@ const body = (await req.json()) as LinkPageBody;
 /**
  * `app/api/admin/link-pages/[id]/route.ts` handlers — single-page CRUD.
  */
-export function createAdminLinkPageByIdHandlers(deps: LinkPagesAdminDeps): {
+export function createAdminLinkPageByIdHandlers<
+  T extends QueryTables = DefaultTables,
+  TPageInput extends z.ZodObject<any> = typeof LinkPageInputSchema,
+  TItemInput extends z.ZodObject<any> = typeof LinkPageItemInputSchema,
+>(deps: LinkPagesAdminDeps<T, TPageInput, TItemInput>): {
   GET: RouteHandler<{ id: string }>;
   PUT: RouteHandler<{ id: string }>;
   DELETE: RouteHandler<{ id: string }>;
 } {
+  const pageInputSchema = (deps.pageInputSchema ??
+    LinkPageInputSchema) as TPageInput;
+  // Updates accept partials — make every field optional.
+  const partialPageSchema = pageInputSchema.partial();
   return {
-    GET: async (req, { params }) => {
-const { id: idParam } = await params;
+    GET: async (_req, { params }) => {
+      const { id: idParam } = await params;
       const id = Number(idParam);
       if (!Number.isFinite(id)) return json({ error: "Not found" }, { status: 404 });
       const page = await deps.queries.getLinkPageById(id);
@@ -123,31 +157,36 @@ const { id: idParam } = await params;
     },
 
     PUT: async (req, { params }) => {
-const { id: idParam } = await params;
+      const { id: idParam } = await params;
       const id = Number(idParam);
       if (!Number.isFinite(id)) return json({ error: "Not found" }, { status: 404 });
-      const body = (await req.json()) as LinkPageBody;
+      const body = await safeJson(req);
+      const parsed = partialPageSchema.safeParse(body);
+      if (!parsed.success) return json({ error: "Validation failed" }, { status: 400 });
+      const data = parsed.data as Partial<LinkPageInput>;
 
-      const update: LinkPageBody = {};
-      if (body.title !== undefined) {
-        const title = body.title.trim();
+      const update: Partial<LinkPageInput> = {};
+      if (data.title !== undefined) {
+        const title = data.title.trim();
         if (!title) return json({ error: "Title is required" }, { status: 400 });
         update.title = title;
       }
-      if (body.slug !== undefined) {
-        const slug = body.slug.trim().toLowerCase();
+      if (data.slug !== undefined) {
+        const slug = data.slug.trim().toLowerCase();
         const slugCheck = validateSlug(slug);
         if (!slugCheck.ok) return slugCheck.res;
         update.slug = slug;
       }
-      if (body.description !== undefined) update.description = body.description;
-      if (body.releaseId !== undefined) update.releaseId = body.releaseId;
-      if (body.coverImageUrl !== undefined)
-        update.coverImageUrl = body.coverImageUrl;
-      if (body.isPublished !== undefined) update.isPublished = body.isPublished;
+      if (data.description !== undefined) update.description = data.description;
+      if (data.releaseId !== undefined) update.releaseId = data.releaseId;
+      if (data.coverImageUrl !== undefined) update.coverImageUrl = data.coverImageUrl;
+      if (data.isPublished !== undefined) update.isPublished = data.isPublished;
 
       try {
         const page = await deps.queries.updateLinkPage(id, update);
+        if (deps.afterPageWrite) {
+          await deps.afterPageWrite(id, parsed.data as z.infer<TPageInput>);
+        }
         revalidateTag(LINK_PAGES_TAG, "max");
         return json(page);
       } catch (err) {
@@ -158,8 +197,8 @@ const { id: idParam } = await params;
       }
     },
 
-    DELETE: async (req, { params }) => {
-const { id: idParam } = await params;
+    DELETE: async (_req, { params }) => {
+      const { id: idParam } = await params;
       const id = Number(idParam);
       if (!Number.isFinite(id)) return json({ error: "Not found" }, { status: 404 });
       await deps.queries.deleteLinkPage(id);
@@ -184,34 +223,52 @@ interface LinkPageItemBody {
  * PUT updates a single item by `itemId` in the JSON body.
  * DELETE removes an item by `itemId` in the query string.
  */
-export function createAdminLinkPageItemsHandlers(
-  deps: LinkPagesAdminDeps,
-): {
+export function createAdminLinkPageItemsHandlers<
+  T extends QueryTables = DefaultTables,
+  TPageInput extends z.ZodObject<any> = typeof LinkPageInputSchema,
+  TItemInput extends z.ZodObject<any> = typeof LinkPageItemInputSchema,
+>(deps: LinkPagesAdminDeps<T, TPageInput, TItemInput>): {
   POST: RouteHandler<{ id: string }>;
   PUT: RouteHandler<{ id: string }>;
   DELETE: RouteHandler<{ id: string }>;
 } {
+  const itemInputSchema = (deps.itemInputSchema ??
+    LinkPageItemInputSchema) as TItemInput;
+  const partialItemSchema = itemInputSchema.partial();
   return {
     POST: async (req, { params }) => {
-const { id: pageIdParam } = await params;
+      const { id: pageIdParam } = await params;
       const pageId = Number(pageIdParam);
       if (!Number.isFinite(pageId)) {
         return json({ error: "Not found" }, { status: 404 });
       }
-      const { title, url } = (await req.json()) as { title?: string; url?: string };
-      if (!title?.trim() || !url?.trim()) {
+      const body = await safeJson(req);
+      const parsed = itemInputSchema.safeParse(body);
+      if (!parsed.success) {
+        return json({ error: "Title and URL are required" }, { status: 400 });
+      }
+      const data = parsed.data as LinkPageItemInput;
+      if (!data.title?.trim() || !data.url?.trim()) {
         return json({ error: "Title and URL are required" }, { status: 400 });
       }
       const item = await deps.queries.addLinkPageItem(pageId, {
-        title: title.trim(),
-        url: url.trim(),
+        title: data.title.trim(),
+        url: data.url.trim(),
+        position: data.position,
+        isVisible: data.isVisible,
       });
+      if (deps.afterItemWrite) {
+        await deps.afterItemWrite(
+          (item as { id: number }).id,
+          parsed.data as z.infer<TItemInput>,
+        );
+      }
       revalidateTag(LINK_PAGES_TAG, "max");
       return json(item, { status: 201 });
     },
 
     PUT: async (req) => {
-const body = (await req.json()) as LinkPageItemBody;
+      const body = (await safeJson(req)) as LinkPageItemBody;
       if (body.itemId == null) {
         return json({ error: "itemId is required" }, { status: 400 });
       }
@@ -219,18 +276,20 @@ const body = (await req.json()) as LinkPageItemBody;
       if (!Number.isFinite(itemId)) {
         return json({ error: "itemId is required" }, { status: 400 });
       }
-      const item = await deps.queries.updateLinkPageItem(itemId, {
-        title: body.title,
-        url: body.url,
-        position: body.position,
-        isVisible: body.isVisible,
-      });
+      // Validate the remaining body against the partial-item schema.
+      const { itemId: _itemId, ...rest } = body;
+      const parsed = partialItemSchema.safeParse(rest);
+      if (!parsed.success) return json({ error: "Validation failed" }, { status: 400 });
+      const item = await deps.queries.updateLinkPageItem(itemId, parsed.data);
+      if (deps.afterItemWrite) {
+        await deps.afterItemWrite(itemId, parsed.data as z.infer<TItemInput>);
+      }
       revalidateTag(LINK_PAGES_TAG, "max");
       return json(item);
     },
 
     DELETE: async (req) => {
-const { searchParams } = new URL(req.url);
+      const { searchParams } = new URL(req.url);
       const itemIdRaw = searchParams.get("itemId");
       if (!itemIdRaw) {
         return json({ error: "itemId is required" }, { status: 400 });
@@ -245,3 +304,11 @@ const { searchParams } = new URL(req.url);
     },
   };
 }
+
+async function safeJson(req: Request): Promise<unknown> {
+  try {
+    return await req.json();
+  } catch {
+    return {};
+  }
+}

package/src/index.ts

@@ -1,20 +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 {
   LinkPage,
   LinkPageItem,
   LinkPageReleaseRef,
   LinkPageWithItems,
-  LinkPageQueries,
   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,170 +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, linkPages } from "../schema/index";
-import type {
-  LinkPage,
-  LinkPageInput,
-  LinkPageItem,
-  LinkPageItemInput,
-  LinkPageQueries,
-  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`.
- *
- * 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 {
-  return {
-    listPublishedLinkPages: async (): Promise<LinkPage[]> => {
-      const rows = await db.query.linkPages.findMany({
-        where: eq(linkPages.isPublished, true),
-        orderBy: desc(linkPages.updatedAt),
-      });
-      return rows;
-    },
-
-    listAllLinkPages: async (): Promise<LinkPage[]> => {
-      const rows = await db.query.linkPages.findMany({
-        orderBy: desc(linkPages.updatedAt),
-      });
-      return rows;
-    },
-
-    getPublicLinkPageBySlug: async (slug: string): Promise<LinkPageWithItems | 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 | null;
-    },
-
-    getLinkPageById: async (id: number): Promise<LinkPageWithItems | 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 | null;
-    },
-
-    createLinkPage: async (input: LinkPageInput): Promise<LinkPage> => {
-      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!;
-    },
-
-    updateLinkPage: async (id: number, input: Partial<LinkPageInput>): Promise<LinkPage> => {
-      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!;
-    },
-
-    deleteLinkPage: async (id: number): Promise<void> => {
-      await db.delete(linkPages).where(eq(linkPages.id, id));
-    },
-
-    addLinkPageItem: async (pageId: number, input: LinkPageItemInput): Promise<LinkPageItem> => {
-      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!;
-    },
-
-    updateLinkPageItem: async (
-      id: number,
-      input: Partial<LinkPageItemInput>,
-    ): Promise<LinkPageItem> => {
-      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!;
-    },
-
-    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)));
-        }
-      });
-    },
-  };
-}

package/src/schema/index.ts

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

package/src/schema/link-pages.ts

@@ -1,41 +0,0 @@
-import { boolean, index, integer, pgTable, serial, text, timestamp } from "drizzle-orm/pg-core";
-import { releases } from "@gigamusic/db/schema";
-
-export const linkPageColumns = {
-  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()),
-} as const;
-
-export const linkPages = pgTable("link_pages", linkPageColumns, (t) => [
-  index("link_pages_releaseId_idx").on(t.releaseId),
-]);
-
-export const linkPageItemColumns = {
-  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()),
-} as const;
-
-export const linkPageItems = pgTable("link_page_items", linkPageItemColumns, (t) => [
-  index("link_page_items_pageId_idx").on(t.pageId),
-]);

package/src/schema/relations.ts

@@ -1,12 +0,0 @@
-import { relations } from "drizzle-orm";
-import { releases } from "@gigamusic/db/schema";
-import { linkPages, linkPageItems } from "./link-pages";
-
-export const linkPagesRelations = relations(linkPages, ({ one, many }) => ({
-  release: one(releases, { fields: [linkPages.releaseId], references: [releases.id] }),
-  items: many(linkPageItems),
-}));
-
-export const linkPageItemsRelations = relations(linkPageItems, ({ one }) => ({
-  page: one(linkPages, { fields: [linkPageItems.pageId], references: [linkPages.id] }),
-}));

package/src/types.ts

@@ -1,47 +0,0 @@
-import type { LinkPageInput, LinkPageItemInput } from "@gigamusic/core";
-import type { linkPageItems, linkPages } from "./schema/index";
-
-export type { LinkPageInput, LinkPageItemInput };
-
-/** A single link button rendered inside a `LinkPage`. */
-export type LinkPageItem = typeof 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 = typeof linkPages.$inferSelect;
-
-/** A `LinkPage` joined with its visible (or all) items and an optional release ref. */
-export interface LinkPageWithItems extends LinkPage {
-  items: LinkPageItem[];
-  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 {
-  listPublishedLinkPages(): Promise<LinkPage[]>;
-  listAllLinkPages(): Promise<LinkPage[]>;
-  getPublicLinkPageBySlug(slug: string): Promise<LinkPageWithItems | null>;
-  getLinkPageById(id: number): Promise<LinkPageWithItems | null>;
-  createLinkPage(input: LinkPageInput): Promise<LinkPage>;
-  updateLinkPage(id: number, input: Partial<LinkPageInput>): Promise<LinkPage>;
-  deleteLinkPage(id: number): Promise<void>;
-  addLinkPageItem(pageId: number, input: LinkPageItemInput): Promise<LinkPageItem>;
-  updateLinkPageItem(
-    id: number,
-    input: Partial<LinkPageItemInput>,
-  ): Promise<LinkPageItem>;
-  deleteLinkPageItem(id: number): Promise<void>;
-  reorderLinkPageItems(pageId: number, orderedItemIds: number[]): Promise<void>;
-}