nitropage/src/features/admin/data/page.ts

A free and open source, extensible visual page builder based on SolidStart.

import { getUser } from "#lib/auth/server";
import {
  assertCreatePageAllowed as assertCreatePageAllowed_,
  createPage as createPage_,
  deletePage as deletePage_,
  duplicatePage as duplicatePage_,
  getPage as getPage_,
  publishPage as publishPage_,
  updatePage as updatePage_,
} from "#lib/server/page";
import { useDatabase } from "#lib/server/prisma";
import {
  action,
  createAsync,
  query,
  redirect,
  useParams,
} from "@solidjs/router";
import { Accessor } from "solid-js";

export const createPage = action(
  async (params: Parameters<typeof createPage_>[0]) => {
    "use server";
    await getUser({ assert: { csrf: true } });
    await assertCreatePageAllowed_();
    await createPage_(params);
  },
);

export const updatePage = action(
  async (csrf = "", params: Parameters<typeof updatePage_>[0]) => {
    "use server";
    await getUser({ assert: { csrf } });
    return await updatePage_(params);
  },
);

export const getPages = query(
  async ({ projectId, layouts }: { projectId: string; layouts?: boolean }) => {
    "use server";
    await getUser({ assert: {} });

    const db = useDatabase();
    return await db.nitroPage.findMany({
      include: {
        revisions: {
          orderBy: { savedAt: "desc" },
          take: 1,
        },
        publishedRevision: true,
      },
      where: {
        projectId,
        type: {
          equals: layouts ? "layout" : null,
        },
      },
      orderBy: {
        publishedRevision: {
          urlPath: "asc",
        },
      },
    });
  },
  "np-pages",
);

export const getPage = query(async ({ id }: { id: string }) => {
  "use server";
  await getUser({ assert: {} });
  const page = await getPage_(id);

  if (!page) {
    throw redirect("/admin");
  }

  return page;
}, "np-page");

export const useRouterPage = (opts = { deferStream: true }) => {
  const params = useParams();
  return createAsync(
    async () => (params.page ? await getPage({ id: params.page }) : undefined),
    opts,
  );
};

export const useRouterProjectPages = (
  { layouts: layouts }: { layouts?: Accessor<boolean> } = {},
  opts = { deferStream: true },
) => {
  const params = useParams();
  return createAsync(
    () => getPages({ projectId: params.project, layouts: layouts?.() }),
    opts,
  );
};

export const deletePage = action(async (csrf = "", params: { id: string }) => {
  "use server";
  await getUser({ assert: { csrf } });
  await deletePage_(params.id);
}, "np-deletePage");

export const duplicatePage = action(
  async (csrf = "", params: { id: string }) => {
    "use server";
    await getUser({ assert: { csrf } });
    await assertCreatePageAllowed_();
    await duplicatePage_(params);
  },
  "np-duplicatePage",
);

export const publishPage = action(
  async (...args: Parameters<typeof publishPage_>) => {
    "use server";
    await getUser({ assert: { csrf: true } });
    await publishPage_(...args);
  },
  "np-publishPage",
);