@gigamusic/links 1.0.0 → 2.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @gigamusic/links
 
-Linktree-style per-release link pages for the gigamusic platform. Ships its own Prisma fragment (`LinkPage`, `LinkPageItem`), 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 a Drizzle schema (`linkPages`, `linkPageItems`), a typed queries factory, admin API handler factories, platform-detection helpers, and a small SVG `LinkPlatformIcon` component.
 
 ```ts
 import {
@@ -19,18 +19,48 @@ import {
 } from "@gigamusic/links/server";
 ```
 
-The public link-page UI is the consumer's responsibility — fetch with `createLinkPageQueries(prisma).getPublicLinkPageBySlug(slug)` and render whatever you want.
+The public link-page UI is the consumer's responsibility — fetch with `createLinkPageQueries(db).getPublicLinkPageBySlug(slug)` and render whatever you want.
 
-## Prisma fragment
+## Schema subpath
 
-The `link-page.prisma` fragment ships under `node_modules/@gigamusic/links/prisma/`. Copy it into your `prisma/schema/` directory (Prisma 6 `prismaSchemaFolder` mode) once per upgrade.
+`@gigamusic/links/schema` exports the table objects and relations:
 
-The fragment references the `Release` model owned by `@gigamusic/db`. Prisma requires both sides of a relation to be declared, so consumers must add the inverse on their copy of `Release`:
+```ts
+import {
+  linkPages,
+  linkPageItems,
+  linkPagesRelations,
+  linkPageItemsRelations,
+  linkPageColumns,
+  linkPageItemColumns,
+} from "@gigamusic/links/schema";
+```
+
+Merge with `@gigamusic/db/schema` when constructing your Drizzle instance:
 
-```prisma
-// prisma/schema/99-app.prisma (or wherever your Release lives)
-model Release {
-  // ...existing fields...
-  linkPages LinkPage[]
-}
+```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 });
 ```
+
+## 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`:
+
+```ts
+import { relations } from "drizzle-orm";
+import { releases } from "@gigamusic/db/schema";
+import { linkPages } from "@gigamusic/links/schema";
+
+export const releasesRelations = relations(releases, ({ many }) => ({
+  // ...keep the existing many() relations from @gigamusic/db/schema if you need them...
+  linkPages: many(linkPages),
+}));
+```
+
+Because relations are TS modules, you compose them once and never re-apply patches on package upgrades.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gigamusic/links",
-  "version": "1.0.0",
-  "description": "Editable Linktree-style link pages for gigamusic artist sites. Ships a Prisma fragment, admin API handler factories, and platform-detection helpers.",
+  "version": "2.0.0",
+  "description": "Editable Linktree-style link pages for gigamusic artist sites. Ships a Drizzle schema, admin API handler factories, and platform-detection helpers.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,11 +17,14 @@
     "./server": {
       "types": "./src/server.ts",
       "default": "./src/server.ts"
+    },
+    "./schema": {
+      "types": "./src/schema/index.ts",
+      "default": "./src/schema/index.ts"
     }
   },
   "files": [
     "src",
-    "prisma",
     "README.md"
   ],
   "publishConfig": {
@@ -29,29 +32,30 @@
   },
   "dependencies": {
     "@gigamusic/core": "1.0.0",
-    "@gigamusic/db": "1.0.0"
+    "@gigamusic/db": "2.0.0"
   },
   "peerDependencies": {
-    "@prisma/client": ">=6",
+    "drizzle-orm": ">=0.45",
     "next": ">=15",
     "react": ">=18 <20",
     "react-dom": ">=18 <20"
   },
   "devDependencies": {
-    "@prisma/client": "^6.1.0",
     "@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",
-    "prisma": "^6.1.0",
+    "pg": "^8.21.0",
     "react": "^19.0.0",
     "typescript": "^5.7.3",
     "vitest": "^2.1.8"
   },
   "scripts": {
     "lint": "eslint src",
-    "test": "pnpm run prisma:generate && vitest run",
-    "typecheck": "pnpm run prisma:generate && tsc --noEmit",
-    "prisma:generate": "prisma generate --schema=./prisma",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
     "clean": "rm -rf .turbo *.tsbuildinfo"
   }
 }

