@daf-sdk/runtime 1.0.0

package/dist/chunk-4H6PEYL7.mjs

@@ -0,0 +1,1221 @@
+// src/runtime/integrations/notion.ts
+import { Client } from "@notionhq/client";
+var NOTION_CLIENT_ID = process.env.NOTION_CLIENT_ID || "";
+var NOTION_CLIENT_SECRET = process.env.NOTION_CLIENT_SECRET || "";
+var NOTION_REDIRECT_URI = process.env.NOTION_REDIRECT_URI || "http://localhost:3000/api/integrations/notion/callback";
+function getNotionAuthUrl(userId) {
+  const authUrl = new URL("https://api.notion.com/v1/oauth/authorize");
+  authUrl.searchParams.set("client_id", NOTION_CLIENT_ID);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("owner", "user");
+  authUrl.searchParams.set("redirect_uri", NOTION_REDIRECT_URI);
+  authUrl.searchParams.set("state", userId);
+  return authUrl.toString();
+}
+async function exchangeNotionCode(code) {
+  const encoded = Buffer.from(`${NOTION_CLIENT_ID}:${NOTION_CLIENT_SECRET}`).toString("base64");
+  const response = await fetch("https://api.notion.com/v1/oauth/token", {
+    method: "POST",
+    headers: {
+      "Authorization": `Basic ${encoded}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: NOTION_REDIRECT_URI
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Failed to exchange Notion code: ${error}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    workspaceId: data.workspace_id,
+    workspaceName: data.workspace_name,
+    botId: data.bot_id
+  };
+}
+async function getNotionAccessToken(userId, adapter) {
+  const integration = await adapter.getNotionIntegration(userId);
+  if (!integration) {
+    throw new Error("Notion integration not found. Please connect your Notion account.");
+  }
+  return integration.accessToken;
+}
+function extractPageIdFromUrl(url) {
+  const urlWithoutQuery = url.split("?")[0];
+  const match = urlWithoutQuery.match(/([a-f0-9]{32}|[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})$/i);
+  if (match) {
+    const id = match[1].replace(/-/g, "");
+    return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`;
+  }
+  return null;
+}
+function extractDatabaseIdFromUrl(url) {
+  return extractPageIdFromUrl(url);
+}
+async function getNotionPageTitle(pageId, accessToken) {
+  try {
+    const notion = new Client({ auth: accessToken });
+    const page = await notion.pages.retrieve({ page_id: pageId });
+    if (page.properties) {
+      for (const prop of Object.values(page.properties)) {
+        if (prop.type === "title" && prop.title) {
+          const titleArray = prop.title;
+          if (titleArray.length > 0 && titleArray[0].plain_text) {
+            return titleArray[0].plain_text;
+          }
+        }
+      }
+    }
+    return null;
+  } catch (error) {
+    console.error("Error fetching Notion page title:", error);
+    return null;
+  }
+}
+async function readNotionPage(pageId, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  async function getBlockContent(blockId, indentLevel = 0) {
+    const blocks = await notion.blocks.children.list({
+      block_id: blockId
+    });
+    let content = "";
+    const indent = "  ".repeat(indentLevel);
+    for (const block of blocks.results) {
+      if ("type" in block) {
+        const blockType = block.type;
+        if (blockType === "paragraph" && "paragraph" in block) {
+          const paragraph = block.paragraph;
+          if (paragraph.rich_text && paragraph.rich_text.length > 0) {
+            content += indent + extractTextFromRichText(paragraph.rich_text) + "\n";
+          } else {
+            content += "\n";
+          }
+        } else if (blockType === "heading_1" && "heading_1" in block) {
+          const heading = block.heading_1;
+          if (heading.rich_text) {
+            content += indent + "# " + extractTextFromRichText(heading.rich_text) + "\n";
+          }
+        } else if (blockType === "heading_2" && "heading_2" in block) {
+          const heading = block.heading_2;
+          if (heading.rich_text) {
+            content += indent + "## " + extractTextFromRichText(heading.rich_text) + "\n";
+          }
+        } else if (blockType === "heading_3" && "heading_3" in block) {
+          const heading = block.heading_3;
+          if (heading.rich_text) {
+            content += indent + "### " + extractTextFromRichText(heading.rich_text) + "\n";
+          }
+        } else if (blockType === "bulleted_list_item" && "bulleted_list_item" in block) {
+          const item = block.bulleted_list_item;
+          if (item.rich_text) {
+            content += indent + "\u2022 " + extractTextFromRichText(item.rich_text) + "\n";
+          }
+          if (block.has_children && "id" in block) {
+            content += await getBlockContent(block.id, indentLevel + 1);
+          }
+        } else if (blockType === "numbered_list_item" && "numbered_list_item" in block) {
+          const item = block.numbered_list_item;
+          if (item.rich_text) {
+            content += indent + "1. " + extractTextFromRichText(item.rich_text) + "\n";
+          }
+          if (block.has_children && "id" in block) {
+            content += await getBlockContent(block.id, indentLevel + 1);
+          }
+        } else if (blockType === "to_do" && "to_do" in block) {
+          const todo = block.to_do;
+          const checkbox = todo.checked ? "[x]" : "[ ]";
+          if (todo.rich_text) {
+            content += indent + `- ${checkbox} ` + extractTextFromRichText(todo.rich_text) + "\n";
+          }
+          if (block.has_children && "id" in block) {
+            content += await getBlockContent(block.id, indentLevel + 1);
+          }
+        } else if (blockType === "toggle" && "toggle" in block) {
+          const toggle = block.toggle;
+          if (toggle.rich_text) {
+            content += indent + "\u25B8 " + extractTextFromRichText(toggle.rich_text) + "\n";
+          }
+          if (block.has_children && "id" in block) {
+            content += await getBlockContent(block.id, indentLevel + 1);
+          }
+        } else if (blockType === "code" && "code" in block) {
+          const code = block.code;
+          if (code.rich_text) {
+            content += indent + "```\n" + extractTextFromRichText(code.rich_text) + "\n```\n";
+          }
+        } else if (blockType === "quote" && "quote" in block) {
+          const quote = block.quote;
+          if (quote.rich_text) {
+            content += indent + "> " + extractTextFromRichText(quote.rich_text) + "\n";
+          }
+        } else if (blockType === "callout" && "callout" in block) {
+          const callout = block.callout;
+          if (callout.rich_text) {
+            const icon = callout.icon && "emoji" in callout.icon ? callout.icon.emoji : "\u{1F4CC}";
+            content += indent + `${icon} ` + extractTextFromRichText(callout.rich_text) + "\n";
+          }
+        } else if (blockType === "divider") {
+          content += indent + "---\n";
+        } else if (blockType === "child_page" && "child_page" in block && "id" in block) {
+          const childPage = block.child_page;
+          const title = childPage.title || "Untitled";
+          const url = `https://www.notion.so/${block.id.replace(/-/g, "")}`;
+          content += indent + `${title} (${url})
+`;
+        } else if (blockType === "child_database" && "child_database" in block && "id" in block) {
+          const childDb = block.child_database;
+          const title = childDb.title || "Untitled Database";
+          const url = `https://www.notion.so/${block.id.replace(/-/g, "")}`;
+          content += indent + `[Database] ${title} (${url})
+`;
+        }
+      }
+    }
+    return content;
+  }
+  return await getBlockContent(pageId);
+}
+function extractTextFromRichText(richText) {
+  return richText.map((text) => {
+    if (text.type === "mention" && text.mention) {
+      const plainText = text.plain_text;
+      if (text.mention.type === "page") {
+        const pageId = text.mention.page?.id;
+        if (pageId) {
+          const url = `https://www.notion.so/${pageId.replace(/-/g, "")}`;
+          return `${plainText} (${url})`;
+        }
+      }
+      return plainText;
+    }
+    return text.plain_text;
+  }).join("");
+}
+async function writeNotionPage(pageId, content, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  const existingBlocks = await notion.blocks.children.list({
+    block_id: pageId
+  });
+  for (const block of existingBlocks.results) {
+    if ("id" in block) {
+      await notion.blocks.delete({
+        block_id: block.id
+      });
+    }
+  }
+  const lines = content.split("\n").filter((line) => line.trim());
+  const blocks = [];
+  for (const line of lines) {
+    if (line.startsWith("# ")) {
+      blocks.push({
+        object: "block",
+        type: "heading_1",
+        heading_1: {
+          rich_text: [{ type: "text", text: { content: line.slice(2) } }]
+        }
+      });
+    } else if (line.startsWith("## ")) {
+      blocks.push({
+        object: "block",
+        type: "heading_2",
+        heading_2: {
+          rich_text: [{ type: "text", text: { content: line.slice(3) } }]
+        }
+      });
+    } else if (line.startsWith("### ")) {
+      blocks.push({
+        object: "block",
+        type: "heading_3",
+        heading_3: {
+          rich_text: [{ type: "text", text: { content: line.slice(4) } }]
+        }
+      });
+    } else if (line.startsWith("\u2022 ") || line.startsWith("- ")) {
+      blocks.push({
+        object: "block",
+        type: "bulleted_list_item",
+        bulleted_list_item: {
+          rich_text: [{ type: "text", text: { content: line.slice(2) } }]
+        }
+      });
+    } else if (line.match(/^\d+\.\s/)) {
+      blocks.push({
+        object: "block",
+        type: "numbered_list_item",
+        numbered_list_item: {
+          rich_text: [{ type: "text", text: { content: line.replace(/^\d+\.\s/, "") } }]
+        }
+      });
+    } else {
+      blocks.push({
+        object: "block",
+        type: "paragraph",
+        paragraph: {
+          rich_text: [{ type: "text", text: { content: line } }]
+        }
+      });
+    }
+  }
+  const NOTION_BLOCK_BATCH_LIMIT = 100;
+  for (let i = 0; i < blocks.length; i += NOTION_BLOCK_BATCH_LIMIT) {
+    await notion.blocks.children.append({
+      block_id: pageId,
+      children: blocks.slice(i, i + NOTION_BLOCK_BATCH_LIMIT)
+    });
+  }
+}
+async function selectiveUpdateNotionPage(pageId, content, startBlockIndex, endBlockIndex, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  const response = await notion.blocks.children.list({
+    block_id: pageId
+  });
+  const allBlocks = response.results;
+  if (startBlockIndex < 0 || endBlockIndex > allBlocks.length) {
+    throw new Error(`Invalid block range: startBlockIndex=${startBlockIndex}, endBlockIndex=${endBlockIndex}, total blocks=${allBlocks.length}`);
+  }
+  for (let i = startBlockIndex; i < endBlockIndex && i < allBlocks.length; i++) {
+    await notion.blocks.delete({
+      block_id: allBlocks[i].id
+    });
+  }
+  const lines = content.split("\n").filter((line) => line.trim());
+  const newBlocks = [];
+  for (const line of lines) {
+    if (line.startsWith("# ")) {
+      newBlocks.push({
+        object: "block",
+        type: "heading_1",
+        heading_1: {
+          rich_text: [{ type: "text", text: { content: line.slice(2) } }]
+        }
+      });
+    } else if (line.startsWith("## ")) {
+      newBlocks.push({
+        object: "block",
+        type: "heading_2",
+        heading_2: {
+          rich_text: [{ type: "text", text: { content: line.slice(3) } }]
+        }
+      });
+    } else if (line.startsWith("### ")) {
+      newBlocks.push({
+        object: "block",
+        type: "heading_3",
+        heading_3: {
+          rich_text: [{ type: "text", text: { content: line.slice(4) } }]
+        }
+      });
+    } else if (line.match(/^[•\-]\s/)) {
+      newBlocks.push({
+        object: "block",
+        type: "bulleted_list_item",
+        bulleted_list_item: {
+          rich_text: [{ type: "text", text: { content: line.slice(2) } }]
+        }
+      });
+    } else if (line.match(/^\d+\.\s/)) {
+      newBlocks.push({
+        object: "block",
+        type: "numbered_list_item",
+        numbered_list_item: {
+          rich_text: [{ type: "text", text: { content: line.replace(/^\d+\.\s/, "") } }]
+        }
+      });
+    } else {
+      newBlocks.push({
+        object: "block",
+        type: "paragraph",
+        paragraph: {
+          rich_text: [{ type: "text", text: { content: line } }]
+        }
+      });
+    }
+  }
+  if (newBlocks.length > 0) {
+    const blocksToMoveToEnd = allBlocks.slice(endBlockIndex);
+    const savedBlocks = [];
+    for (const block of blocksToMoveToEnd) {
+      savedBlocks.push(block);
+      await notion.blocks.delete({
+        block_id: block.id
+      });
+    }
+    await notion.blocks.children.append({
+      block_id: pageId,
+      children: newBlocks
+    });
+    if (savedBlocks.length > 0) {
+      const blocksToReinsert = savedBlocks.map((block) => {
+        const blockType = block.type;
+        const blockData = block[blockType];
+        return {
+          object: "block",
+          type: blockType,
+          [blockType]: blockData
+        };
+      });
+      await notion.blocks.children.append({
+        block_id: pageId,
+        children: blocksToReinsert
+      });
+    }
+  }
+}
+async function appendNotionPage(pageId, content, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  const lines = content.split("\n").filter((line) => line.trim());
+  const blocks = [];
+  for (const line of lines) {
+    if (line.startsWith("# ")) {
+      blocks.push({
+        object: "block",
+        type: "heading_1",
+        heading_1: {
+          rich_text: [{ type: "text", text: { content: line.slice(2) } }]
+        }
+      });
+    } else if (line.startsWith("## ")) {
+      blocks.push({
+        object: "block",
+        type: "heading_2",
+        heading_2: {
+          rich_text: [{ type: "text", text: { content: line.slice(3) } }]
+        }
+      });
+    } else if (line.startsWith("### ")) {
+      blocks.push({
+        object: "block",
+        type: "heading_3",
+        heading_3: {
+          rich_text: [{ type: "text", text: { content: line.slice(4) } }]
+        }
+      });
+    } else {
+      blocks.push({
+        object: "block",
+        type: "paragraph",
+        paragraph: {
+          rich_text: [{ type: "text", text: { content: line } }]
+        }
+      });
+    }
+  }
+  const NOTION_BLOCK_BATCH_LIMIT = 100;
+  for (let i = 0; i < blocks.length; i += NOTION_BLOCK_BATCH_LIMIT) {
+    await notion.blocks.children.append({
+      block_id: pageId,
+      children: blocks.slice(i, i + NOTION_BLOCK_BATCH_LIMIT)
+    });
+  }
+}
+async function deleteNotionPage(pageId, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  try {
+    await notion.pages.update({
+      page_id: pageId,
+      archived: true
+    });
+  } catch (error) {
+    if (error?.message?.includes("workspace level pages")) {
+      throw new Error("This Notion page cannot be removed via API because it's at the workspace level. Please move it to a parent page first, or remove it manually in Notion.");
+    }
+    throw error;
+  }
+}
+async function renameNotionPage(pageId, newTitle, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  await notion.pages.update({
+    page_id: pageId,
+    properties: {
+      title: {
+        title: [
+          {
+            text: {
+              content: newTitle
+            }
+          }
+        ]
+      }
+    }
+  });
+}
+async function duplicateNotionPage(pageId, newTitle, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  const originalPage = await notion.pages.retrieve({ page_id: pageId });
+  if (!("parent" in originalPage)) {
+    throw new Error("Cannot access parent information for this page");
+  }
+  const blocks = await notion.blocks.children.list({
+    block_id: pageId
+  });
+  const parent = originalPage.parent;
+  let validParent;
+  if ("page_id" in parent) {
+    validParent = { page_id: parent.page_id };
+  } else if ("database_id" in parent) {
+    validParent = { database_id: parent.database_id };
+  } else if ("workspace" in parent) {
+    validParent = { workspace: true };
+  } else {
+    throw new Error("Cannot duplicate page: parent type not supported");
+  }
+  const newPage = await notion.pages.create({
+    parent: validParent,
+    properties: {
+      title: {
+        title: [
+          {
+            text: {
+              content: newTitle
+            }
+          }
+        ]
+      }
+    }
+  });
+  if (blocks.results.length > 0) {
+    const blockChildren = blocks.results.map((block) => {
+      const blockCopy = {
+        type: block.type
+      };
+      if (block.type && block[block.type]) {
+        blockCopy[block.type] = block[block.type];
+      }
+      return blockCopy;
+    });
+    try {
+      await notion.blocks.children.append({
+        block_id: newPage.id,
+        children: blockChildren
+      });
+    } catch (error) {
+      console.error("Error copying blocks to new page:", error);
+    }
+  }
+  return {
+    pageId: newPage.id,
+    url: "url" in newPage ? newPage.url : `https://www.notion.so/${newPage.id.replace(/-/g, "")}`
+  };
+}
+async function createNotionSubpage(parentPageId, pageTitle, accessToken, initialContent) {
+  const notion = new Client({ auth: accessToken });
+  const pageData = {
+    properties: {
+      title: {
+        title: [
+          {
+            text: {
+              content: pageTitle
+            }
+          }
+        ]
+      }
+    }
+  };
+  if (parentPageId) {
+    pageData.parent = {
+      page_id: parentPageId
+    };
+  } else {
+    pageData.parent = {
+      workspace: true
+    };
+  }
+  const newPage = await notion.pages.create(pageData);
+  if (initialContent) {
+    const lines = initialContent.split("\n").filter((line) => line.trim());
+    const blocks = [];
+    const NOTION_TEXT_LIMIT = 2e3;
+    const chunkText = (text) => {
+      const chunks = [];
+      for (let i = 0; i < text.length; i += NOTION_TEXT_LIMIT) {
+        chunks.push(text.slice(i, i + NOTION_TEXT_LIMIT));
+      }
+      return chunks.length > 0 ? chunks : [""];
+    };
+    for (const line of lines) {
+      if (line.startsWith("# ")) {
+        blocks.push({
+          object: "block",
+          type: "heading_1",
+          heading_1: {
+            rich_text: [{ type: "text", text: { content: line.slice(2).slice(0, NOTION_TEXT_LIMIT) } }]
+          }
+        });
+      } else if (line.startsWith("## ")) {
+        blocks.push({
+          object: "block",
+          type: "heading_2",
+          heading_2: {
+            rich_text: [{ type: "text", text: { content: line.slice(3).slice(0, NOTION_TEXT_LIMIT) } }]
+          }
+        });
+      } else if (line.startsWith("### ")) {
+        blocks.push({
+          object: "block",
+          type: "heading_3",
+          heading_3: {
+            rich_text: [{ type: "text", text: { content: line.slice(4).slice(0, NOTION_TEXT_LIMIT) } }]
+          }
+        });
+      } else if (line.startsWith("\u2022 ") || line.startsWith("- ")) {
+        blocks.push({
+          object: "block",
+          type: "bulleted_list_item",
+          bulleted_list_item: {
+            rich_text: [{ type: "text", text: { content: line.slice(2).slice(0, NOTION_TEXT_LIMIT) } }]
+          }
+        });
+      } else {
+        for (const chunk of chunkText(line)) {
+          blocks.push({
+            object: "block",
+            type: "paragraph",
+            paragraph: {
+              rich_text: [{ type: "text", text: { content: chunk } }]
+            }
+          });
+        }
+      }
+    }
+    const NOTION_BLOCK_BATCH_LIMIT = 100;
+    for (let i = 0; i < blocks.length; i += NOTION_BLOCK_BATCH_LIMIT) {
+      await notion.blocks.children.append({
+        block_id: newPage.id,
+        children: blocks.slice(i, i + NOTION_BLOCK_BATCH_LIMIT)
+      });
+    }
+  }
+  return {
+    pageId: newPage.id,
+    url: "url" in newPage ? newPage.url : `https://www.notion.so/${newPage.id.replace(/-/g, "")}`
+  };
+}
+async function listNotionPageChildren(pageId, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  const blocks = await notion.blocks.children.list({
+    block_id: pageId
+  });
+  const children = [];
+  for (const block of blocks.results) {
+    if (!("type" in block)) continue;
+    if (block.type === "child_page" && "child_page" in block) {
+      const childPage = block.child_page;
+      children.push({
+        id: block.id,
+        title: childPage.title || "Untitled",
+        type: "page",
+        url: `https://www.notion.so/${block.id.replace(/-/g, "")}`
+      });
+    } else if (block.type === "child_database" && "child_database" in block) {
+      const childDb = block.child_database;
+      children.push({
+        id: block.id,
+        title: childDb.title || "Untitled Database",
+        type: "database",
+        url: `https://www.notion.so/${block.id.replace(/-/g, "")}`
+      });
+    }
+  }
+  return children;
+}
+async function getNotionDatabase(databaseId, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  const database = await notion.databases.retrieve({ database_id: databaseId });
+  let title = "Untitled Database";
+  if (database.title && database.title.length > 0) {
+    title = database.title[0].plain_text || "Untitled Database";
+  }
+  return {
+    title,
+    properties: database.properties || {}
+  };
+}
+async function createNotionDatabasePage(databaseId, properties, accessToken, content) {
+  const notion = new Client({ auth: accessToken });
+  const database = await notion.databases.retrieve({ database_id: databaseId });
+  let dbProperties;
+  if (database.data_sources && database.data_sources.length > 0) {
+    const dataSourceId = database.data_sources[0].id;
+    console.log(`Fetching data source properties for data source ID: ${dataSourceId}`);
+    try {
+      const dataSource = await notion.dataSources.retrieve({ data_source_id: dataSourceId });
+      dbProperties = dataSource.properties;
+    } catch (error) {
+      console.error("Error fetching data source:", error);
+      throw new Error(`Failed to fetch data source properties: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  } else if (database.properties) {
+    dbProperties = database.properties;
+  }
+  if (!dbProperties || Object.keys(dbProperties).length === 0) {
+    console.error("Database retrieval result:", JSON.stringify(database, null, 2));
+    throw new Error(`Database has no properties defined. Database ID: ${databaseId}`);
+  }
+  const formattedProperties = {};
+  for (const [propName, propValue] of Object.entries(properties)) {
+    const propSchema = dbProperties[propName];
+    if (!propSchema) {
+      console.warn(`Property "${propName}" not found in database schema, skipping`);
+      continue;
+    }
+    const propType = propSchema.type;
+    switch (propType) {
+      case "title":
+        formattedProperties[propName] = {
+          title: [{ text: { content: String(propValue) } }]
+        };
+        break;
+      case "rich_text":
+        formattedProperties[propName] = {
+          rich_text: [{ text: { content: String(propValue) } }]
+        };
+        break;
+      case "number":
+        formattedProperties[propName] = {
+          number: Number(propValue)
+        };
+        break;
+      case "select":
+        formattedProperties[propName] = {
+          select: { name: String(propValue) }
+        };
+        break;
+      case "multi_select":
+        const values = Array.isArray(propValue) ? propValue : [propValue];
+        formattedProperties[propName] = {
+          multi_select: values.map((v) => ({ name: String(v) }))
+        };
+        break;
+      case "date":
+        formattedProperties[propName] = {
+          date: { start: String(propValue) }
+        };
+        break;
+      case "checkbox":
+        formattedProperties[propName] = {
+          checkbox: Boolean(propValue)
+        };
+        break;
+      case "url":
+        formattedProperties[propName] = {
+          url: String(propValue)
+        };
+        break;
+      case "email":
+        formattedProperties[propName] = {
+          email: String(propValue)
+        };
+        break;
+      case "phone_number":
+        formattedProperties[propName] = {
+          phone_number: String(propValue)
+        };
+        break;
+      default:
+        console.warn(`Property type "${propType}" not supported for property "${propName}", skipping`);
+    }
+  }
+  if (Object.keys(formattedProperties).length === 0) {
+    const availableProps = Object.keys(dbProperties).join(", ");
+    const requestedProps = Object.keys(properties).join(", ");
+    throw new Error(
+      `No valid properties found. Requested properties: ${requestedProps}. Available properties in database: ${availableProps}`
+    );
+  }
+  const newPage = await notion.pages.create({
+    parent: { database_id: databaseId },
+    properties: formattedProperties
+  });
+  if (content) {
+    const lines = content.split("\n").filter((line) => line.trim());
+    const blocks = [];
+    for (const line of lines) {
+      if (line.startsWith("# ")) {
+        blocks.push({
+          object: "block",
+          type: "heading_1",
+          heading_1: {
+            rich_text: [{ type: "text", text: { content: line.slice(2) } }]
+          }
+        });
+      } else if (line.startsWith("## ")) {
+        blocks.push({
+          object: "block",
+          type: "heading_2",
+          heading_2: {
+            rich_text: [{ type: "text", text: { content: line.slice(3) } }]
+          }
+        });
+      } else if (line.startsWith("### ")) {
+        blocks.push({
+          object: "block",
+          type: "heading_3",
+          heading_3: {
+            rich_text: [{ type: "text", text: { content: line.slice(4) } }]
+          }
+        });
+      } else if (line.startsWith("\u2022 ") || line.startsWith("- ")) {
+        blocks.push({
+          object: "block",
+          type: "bulleted_list_item",
+          bulleted_list_item: {
+            rich_text: [{ type: "text", text: { content: line.slice(2) } }]
+          }
+        });
+      } else {
+        blocks.push({
+          object: "block",
+          type: "paragraph",
+          paragraph: {
+            rich_text: [{ type: "text", text: { content: line } }]
+          }
+        });
+      }
+    }
+    const NOTION_BLOCK_BATCH_LIMIT = 100;
+    for (let i = 0; i < blocks.length; i += NOTION_BLOCK_BATCH_LIMIT) {
+      await notion.blocks.children.append({
+        block_id: newPage.id,
+        children: blocks.slice(i, i + NOTION_BLOCK_BATCH_LIMIT)
+      });
+    }
+  }
+  return {
+    pageId: newPage.id,
+    url: "url" in newPage ? newPage.url : `https://www.notion.so/${newPage.id.replace(/-/g, "")}`
+  };
+}
+async function queryNotionDatabase(databaseId, accessToken, filter, sorts) {
+  const notion = new Client({ auth: accessToken });
+  const response = await notion.databases.query({
+    database_id: databaseId,
+    filter,
+    sorts
+  });
+  return response.results;
+}
+async function createNotionDatabase(parentPageId, title, properties, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  const parent = parentPageId ? {
+    type: "page_id",
+    page_id: parentPageId
+  } : {
+    type: "workspace",
+    workspace: true
+  };
+  const database = await notion.databases.create({
+    parent,
+    title: [
+      {
+        type: "text",
+        text: {
+          content: title
+        }
+      }
+    ],
+    properties
+  });
+  return {
+    databaseId: database.id,
+    url: "url" in database ? database.url : `https://www.notion.so/${database.id.replace(/-/g, "")}`
+  };
+}
+async function readNotionDatabase(databaseId, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  const database = await notion.databases.retrieve({ database_id: databaseId });
+  let title = "Untitled Database";
+  if (database.title && database.title.length > 0) {
+    title = database.title[0].plain_text || "Untitled Database";
+  }
+  let dbProperties = {};
+  if (database.data_sources && database.data_sources.length > 0) {
+    const dataSourceId = database.data_sources[0].id;
+    try {
+      const dataSource = await notion.dataSources.retrieve({ data_source_id: dataSourceId });
+      dbProperties = dataSource.properties || {};
+    } catch (error) {
+      console.error("Error fetching data source:", error);
+    }
+  } else if (database.properties) {
+    dbProperties = database.properties;
+  }
+  return {
+    title,
+    properties: dbProperties,
+    url: database.url || `https://www.notion.so/${databaseId.replace(/-/g, "")}`
+  };
+}
+async function updateNotionDatabase(databaseId, accessToken, title, properties) {
+  const notion = new Client({ auth: accessToken });
+  if (title) {
+    await notion.databases.update({
+      database_id: databaseId,
+      title: [
+        {
+          type: "text",
+          text: {
+            content: title
+          }
+        }
+      ]
+    });
+  }
+  if (properties && Object.keys(properties).length > 0) {
+    const database = await notion.databases.retrieve({ database_id: databaseId });
+    if (database.data_sources && database.data_sources.length > 0) {
+      const dataSourceId = database.data_sources[0].id;
+      await notion.dataSources.update({
+        data_source_id: dataSourceId,
+        properties
+      });
+    } else {
+      await notion.databases.update({
+        database_id: databaseId,
+        properties
+      });
+    }
+  }
+}
+async function deleteNotionDatabase(databaseId, accessToken) {
+  const notion = new Client({ auth: accessToken });
+  try {
+    const result = await notion.databases.update({
+      database_id: databaseId,
+      in_trash: true
+      // Databases use in_trash instead of archived
+    });
+    console.log("[deleteNotionDatabase] Database moved to trash successfully:", {
+      id: result.id,
+      in_trash: result.in_trash
+    });
+  } catch (error) {
+    if (error.message && error.message.includes("workspace level")) {
+      throw new Error("Cannot archive workspace-level databases via API. Only databases inside pages can be archived. Please archive this database manually in Notion or move it inside a page first.");
+    }
+    throw new Error(`Failed to move database to trash: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+async function duplicateNotionDatabase(databaseId, accessToken, newDatabaseName) {
+  const notion = new Client({ auth: accessToken });
+  const originalDatabase = await notion.databases.retrieve({ database_id: databaseId });
+  let originalTitle = "Untitled";
+  if (originalDatabase.title && Array.isArray(originalDatabase.title) && originalDatabase.title.length > 0) {
+    originalTitle = originalDatabase.title[0].plain_text || "Untitled";
+  }
+  const newTitle = newDatabaseName || `${originalTitle} (Copy)`;
+  let rawProperties = {};
+  if (originalDatabase.data_sources && originalDatabase.data_sources.length > 0) {
+    const dataSourceId = originalDatabase.data_sources[0].id;
+    const dataSource = await notion.dataSources.retrieve({ data_source_id: dataSourceId });
+    rawProperties = dataSource.properties;
+  } else if (originalDatabase.properties) {
+    rawProperties = originalDatabase.properties;
+  }
+  console.log("[duplicateDatabase] Raw properties retrieved:", JSON.stringify(rawProperties, null, 2));
+  const properties = {};
+  for (const [propName, propSchema] of Object.entries(rawProperties)) {
+    const schema = propSchema;
+    const propType = schema.type;
+    if (propType === "title") {
+      properties[propName] = { title: {} };
+    } else if (propType === "rich_text") {
+      properties[propName] = { rich_text: {} };
+    } else if (propType === "number") {
+      properties[propName] = { number: schema.number || {} };
+    } else if (propType === "select") {
+      properties[propName] = { select: schema.select || {} };
+    } else if (propType === "multi_select") {
+      properties[propName] = { multi_select: schema.multi_select || {} };
+    } else if (propType === "date") {
+      properties[propName] = { date: {} };
+    } else if (propType === "checkbox") {
+      properties[propName] = { checkbox: {} };
+    } else if (propType === "url") {
+      properties[propName] = { url: {} };
+    } else if (propType === "email") {
+      properties[propName] = { email: {} };
+    } else if (propType === "phone_number") {
+      properties[propName] = { phone_number: {} };
+    } else if (propType === "people") {
+      properties[propName] = { people: {} };
+    } else if (propType === "files") {
+      properties[propName] = { files: {} };
+    } else if (propType === "relation") {
+      properties[propName] = { relation: schema.relation || {} };
+    } else if (propType === "rollup") {
+      properties[propName] = { rollup: schema.rollup || {} };
+    } else if (propType === "formula") {
+      properties[propName] = { formula: schema.formula || {} };
+    } else if (propType === "status") {
+      properties[propName] = { status: schema.status || {} };
+    } else if (propType === "created_time") {
+      properties[propName] = { created_time: {} };
+    } else if (propType === "created_by") {
+      properties[propName] = { created_by: {} };
+    } else if (propType === "last_edited_time") {
+      properties[propName] = { last_edited_time: {} };
+    } else if (propType === "last_edited_by") {
+      properties[propName] = { last_edited_by: {} };
+    } else {
+      console.warn(`[duplicateDatabase] Unknown property type "${propType}" for property "${propName}", copying as-is`);
+      properties[propName] = { [propType]: schema[propType] || {} };
+    }
+  }
+  console.log("[duplicateDatabase] Cleaned properties for create:", JSON.stringify(properties, null, 2));
+  const parent = originalDatabase.parent;
+  console.log("[duplicateDatabase] Creating database with parent:", JSON.stringify(parent, null, 2));
+  console.log("[duplicateDatabase] Number of properties:", Object.keys(properties).length);
+  try {
+    const titleProperty = Object.entries(properties).find(([_, schema]) => schema.title);
+    const titlePropName = titleProperty ? titleProperty[0] : "Name";
+    const minimalProperties = titleProperty ? { [titlePropName]: titleProperty[1] } : { "Name": { "title": {} } };
+    console.log("[duplicateDatabase] Step 1: Creating with title property only");
+    const newDatabase = await notion.databases.create({
+      parent,
+      title: [{ type: "text", text: { content: newTitle } }],
+      properties: minimalProperties
+    });
+    console.log("[duplicateDatabase] Database created:", newDatabase.id);
+    const remainingProperties = Object.fromEntries(
+      Object.entries(properties).filter(([name, _]) => name !== titlePropName)
+    );
+    if (Object.keys(remainingProperties).length > 0) {
+      console.log("[duplicateDatabase] Step 2: Adding", Object.keys(remainingProperties).length, "remaining properties");
+      const createdDb = await notion.databases.retrieve({ database_id: newDatabase.id });
+      if (createdDb.data_sources && createdDb.data_sources.length > 0) {
+        const dataSourceId = createdDb.data_sources[0].id;
+        console.log("[duplicateDatabase] Using data source API to add properties to data source:", dataSourceId);
+        await notion.dataSources.update({
+          data_source_id: dataSourceId,
+          properties: remainingProperties
+        });
+        console.log("[duplicateDatabase] All properties added successfully via data source API");
+      } else {
+        console.log("[duplicateDatabase] No data sources found, using legacy database update API");
+        await notion.databases.update({
+          database_id: newDatabase.id,
+          properties: remainingProperties
+        });
+      }
+    }
+    const verifyDatabase = await notion.databases.retrieve({ database_id: newDatabase.id });
+    let finalPropertyCount = 0;
+    if (verifyDatabase.data_sources && verifyDatabase.data_sources.length > 0) {
+      const dataSourceId = verifyDatabase.data_sources[0].id;
+      const verifyDataSource = await notion.dataSources.retrieve({ data_source_id: dataSourceId });
+      finalPropertyCount = Object.keys(verifyDataSource.properties || {}).length;
+      console.log("[duplicateDatabase] Final verification - properties:", finalPropertyCount, "/", Object.keys(properties).length);
+    } else if (verifyDatabase.properties) {
+      finalPropertyCount = Object.keys(verifyDatabase.properties).length;
+      console.log("[duplicateDatabase] Final verification - properties:", finalPropertyCount, "/", Object.keys(properties).length);
+    }
+    return {
+      databaseId: newDatabase.id,
+      title: newTitle,
+      url: "url" in newDatabase ? newDatabase.url : `https://www.notion.so/${newDatabase.id.replace(/-/g, "")}`
+    };
+  } catch (error) {
+    console.error("[duplicateDatabase] Error:", error);
+    throw error;
+  }
+}
+async function updateNotionDatabasePage(pageId, accessToken, properties, content) {
+  const notion = new Client({ auth: accessToken });
+  if (properties && Object.keys(properties).length > 0) {
+    const page = await notion.pages.retrieve({ page_id: pageId });
+    if (!("parent" in page) || !("database_id" in page.parent)) {
+      throw new Error("This page is not a database page");
+    }
+    const databaseId = page.parent.database_id;
+    const database = await notion.databases.retrieve({ database_id: databaseId });
+    let dbProperties;
+    if (database.data_sources && database.data_sources.length > 0) {
+      const dataSourceId = database.data_sources[0].id;
+      console.log(`Fetching data source properties for data source ID: ${dataSourceId}`);
+      try {
+        const dataSource = await notion.dataSources.retrieve({ data_source_id: dataSourceId });
+        dbProperties = dataSource.properties;
+      } catch (error) {
+        console.error("Error fetching data source:", error);
+        throw new Error(`Failed to fetch data source properties: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    } else if (database.properties) {
+      dbProperties = database.properties;
+    }
+    if (!dbProperties || Object.keys(dbProperties).length === 0) {
+      throw new Error("Database has no properties defined");
+    }
+    const formattedProperties = {};
+    for (const [propName, propValue] of Object.entries(properties)) {
+      const propSchema = dbProperties[propName];
+      if (!propSchema) {
+        console.warn(`Property "${propName}" not found in database schema, skipping`);
+        continue;
+      }
+      const propType = propSchema.type;
+      switch (propType) {
+        case "title":
+          formattedProperties[propName] = {
+            title: [{ text: { content: String(propValue) } }]
+          };
+          break;
+        case "rich_text":
+          formattedProperties[propName] = {
+            rich_text: [{ text: { content: String(propValue) } }]
+          };
+          break;
+        case "number":
+          formattedProperties[propName] = {
+            number: Number(propValue)
+          };
+          break;
+        case "select":
+          formattedProperties[propName] = {
+            select: propValue === null ? null : { name: String(propValue) }
+          };
+          break;
+        case "multi_select":
+          const values = Array.isArray(propValue) ? propValue : [propValue];
+          formattedProperties[propName] = {
+            multi_select: values.map((v) => ({ name: String(v) }))
+          };
+          break;
+        case "date":
+          formattedProperties[propName] = {
+            date: propValue === null ? null : { start: String(propValue) }
+          };
+          break;
+        case "checkbox":
+          formattedProperties[propName] = {
+            checkbox: Boolean(propValue)
+          };
+          break;
+        case "url":
+          formattedProperties[propName] = {
+            url: propValue === null ? null : String(propValue)
+          };
+          break;
+        case "email":
+          formattedProperties[propName] = {
+            email: propValue === null ? null : String(propValue)
+          };
+          break;
+        case "phone_number":
+          formattedProperties[propName] = {
+            phone_number: propValue === null ? null : String(propValue)
+          };
+          break;
+        default:
+          console.warn(`Property type "${propType}" not supported for property "${propName}", skipping`);
+      }
+    }
+    if (Object.keys(formattedProperties).length === 0) {
+      const availableProps = Object.keys(dbProperties).join(", ");
+      const requestedProps = Object.keys(properties).join(", ");
+      throw new Error(
+        `No valid properties found to update. Requested properties: ${requestedProps}. Available properties in database: ${availableProps}`
+      );
+    }
+    await notion.pages.update({
+      page_id: pageId,
+      properties: formattedProperties
+    });
+  }
+  if (content !== void 0) {
+    const existingBlocks = await notion.blocks.children.list({
+      block_id: pageId
+    });
+    for (const block of existingBlocks.results) {
+      if ("id" in block) {
+        await notion.blocks.delete({
+          block_id: block.id
+        });
+      }
+    }
+    const lines = content.split("\n").filter((line) => line.trim());
+    const blocks = [];
+    for (const line of lines) {
+      if (line.startsWith("# ")) {
+        blocks.push({
+          object: "block",
+          type: "heading_1",
+          heading_1: {
+            rich_text: [{ type: "text", text: { content: line.slice(2) } }]
+          }
+        });
+      } else if (line.startsWith("## ")) {
+        blocks.push({
+          object: "block",
+          type: "heading_2",
+          heading_2: {
+            rich_text: [{ type: "text", text: { content: line.slice(3) } }]
+          }
+        });
+      } else if (line.startsWith("### ")) {
+        blocks.push({
+          object: "block",
+          type: "heading_3",
+          heading_3: {
+            rich_text: [{ type: "text", text: { content: line.slice(4) } }]
+          }
+        });
+      } else if (line.startsWith("\u2022 ") || line.startsWith("- ")) {
+        blocks.push({
+          object: "block",
+          type: "bulleted_list_item",
+          bulleted_list_item: {
+            rich_text: [{ type: "text", text: { content: line.slice(2) } }]
+          }
+        });
+      } else {
+        blocks.push({
+          object: "block",
+          type: "paragraph",
+          paragraph: {
+            rich_text: [{ type: "text", text: { content: line } }]
+          }
+        });
+      }
+    }
+    const NOTION_BLOCK_BATCH_LIMIT = 100;
+    for (let i = 0; i < blocks.length; i += NOTION_BLOCK_BATCH_LIMIT) {
+      await notion.blocks.children.append({
+        block_id: pageId,
+        children: blocks.slice(i, i + NOTION_BLOCK_BATCH_LIMIT)
+      });
+    }
+  }
+}
+
+export {
+  getNotionAuthUrl,
+  exchangeNotionCode,
+  getNotionAccessToken,
+  extractPageIdFromUrl,
+  extractDatabaseIdFromUrl,
+  getNotionPageTitle,
+  readNotionPage,
+  writeNotionPage,
+  selectiveUpdateNotionPage,
+  appendNotionPage,
+  deleteNotionPage,
+  renameNotionPage,
+  duplicateNotionPage,
+  createNotionSubpage,
+  listNotionPageChildren,
+  getNotionDatabase,
+  createNotionDatabasePage,
+  queryNotionDatabase,
+  createNotionDatabase,
+  readNotionDatabase,
+  updateNotionDatabase,
+  deleteNotionDatabase,
+  duplicateNotionDatabase,
+  updateNotionDatabasePage
+};