Merge pull request #577 from chaibuilder/576-better-organization-of-types-across-codebase

better organization of types across codebase

Author: surajair

frameworks/nextjs/app/(public)/[[...slug]]/page.tsx

@@ -27,7 +27,7 @@ export default async function Page({ params }: { params: Promise<{ slug: string[
   ChaiBuilder.init(process.env.CHAIBUILDER_APP_KEY!, isEnabled);
   let page = null;
   try {
-    page = await ChaiBuilder.getPageBySlug(slug);
+    page = await ChaiBuilder.getPage(slug);
     if ("error" in page) {
       return notFound();
     }
@@ -36,10 +36,11 @@ export default async function Page({ params }: { params: Promise<{ slug: string[
   }
 
   //NOTE: pageProps are received in your dataProvider functions for block and page
+  const siteSettings = await ChaiBuilder.getSiteSettings();
   const pageProps: ChaiPageProps = {
     slug,
     pageType: page.pageType,
-    fallbackLang: page.fallbackLang,
+    fallbackLang: siteSettings.fallbackLang,
     pageLang: page.lang,
   };
   return (

frameworks/nextjs/package.json

@@ -13,7 +13,7 @@
     "@supabase/ssr": "^0.8.0",
     "@supabase/supabase-js": "^2.90.1",
     "date-fns": "^4.1.0",
-    "drizzle-orm": "^0.45.1",
+    "drizzle-orm": "0.45.1",
     "lodash": "^4.17.21",
     "next": "^16.1.2",
     "react": "^19.2.3",

frameworks/nextjs/package/ChaiBuilder.ts

@@ -1,9 +1,10 @@
 import { applyChaiDataBinding } from "@chaibuilder/sdk/render";
-import { ChaiBlock, ChaiPageProps } from "@chaibuilder/sdk/runtime";
+import type { ChaiBlock, ChaiPage, ChaiPageProps, ChaiWebsiteSetting } from "@chaibuilder/sdk/types";
 import { unstable_cache } from "next/cache";
+import { notFound } from "next/navigation";
 import { cache } from "react";
-import type { ChaiBuilderPage } from "./lib";
 import * as utils from "./lib";
+import { ChaiFullPage, ChaiPartialPage } from "./types";
 
 class ChaiBuilder {
   private static appId?: string;
@@ -51,53 +52,71 @@ class ChaiBuilder {
     return ChaiBuilder.fallbackLang;
   }
 
-  static async getSiteSettings(): Promise<{ fallbackLang?: string; [key: string]: unknown }> {
+  static async getSiteSettings(): Promise<ChaiWebsiteSetting> {
     ChaiBuilder.verifyInit();
     return await unstable_cache(
       async () => await utils.getSiteSettings(ChaiBuilder.appId!, ChaiBuilder.draftMode),
       [`website-settings-${ChaiBuilder.getAppId()}`],
-      {
-        tags: [`website-settings`, `website-settings-${ChaiBuilder.getAppId()}`],
-      },
+      { tags: [`website-settings`, `website-settings-${ChaiBuilder.getAppId()}`] },
     )();
   }
 
-  static async getPageBySlug(slug: string): Promise<ChaiBuilderPage | { error: string }> {
+  static async getPageBySlug(slug: string): Promise<ChaiPartialPage> {
     ChaiBuilder.verifyInit();
-    return await utils.getPageBySlug(slug, this.appId!, this.draftMode);
+    try {
+      return await utils.getPageBySlug(slug, this.appId!, this.draftMode);
+    } catch (error) {
+      if (error instanceof Error && error.message === "PAGE_NOT_FOUND") {
+        throw notFound();
+      }
+      throw error;
+    }
   }
 
-  static async getFullPage(pageId: string): Promise<Record<string, unknown>> {
+  static async getFullPage(pageId: string): Promise<ChaiFullPage> {
     ChaiBuilder.verifyInit();
     return await utils.getFullPage(pageId, this.appId!, this.draftMode);
   }
 
-  static async getPartialPageBySlug(slug: string): Promise<Record<string, unknown>> {
+  static async getPartialPageBySlug(
+    slug: string,
+  ): Promise<
+    Pick<
+      ChaiPage,
+      | "id"
+      | "name"
+      | "slug"
+      | "lang"
+      | "primaryPage"
+      | "seo"
+      | "currentEditor"
+      | "pageType"
+      | "lastSaved"
+      | "dynamic"
+      | "parent"
+      | "blocks"
+    >
+  > {
     ChaiBuilder.verifyInit();
     // if the slug is of format /_partial/{langcode}/{uuid}, get the uuid. langcode is optional
     const uuid = slug.split("/").pop();
     if (!uuid) {
-      throw new Error("Invalid slug format for partial page");
+      throw new Error("PAGE_NOT_FOUND");
     }
 
     // Fetch the partial page data
     const siteSettings = await ChaiBuilder.getSiteSettings();
     const data = await ChaiBuilder.getFullPage(uuid);
-    const fallbackLang = siteSettings?.fallbackLang;
-    const lang = slug.split("/").length > 3 ? slug.split("/")[2] : fallbackLang;
-    return { ...data, fallbackLang, lang };
+    const lang = slug.split("/").length > 3 ? slug.split("/")[2] : siteSettings?.fallbackLang;
+    return { ...data, lang };
   }
 
-  static getPage = cache(async (slug: string): Promise<ChaiBuilderPage | Record<string, unknown>> => {
+  static getPage = cache(async (slug: string): Promise<ChaiFullPage> => {
     ChaiBuilder.verifyInit();
     if (slug.startsWith("/_partial/")) {
       return await ChaiBuilder.getPartialPageBySlug(slug);
     }
-    const page: ChaiBuilderPage = await ChaiBuilder.getPageBySlug(slug);
-    if ("error" in page) {
-      return page;
-    }
-
+    const page = await ChaiBuilder.getPageBySlug(slug);
     const siteSettings = await ChaiBuilder.getSiteSettings();
     const tagPageId = page.id;
     const languagePageId = page.languagePageId || page.id;
@@ -129,16 +148,12 @@ class ChaiBuilder {
       };
     }
     const page = await ChaiBuilder.getPage(slug);
-    if ("error" in page) {
-      return {
-        title: "Page Not Found",
-        description: "The requested page could not be found.",
-        robots: { index: false, follow: false },
-      };
+    if ("error" in page && page.error === "PAGE_NOT_FOUND") {
+      throw notFound();
     }
 
     // Type assertion after error check
-    const pageData = page as Exclude<ChaiBuilderPage, { error: string }>;
+    const pageData = page as ChaiPage;
 
     const externalData = await ChaiBuilder.getPageExternalData({
       blocks: pageData.blocks,
@@ -194,7 +209,7 @@ class ChaiBuilder {
 
   static async getPageData(args: {
     blocks: ChaiBlock[];
-    pageProps: Record<string, unknown>;
+    pageProps: ChaiPageProps;
     pageType: string;
     lang: string;
   }): Promise<Record<string, unknown>> {

frameworks/nextjs/package/lib/get-blocks-styles.ts

@@ -1,5 +1,5 @@
 import { getStylesForBlocks } from "@chaibuilder/sdk/render";
-import { ChaiBlock } from "@chaibuilder/sdk/runtime";
+import type { ChaiBlock } from "@chaibuilder/sdk/types";
 
 export async function getBlocksStyles(blocks: ChaiBlock[]): Promise<string> {
   return await getStylesForBlocks(blocks, false);

frameworks/nextjs/package/lib/get-full-page.ts

@@ -1,7 +1,6 @@
 import { db, safeQuery, schema } from "@chaibuilder/sdk/actions";
-import { ChaiBlock } from "@chaibuilder/sdk/runtime";
-import { differenceInMinutes } from "date-fns";
-import { and, eq, inArray, sql } from "drizzle-orm";
+import { ChaiBlock, ChaiPage } from "@chaibuilder/sdk/types";
+import { and, eq, inArray } from "drizzle-orm";
 import { get, has, isEmpty } from "lodash";
 
 export type GetFullPageOptions = {
@@ -13,28 +12,28 @@ export type GetFullPageOptions = {
   userId?: string;
 };
 
-export type FullPageResponse = {
-  id: string;
-  name: string;
-  slug: string;
-  lang: string;
-  primaryPage?: string | null;
-  seo: any;
-  currentEditor?: string | null;
-  pageType?: string | null;
-  lastSaved?: string | null;
-  dynamic: boolean | null;
-  parent?: string | null;
-  blocks: ChaiBlock[];
-  languagePageId: string;
-};
-
 export async function getFullPage(
   pageId: string,
   appId: string,
   draftMode: boolean,
   options: Partial<GetFullPageOptions> = {},
-): Promise<FullPageResponse> {
+): Promise<
+  Pick<
+    ChaiPage,
+    | "id"
+    | "name"
+    | "slug"
+    | "lang"
+    | "primaryPage"
+    | "seo"
+    | "currentEditor"
+    | "pageType"
+    | "lastSaved"
+    | "dynamic"
+    | "parent"
+    | "blocks"
+  >
+> {
   const table = draftMode ? schema.appPages : schema.appPagesOnline;
 
   // Get page data with selected fields
@@ -59,12 +58,12 @@ export async function getFullPage(
   );
 
   if (error || !pageResult || pageResult.length === 0) {
-    throw new Error("Page not found");
+    throw new Error("PAGE_NOT_FOUND");
   }
 
   const page = pageResult[0];
   if (!page) {
-    throw new Error("Page data is invalid");
+    throw new Error("PAGE_NOT_FOUND");
   }
 
   const primaryPageId = page.primaryPage ?? page.id;
@@ -81,7 +80,7 @@ export async function getFullPage(
   );
 
   if (blocksError) {
-    throw new Error("Failed to fetch page blocks");
+    throw new Error("FAILED_TO_FETCH_PAGE_BLOCKS");
   }
 
   let blocks = (blocksResult?.[0]?.blocks as ChaiBlock[]) ?? [];
@@ -95,76 +94,22 @@ export async function getFullPage(
   // Handle editor locking for draft pages
   let currentEditor = page.currentEditor;
 
-  if (draftMode && options.editor && options.userId) {
-    const lockResult = await handleEditorLock(page, primaryPageId, options.userId, appId);
-    currentEditor = lockResult.currentEditor;
-  }
-
   return {
     id: pageId,
     name: page.name,
     slug: page.slug,
     lang: page.lang,
-    primaryPage: page.primaryPage ?? null,
-    seo: page.seo,
+    primaryPage: page.primaryPage,
+    seo: page.seo ?? {},
     currentEditor,
-    pageType: page.pageType ?? null,
-    lastSaved: page.lastSaved ?? null,
-    dynamic: page.dynamic ?? null,
-    parent: page.parent ?? null,
+    pageType: page.pageType!,
+    lastSaved: page.lastSaved!,
+    dynamic: page.dynamic!,
+    parent: page.parent,
     blocks,
-    languagePageId: page.id,
   };
 }
 
-/**
- * Handle editor locking logic
- */
-async function handleEditorLock(
-  page: any,
-  primaryPageId: string,
-  userId: string,
-  appId: string,
-): Promise<{ currentEditor: string | null }> {
-  const now = new Date();
-  let canTakePage = false;
-
-  // Check if we can take over the page (no editor or last save > 5 minutes ago)
-  if (page.lastSaved) {
-    const lastSaved = new Date(page.lastSaved);
-    canTakePage = differenceInMinutes(now, lastSaved) > 5;
-  }
-
-  const isCurrentEditorNull = page.currentEditor === null;
-
-  if (isCurrentEditorNull || canTakePage) {
-    // Take over the page
-    await safeQuery(() =>
-      db
-        .update(schema.appPages)
-        .set({
-          currentEditor: userId,
-          lastSaved: sql`now()`,
-        })
-        .where(and(eq(schema.appPages.id, primaryPageId), eq(schema.appPages.app, appId))),
-    );
-    return { currentEditor: userId };
-  } else if (page.currentEditor === userId) {
-    // Update last saved time for current editor
-    await safeQuery(() =>
-      db
-        .update(schema.appPages)
-        .set({
-          lastSaved: sql`now()`,
-        })
-        .where(and(eq(schema.appPages.id, primaryPageId), eq(schema.appPages.app, appId))),
-    );
-    return { currentEditor: userId };
-  }
-
-  return { currentEditor: page.currentEditor };
-}
-
 /**
  * Merge partial blocks into the main blocks array
  * Optimized to fetch all partial blocks in a single query