package/src/index.ts

@@ -14,6 +14,7 @@ export type {
 
 // ── Queries factory ─────────────────────────────────────────────────────
 export { createLinkPageQueries } from "./queries/link-pages";
+export type { LinkPagesDb } from "./queries/link-pages";
 
 // ── Platform detection ──────────────────────────────────────────────────
 export { detectLinkPlatform, PLATFORM_LABELS } from "./platforms/detect";

package/src/queries/link-pages.ts

@@ -1,4 +1,8 @@
-import type { PrismaClient } from "@prisma/client";
+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.js";
+import { linkPageItems, linkPages } from "../schema/index.js";
 import type {
   LinkPage,
   LinkPageInput,
@@ -8,38 +12,42 @@ import type {
   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 `PrismaClient` into the `LinkPageQueries` contract.
+ * Factory that binds a Drizzle database into the `LinkPageQueries` contract.
  * Consumers typically merge the result with `@gigamusic/db`'s `createQueries`.
  *
- * Both inputs and outputs use numeric IDs, matching the underlying
- * `Int @id @default(autoincrement())` schema fragments.
+ * 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: PrismaClient): LinkPageQueries {
+export function createLinkPageQueries(db: LinkPagesDb): LinkPageQueries {
   return {
     listPublishedLinkPages: async (): Promise<LinkPage[]> => {
-      const rows = await db.linkPage.findMany({
-        where: { isPublished: true },
-        orderBy: { updatedAt: "desc" },
+      const rows = await db.query.linkPages.findMany({
+        where: eq(linkPages.isPublished, true),
+        orderBy: desc(linkPages.updatedAt),
       });
-      return rows as unknown as LinkPage[];
+      return rows;
     },
 
     listAllLinkPages: async (): Promise<LinkPage[]> => {
-      const rows = await db.linkPage.findMany({
-        orderBy: { updatedAt: "desc" },
+      const rows = await db.query.linkPages.findMany({
+        orderBy: desc(linkPages.updatedAt),
       });
-      return rows as unknown as LinkPage[];
+      return rows;
     },
 
-    getPublicLinkPageBySlug: async (
-      slug: string,
-    ): Promise<LinkPageWithItems | null> => {
-      const row = await db.linkPage.findFirst({
-        where: { slug, isPublished: true },
-        include: {
+    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: {
-            select: {
+            columns: {
               id: true,
               name: true,
               slug: true,
@@ -48,20 +56,20 @@ export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
             },
           },
           items: {
-            where: { isVisible: true },
-            orderBy: { position: "asc" },
+            where: eq(linkPageItems.isVisible, true),
+            orderBy: asc(linkPageItems.position),
           },
         },
       });
-      return row as unknown as LinkPageWithItems | null;
+      return (row ?? null) as unknown as LinkPageWithItems | null;
     },
 
     getLinkPageById: async (id: number): Promise<LinkPageWithItems | null> => {
-      const row = await db.linkPage.findUnique({
-        where: { id },
-        include: {
+      const row = await db.query.linkPages.findFirst({
+        where: eq(linkPages.id, id),
+        with: {
           release: {
-            select: {
+            columns: {
               id: true,
               name: true,
               slug: true,
@@ -69,67 +77,60 @@ export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
               isPublished: true,
             },
           },
-          items: { orderBy: { position: "asc" } },
+          items: { orderBy: asc(linkPageItems.position) },
         },
       });
-      return row as unknown as LinkPageWithItems | null;
+      return (row ?? null) as unknown as LinkPageWithItems | null;
     },
 
     createLinkPage: async (input: LinkPageInput): Promise<LinkPage> => {
-      const row = await db.linkPage.create({
-        data: {
+      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,
-        },
-      });
-      return row as unknown as LinkPage;
+        })
+        .returning();
+      return row!;
     },
 
-    updateLinkPage: async (
-      id: number,
-      input: Partial<LinkPageInput>,
-    ): Promise<LinkPage> => {
+    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.coverImageUrl !== undefined) data.coverImageUrl = input.coverImageUrl;
       if (input.isPublished !== undefined) data.isPublished = input.isPublished;
-      const row = await db.linkPage.update({
-        where: { id },
-        data,
-      });
-      return row as unknown as LinkPage;
+      const [row] = await db.update(linkPages).set(data).where(eq(linkPages.id, id)).returning();
+      return row!;
     },
 
     deleteLinkPage: async (id: number): Promise<void> => {
-      await db.linkPage.delete({ where: { id } });
+      await db.delete(linkPages).where(eq(linkPages.id, id));
     },
 
-    addLinkPageItem: async (
-      pageId: number,
-      input: LinkPageItemInput,
-    ): Promise<LinkPageItem> => {
-      const max = await db.linkPageItem.aggregate({
-        where: { pageId },
-        _max: { position: true },
-      });
-      const row = await db.linkPageItem.create({
-        data: {
+    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: input.position ?? (max._max.position ?? -1) + 1,
+          position: nextPosition,
           isVisible: input.isVisible ?? true,
-        },
-      });
-      return row as unknown as LinkPageItem;
+        })
+        .returning();
+      return row!;
     },
 
     updateLinkPageItem: async (
@@ -141,15 +142,12 @@ export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
       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.linkPageItem.update({
-        where: { id },
-        data,
-      });
-      return row as unknown as LinkPageItem;
+      const [row] = await db.update(linkPageItems).set(data).where(eq(linkPageItems.id, id)).returning();
+      return row!;
     },
 
     deleteLinkPageItem: async (id: number): Promise<void> => {
-      await db.linkPageItem.delete({ where: { id } });
+      await db.delete(linkPageItems).where(eq(linkPageItems.id, id));
     },
 
     /**
@@ -158,18 +156,15 @@ export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
      * their current position — callers must include the full set to fully
      * resort.
      */
-    reorderLinkPageItems: async (
-      pageId: number,
-      orderedItemIds: number[],
-    ): Promise<void> => {
-      await db.$transaction(
-        orderedItemIds.map((itemId, position) =>
-          db.linkPageItem.update({
-            where: { id: itemId, pageId },
-            data: { position },
-          }),
-        ),
-      );
+    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

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

package/src/schema/link-pages.ts

@@ -0,0 +1,41 @@
+import { boolean, index, integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { releases } from "@gigamusic/db/schema";
+
+export const linkPageColumns = {
+  id: integer().primaryKey().generatedAlwaysAsIdentity(),
+  slug: text("slug").notNull().unique(),
+  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: integer().primaryKey().generatedAlwaysAsIdentity(),
+  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

@@ -0,0 +1,12 @@
+import { relations } from "drizzle-orm";
+import { releases } from "@gigamusic/db/schema";
+import { linkPages, linkPageItems } from "./link-pages.js";
+
+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/server.ts

@@ -3,6 +3,7 @@
 // because the handlers depend on `next/cache`.
 
 export { createLinkPageQueries } from "./queries/link-pages";
+export type { LinkPagesDb } from "./queries/link-pages";
 export {
   createAdminLinkPagesHandlers,
   createAdminLinkPageByIdHandlers,

package/src/types.ts

@@ -1,18 +1,10 @@
 import type { LinkPageInput, LinkPageItemInput } from "@gigamusic/core";
+import type { linkPageItems, linkPages } from "./schema/index.js";
 
 export type { LinkPageInput, LinkPageItemInput };
 
 /** A single link button rendered inside a `LinkPage`. */
-export interface LinkPageItem {
-  id: number;
-  pageId: number;
-  title: string;
-  url: string;
-  position: number;
-  isVisible: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-}
+export type LinkPageItem = typeof linkPageItems.$inferSelect;
 
 /** Optional `Release` reference exposed to the public view for cover fallback. */
 export interface LinkPageReleaseRef {
@@ -23,18 +15,8 @@ export interface LinkPageReleaseRef {
   isPublished: boolean;
 }
 
-/** Top-level "Linktree-style" page row. IDs are native `Int @id @default(autoincrement())`. */
-export interface LinkPage {
-  id: number;
-  slug: string;
-  title: string;
-  description: string | null;
-  coverImageUrl: string | null;
-  releaseId: number | null;
-  isPublished: boolean;
-  createdAt: Date;
-  updatedAt: Date;
-}
+/** 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 {
@@ -43,7 +25,7 @@ export interface LinkPageWithItems extends LinkPage {
 }
 
 /**
- * Query helpers that close over a `PrismaClient`. Consumers merge this with
+ * 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).
  */

package/prisma/_typegen.prisma

@@ -1,29 +0,0 @@
-// Internal — exists ONLY so `prisma generate --schema=./prisma` in THIS
-// package can produce a PrismaClient with LinkPage + LinkPageItem on the
-// delegate. The `gigamusic-links sync` CLI skips files starting with `_`,
-// so this is never copied into a consumer app. The consumer's merged
-// schema gets `Release` from `@gigamusic/db`; here we declare a minimal
-// stub so the link-page.prisma relation compiles in isolation.
-
-datasource db {
-  provider = "postgresql"
-  url      = env("DATABASE_URL")
-}
-
-generator client {
-  provider      = "prisma-client-js"
-  binaryTargets = ["native"]
-}
-
-/// Minimal stub of @gigamusic/db's `Release` model — only the fields this
-/// package's queries select. The consumer's merged schema redefines `Release`
-/// with all its fields; this stub only needs to satisfy the link-page relation
-/// and the columns we read.
-model Release {
-  id            Int        @id @default(autoincrement())
-  name          String
-  slug          String     @unique
-  coverImageUrl String?
-  isPublished   Boolean    @default(false)
-  linkPages     LinkPage[]
-}

package/prisma/link-page.prisma

@@ -1,54 +0,0 @@
-// gigamusic link-page schema fragment
-//
-// Shipped by `@gigamusic/links` and copied into a consumer app's
-// `prisma/schema/` directory by `gigamusic-links sync` with a `20-` prefix
-// (after `10-` fragments from @gigamusic/db, before consumer-owned `99-`).
-//
-// `LinkPage` references the `Release` model from @gigamusic/db via the
-// `releaseId` scalar foreign key. Prisma requires *both* sides of every
-// relation to be declared, so for the `release Release?` relation to compile
-// the consumer must extend the upstream `Release` model with:
-//
-//     model Release {
-//       // ...existing fields...
-//       linkPages LinkPage[]
-//     }
-//
-// The demo + create-gigamusic-app scaffolding wire this up automatically.
-//
-// Reserved model names: LinkPage, LinkPageItem
-// Reserved table names: link_pages, link_page_items
-
-model LinkPage {
-  id            Int      @id @default(autoincrement())
-  slug          String   @unique
-  title         String
-  description   String?
-  coverImageUrl String?
-  releaseId     Int?
-  isPublished   Boolean  @default(true)
-  createdAt     DateTime @default(now())
-  updatedAt     DateTime @updatedAt
-
-  release Release?       @relation(fields: [releaseId], references: [id], onDelete: SetNull)
-  items   LinkPageItem[]
-
-  @@index([releaseId])
-  @@map("link_pages")
-}
-
-model LinkPageItem {
-  id        Int      @id @default(autoincrement())
-  pageId    Int
-  title     String
-  url       String
-  position  Int      @default(0)
-  isVisible Boolean  @default(true)
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  page LinkPage @relation(fields: [pageId], references: [id], onDelete: Cascade)
-
-  @@index([pageId])
-  @@map("link_page_items")
-}