@gigamusic/links 0.1.0

package/src/queries/link-pages.ts

@@ -0,0 +1,175 @@
+import type { PrismaClient } from "@prisma/client";
+import type {
+  LinkPage,
+  LinkPageInput,
+  LinkPageItem,
+  LinkPageItemInput,
+  LinkPageQueries,
+  LinkPageWithItems,
+} from "../types";
+
+/**
+ * Factory that binds a `PrismaClient` 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.
+ */
+export function createLinkPageQueries(db: PrismaClient): LinkPageQueries {
+  return {
+    listPublishedLinkPages: async (): Promise<LinkPage[]> => {
+      const rows = await db.linkPage.findMany({
+        where: { isPublished: true },
+        orderBy: { updatedAt: "desc" },
+      });
+      return rows as unknown as LinkPage[];
+    },
+
+    listAllLinkPages: async (): Promise<LinkPage[]> => {
+      const rows = await db.linkPage.findMany({
+        orderBy: { updatedAt: "desc" },
+      });
+      return rows as unknown as LinkPage[];
+    },
+
+    getPublicLinkPageBySlug: async (
+      slug: string,
+    ): Promise<LinkPageWithItems | null> => {
+      const row = await db.linkPage.findFirst({
+        where: { slug, isPublished: true },
+        include: {
+          release: {
+            select: {
+              id: true,
+              name: true,
+              slug: true,
+              coverImageUrl: true,
+              isPublished: true,
+            },
+          },
+          items: {
+            where: { isVisible: true },
+            orderBy: { position: "asc" },
+          },
+        },
+      });
+      return row as unknown as LinkPageWithItems | null;
+    },
+
+    getLinkPageById: async (id: number): Promise<LinkPageWithItems | null> => {
+      const row = await db.linkPage.findUnique({
+        where: { id },
+        include: {
+          release: {
+            select: {
+              id: true,
+              name: true,
+              slug: true,
+              coverImageUrl: true,
+              isPublished: true,
+            },
+          },
+          items: { orderBy: { position: "asc" } },
+        },
+      });
+      return row as unknown as LinkPageWithItems | null;
+    },
+
+    createLinkPage: async (input: LinkPageInput): Promise<LinkPage> => {
+      const row = await db.linkPage.create({
+        data: {
+          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;
+    },
+
+    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.linkPage.update({
+        where: { id },
+        data,
+      });
+      return row as unknown as LinkPage;
+    },
+
+    deleteLinkPage: async (id: number): Promise<void> => {
+      await db.linkPage.delete({ where: { 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: {
+          pageId,
+          title: input.title,
+          url: input.url,
+          position: input.position ?? (max._max.position ?? -1) + 1,
+          isVisible: input.isVisible ?? true,
+        },
+      });
+      return row as unknown as LinkPageItem;
+    },
+
+    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.linkPageItem.update({
+        where: { id },
+        data,
+      });
+      return row as unknown as LinkPageItem;
+    },
+
+    deleteLinkPageItem: async (id: number): Promise<void> => {
+      await db.linkPageItem.delete({ where: { 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(
+        orderedItemIds.map((itemId, position) =>
+          db.linkPageItem.update({
+            where: { id: itemId, pageId },
+            data: { position },
+          }),
+        ),
+      );
+    },
+  };
+}

package/src/server.ts

@@ -0,0 +1,22 @@
+// 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`.
+
+export { createLinkPageQueries } from "./queries/link-pages";
+export {
+  createAdminLinkPagesHandlers,
+  createAdminLinkPageByIdHandlers,
+  createAdminLinkPageItemsHandlers,
+  LINK_PAGES_TAG,
+} from "./api/handlers";
+export type {
+  LinkPagesAdminDeps,
+  RouteHandler,
+} from "./api/handlers";
+export {
+  PublicLinkPage,
+  createPublicLinkPage,
+  createPublicLinkPageMetadata,
+  publicLinkPageMetadata,
+  registerLinkPageMetadata,
+} from "./pages/PublicLinkPage";

package/src/slots-context.tsx

@@ -0,0 +1,46 @@
+"use client";
+
+import { createContext, useContext, useMemo, type ReactNode } from "react";
+import type { LinksSlots } from "./slots";
+import { DefaultLinkButton } from "./components/LinkButton";
+import { DefaultLinkPageHeader } from "./components/LinkPageHeader";
+
+const DEFAULT_LINK_SLOTS: LinksSlots = {
+  LinkButton: DefaultLinkButton,
+  LinkPageHeader: DefaultLinkPageHeader,
+};
+
+const LinksSlotsContext = createContext<LinksSlots>(DEFAULT_LINK_SLOTS);
+
+/**
+ * Optional provider that registers overrides for the `LinksSlots` map.
+ * Wrap a subtree (or the whole app) when you want every `LinkPageView` to
+ * use your custom `LinkButton` / `LinkPageHeader` without passing the
+ * `slots` prop at each call site.
+ */
+export function LinksSlotsProvider({
+  components,
+  children,
+}: {
+  components?: Partial<LinksSlots>;
+  children: ReactNode;
+}) {
+  const parent = useContext(LinksSlotsContext);
+  const merged = useMemo<LinksSlots>(
+    () => (components ? { ...parent, ...components } : parent),
+    [parent, components],
+  );
+  return (
+    <LinksSlotsContext.Provider value={merged}>
+      {children}
+    </LinksSlotsContext.Provider>
+  );
+}
+
+/** Resolve a `LinksSlots` entry from the nearest `LinksSlotsProvider`, falling back to the package default. */
+export function useLinksSlot<K extends keyof LinksSlots>(key: K): LinksSlots[K] {
+  const slots = useContext(LinksSlotsContext);
+  return slots[key];
+}
+
+export { DEFAULT_LINK_SLOTS as defaultLinkSlots };

package/src/slots.ts

@@ -0,0 +1,36 @@
+import type { ComponentType, ReactNode } from "react";
+import type { KnownLinkPlatform } from "./platforms/detect";
+
+/**
+ * Props passed to the `LinkButton` slot. Consumers can swap this to use their
+ * own button styling without forking `LinkPageView`.
+ */
+export interface LinkButtonProps {
+  href: string;
+  title: string;
+  /** Detected platform, if any — used to render an inline icon. */
+  platform: KnownLinkPlatform | null;
+  /** True when the URL is same-origin; the default implementation skips `target="_blank"`. */
+  internal: boolean;
+}
+
+/** Props passed to the `LinkPageHeader` slot — the title block above the social row. */
+export interface LinkPageHeaderProps {
+  title: string;
+  description: string | null;
+  /** Cover image url to render (already resolved per the override → release chain). */
+  cover: { src: string; alt: string } | null;
+}
+
+/**
+ * Slots specific to `@gigamusic/links`. They live alongside the slots from
+ * `@gigamusic/ui`; callers register them on the same `GigamusicProvider`.
+ * Adding new entries is a minor-version bump; renaming or changing props of an
+ * existing entry is a breaking change.
+ */
+export interface LinksSlots {
+  LinkButton: ComponentType<LinkButtonProps>;
+  LinkPageHeader: ComponentType<LinkPageHeaderProps>;
+}
+
+export type LinksSlotChildren = { children?: ReactNode };

package/src/types.ts

@@ -0,0 +1,65 @@
+import type { LinkPageInput, LinkPageItemInput } from "@gigamusic/core";
+
+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;
+}
+
+/** 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. 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;
+}
+
+/** 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 `PrismaClient`. 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>;
+}