katanakit-js 6.2.0 → 6.6.1

package/dist/adapters/notion/notion.service.js

@@ -6,83 +6,324 @@ import { NotionBlockListSchema, NotionBlockResponseSchema, NotionConfigSchema, N
 const NOTION_API_BASE = "https://api.notion.com/v1";
 /** Default Notion API version. */
 const NOTION_API_VERSION = "2022-06-28";
-/** Module-level Notion configuration. */
-let config = null;
-/**
- * Retrieves the registered Notion config, or `null` when not configured.
- * @internal
- */
-function getConfig() {
-    return config;
-}
 /** Builds a throwable error carrying `status`/`details` for `useAttempt`. */
 function apiError(message, status, details) {
     return Object.assign(new Error(message), { status, details });
 }
 /**
- * Internal helper to make authenticated requests to the Notion API.
- * Handles Authorization header, Notion-Version, and JSON serialization.
- * @internal
+ * NotionService - Singleton para el cliente de la Notion API.
+ *
+ * Aplica el patrón Singleton: una única instancia mantiene la configuración
+ * (token, versión, base URL) y centraliza las operaciones sobre páginas,
+ * bloques, bases de datos, usuarios y búsqueda, devolviendo siempre Safe Results.
+ *
+ * @example
+ * ```ts
+ * const notion = NotionService.getInstance();
+ * notion.useInit({ token: process.env.NOTION_TOKEN });
+ * const result = await notion.useGetPage("page-id");
+ * ```
  */
-async function notionFetch(endpoint, options = {}, schema) {
-    const cfg = getConfig();
-    if (!cfg) {
-        return {
-            data: null,
-            error: { message: "[Notion] Not configured. Call defineNotionConfig() first.", status: 0 },
-            url: "",
-            status: 0,
-            ok: false,
-        };
+export class NotionService {
+    static instance;
+    /** Registered Notion configuration. */
+    config = null;
+    /**
+     * Constructor privado - enforce singleton.
+     */
+    constructor() { }
+    /**
+     * Obtiene la instancia única del NotionService (Singleton).
+     *
+     * @returns La instancia única de {@link NotionService}.
+     */
+    static getInstance() {
+        if (!NotionService.instance) {
+            NotionService.instance = new NotionService();
+        }
+        return NotionService.instance;
     }
-    const { token, apiVersion, apiBaseUrl } = cfg;
-    const base = apiBaseUrl ?? NOTION_API_BASE;
-    const version = apiVersion ?? NOTION_API_VERSION;
-    const url = `${base}${endpoint}`;
-    const attempt = await useAttempt(async () => {
-        const response = await fetch(url, {
-            ...options,
-            headers: {
-                Authorization: `Bearer ${token}`,
-                "Notion-Version": version,
-                "Content-Type": "application/json",
-                ...options.headers,
-            },
-        });
-        if (!response.ok) {
-            const errorBody = await response.text().catch(() => null);
-            throw apiError(`Notion API Error: ${response.statusText}`, response.status, errorBody);
+    /**
+     * Registers the Notion API configuration.
+     *
+     * @param cfg - Integration token (starts with "ntn_" or "secret_"), optional
+     *   API version and base URL.
+     * @throws {Error} If the config fails Zod validation.
+     *
+     * @example
+     * ```ts
+     * NotionService.getInstance().useInit({ token: process.env.NOTION_TOKEN });
+     * ```
+     */
+    useInit(cfg) {
+        const parsed = useValidate(NotionConfigSchema, cfg);
+        if (!parsed.ok) {
+            throw new Error("[Notion] Invalid config: " + parsed.error.message);
+        }
+        this.config = { ...parsed.data };
+    }
+    /**
+     * Internal helper to make authenticated requests to the Notion API.
+     * Handles Authorization header, Notion-Version, and JSON serialization.
+     * @internal
+     */
+    async useRequest(endpoint, options = {}, schema) {
+        const cfg = this.config;
+        if (!cfg) {
+            return {
+                data: null,
+                error: {
+                    message: "[Notion] Not configured. Call defineNotionConfig() first.",
+                    status: 0,
+                },
+                url: "",
+                status: 0,
+                ok: false,
+            };
         }
-        if (response.status === 204) {
-            return { data: null, status: 204 };
+        const { token, apiVersion, apiBaseUrl } = cfg;
+        const base = apiBaseUrl ?? NOTION_API_BASE;
+        const version = apiVersion ?? NOTION_API_VERSION;
+        const url = `${base}${endpoint}`;
+        const attempt = await useAttempt(async () => {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    Authorization: `Bearer ${token}`,
+                    "Notion-Version": version,
+                    "Content-Type": "application/json",
+                    ...options.headers,
+                },
+            });
+            if (!response.ok) {
+                const errorBody = await response.text().catch(() => null);
+                throw apiError(`Notion API Error: ${response.statusText}`, response.status, errorBody);
+            }
+            if (response.status === 204) {
+                return { data: null, status: 204 };
+            }
+            const data = (await response.json());
+            if (schema) {
+                const parsed = useValidate(schema, data);
+                if (!parsed.ok) {
+                    throw apiError("Notion Validation Error: " + parsed.error.message, 502, parsed.error.details);
+                }
+                return { data: parsed.data, status: response.status };
+            }
+            return { data: data, status: response.status };
+        });
+        if (!attempt.ok) {
+            const { message, status, details } = attempt.error;
+            return {
+                data: null,
+                error: {
+                    message: status === 0 ? `Network Error: ${message}` : message,
+                    status,
+                    details,
+                },
+                url,
+                status,
+                ok: false,
+            };
         }
-        const data = (await response.json());
-        if (schema) {
-            const parsed = useValidate(schema, data);
+        return { data: attempt.data.data, error: null, url, status: attempt.data.status, ok: true };
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Pages                                                                    */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a single Notion page by its ID. */
+    async useGetPage(pageId) {
+        return this.useRequest(`/pages/${pageId}`, {}, NotionPageResponseSchema);
+    }
+    /** Creates a new Notion page inside a database or as a child of another page. */
+    async useCreatePage(parent, properties, children) {
+        // Payload is Record<string, unknown>: no strict shape possible, skip input validation.
+        return this.useRequest("/pages", { method: "POST", body: JSON.stringify({ parent, properties, children }) }, NotionPageResponseSchema);
+    }
+    /** Updates properties of an existing Notion page. */
+    async useUpdatePage(pageId, properties) {
+        // Payload is Record<string, unknown>: no strict shape possible, skip input validation.
+        return this.useRequest(`/pages/${pageId}`, { method: "PATCH", body: JSON.stringify({ properties }) }, NotionPageResponseSchema);
+    }
+    /** Archives (soft-deletes) a Notion page. */
+    async useArchivePage(pageId) {
+        return this.useRequest(`/pages/${pageId}`, { method: "PATCH", body: JSON.stringify({ archived: true }) }, NotionPageResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Blocks                                                                   */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a single Notion block by its ID. */
+    async useGetBlock(blockId) {
+        return this.useRequest(`/blocks/${blockId}`, {}, NotionBlockResponseSchema);
+    }
+    /**
+     * Retrieves the direct children blocks of a block (single page).
+     *
+     * Use for manual pagination. For most cases, prefer
+     * {@link useListAllBlockChildren} which handles pagination automatically.
+     *
+     * @param blockId - The parent block ID (usually a page ID).
+     * @param options - Pagination: `start_cursor` for next page, `page_size` (max 100).
+     */
+    async useGetBlockChildren(blockId, options) {
+        const params = new URLSearchParams();
+        if (options?.start_cursor)
+            params.set("start_cursor", options.start_cursor);
+        if (options?.page_size)
+            params.set("page_size", String(options.page_size));
+        const qs = params.toString();
+        return this.useRequest(`/blocks/${blockId}/children${qs ? `?${qs}` : ""}`, {}, NotionBlockListSchema);
+    }
+    /** Appends new child blocks to a parent block. */
+    async useAppendBlocks(blockId, children) {
+        // Payload is unknown[]: no strict shape possible, skip input validation.
+        return this.useRequest(`/blocks/${blockId}/children`, { method: "PATCH", body: JSON.stringify({ children }) }, NotionBlockResponseSchema);
+    }
+    /** Updates the content of an existing block. */
+    async useUpdateBlock(blockId, content) {
+        // Payload is Record<string, unknown>: no strict shape possible, skip input validation.
+        return this.useRequest(`/blocks/${blockId}`, { method: "PATCH", body: JSON.stringify(content) }, NotionBlockResponseSchema);
+    }
+    /** Deletes (archives) a Notion block. The block is soft-deleted. */
+    async useDeleteBlock(blockId) {
+        return this.useRequest(`/blocks/${blockId}`, { method: "DELETE" }, NotionBlockResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Databases                                                                */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a Notion database schema by its ID. */
+    async useGetDatabase(databaseId) {
+        return this.useRequest(`/databases/${databaseId}`, {}, NotionDatabaseResponseSchema);
+    }
+    /**
+     * Queries a Notion database with filters and sorts (single page).
+     *
+     * For most cases, prefer {@link useListAllDatabasePages} which handles
+     * pagination automatically.
+     */
+    async useQueryDatabase(databaseId, query) {
+        if (query !== undefined) {
+            const parsed = useValidate(NotionDatabaseQuerySchema, query);
             if (!parsed.ok) {
-                throw apiError("Notion Validation Error: " + parsed.error.message, 502, parsed.error.details);
+                return { data: null, error: parsed.error, url: "", status: parsed.status, ok: false };
             }
-            return { data: parsed.data, status: response.status };
         }
-        return { data: data, status: response.status };
-    });
-    if (!attempt.ok) {
-        const { message, status, details } = attempt.error;
+        return this.useRequest(`/databases/${databaseId}/query`, { method: "POST", body: JSON.stringify(query ?? {}) }, NotionPageListSchema);
+    }
+    /** Creates a new Notion database inside a page. */
+    async useCreateDatabase(parent, title, properties) {
+        // Payload properties are Record<string, NotionPropertySchema>: free-form, skip input validation.
+        return this.useRequest("/databases", { method: "POST", body: JSON.stringify({ parent, title, properties }) }, NotionDatabaseResponseSchema);
+    }
+    /** Updates a Notion database title and/or property schemas. */
+    async useUpdateDatabase(databaseId, title, properties) {
+        const body = { title };
+        if (properties)
+            body.properties = properties;
+        // Payload properties are Record<string, NotionPropertySchema>: free-form, skip input validation.
+        return this.useRequest(`/databases/${databaseId}`, { method: "PATCH", body: JSON.stringify(body) }, NotionDatabaseResponseSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Users                                                                    */
+    /* ---------------------------------------------------------------------- */
+    /** Retrieves a Notion workspace member or bot by their user ID. */
+    async useGetUser(userId) {
+        return this.useRequest(`/users/${userId}`, {}, NotionUserResponseSchema);
+    }
+    /** Lists all users (members + bots) in the workspace (paginated). */
+    async useListUsers(options) {
+        const params = new URLSearchParams();
+        if (options?.start_cursor)
+            params.set("start_cursor", options.start_cursor);
+        if (options?.page_size)
+            params.set("page_size", String(options.page_size));
+        const qs = params.toString();
+        return this.useRequest(`/users${qs ? `?${qs}` : ""}`, {}, NotionUserListSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Search                                                                   */
+    /* ---------------------------------------------------------------------- */
+    /** Searches across all pages and databases the integration has access to. */
+    async useSearchContent(query) {
+        const parsed = useValidate(NotionSearchQuerySchema, query);
+        if (!parsed.ok) {
+            return { data: null, error: parsed.error, url: "", status: parsed.status, ok: false };
+        }
+        return this.useRequest("/search", { method: "POST", body: JSON.stringify(query) }, NotionSearchResultSchema);
+    }
+    /* ---------------------------------------------------------------------- */
+    /* Pagination Helpers                                                       */
+    /* ---------------------------------------------------------------------- */
+    /**
+     * Fetches ALL child blocks of a block, automatically handling cursor pagination.
+     *
+     * @param blockId - The parent block ID (usually a page ID).
+     * @param maxItems - Cap on the total number of blocks to fetch (default `1000`).
+     * @returns All child blocks as a flat array.
+     */
+    async useListAllBlockChildren(blockId, maxItems = 1000) {
+        const allBlocks = [];
+        let cursor;
+        do {
+            const result = await this.useGetBlockChildren(blockId, {
+                start_cursor: cursor,
+                page_size: 100,
+            });
+            if (!result.ok)
+                return result;
+            allBlocks.push(...result.data.results);
+            if (maxItems && allBlocks.length >= maxItems)
+                break;
+            cursor = result.data.has_more ? (result.data.next_cursor ?? undefined) : undefined;
+        } while (cursor);
+        return {
+            data: allBlocks.slice(0, maxItems),
+            error: null,
+            url: "",
+            status: 200,
+            ok: true,
+        };
+    }
+    /**
+     * Fetches ALL pages in a database, automatically handling cursor pagination.
+     *
+     * @param databaseId - The database UUID.
+     * @param filter - Optional filter to apply (same syntax as Notion API).
+     * @param sorts - Optional sort options.
+     * @param maxItems - Cap on the total number of pages to fetch (default `1000`).
+     * @returns All pages matching the filter as a flat array.
+     */
+    async useListAllDatabasePages(databaseId, filter, sorts, maxItems = 1000) {
+        const allPages = [];
+        let cursor;
+        do {
+            const result = await this.useQueryDatabase(databaseId, {
+                filter,
+                sorts,
+                start_cursor: cursor,
+                page_size: 100,
+            });
+            if (!result.ok)
+                return result;
+            allPages.push(...result.data.results);
+            if (maxItems && allPages.length >= maxItems)
+                break;
+            cursor = result.data.has_more ? (result.data.next_cursor ?? undefined) : undefined;
+        } while (cursor);
         return {
-            data: null,
-            error: { message: status === 0 ? `Network Error: ${message}` : message, status, details },
-            url,
-            status,
-            ok: false,
+            data: allPages.slice(0, maxItems),
+            error: null,
+            url: "",
+            status: 200,
+            ok: true,
         };
     }
-    return { data: attempt.data.data, error: null, url, status: attempt.data.status, ok: true };
 }
 /* -------------------------------------------------------------------------- */
 /* Initialization                                                             */
 /* -------------------------------------------------------------------------- */
 /**
- * Registers the Notion configuration and returns your methods alongside it —
+ * Registers the Notion configuration and returns your methods alongside it -
  * the config-file entry point. One call is the whole setup: no separate
  * `useInitNotion(...)` step.
  *
@@ -130,21 +371,14 @@ export function defineNotionConfig(input) {
  * ```
  */
 export function useInitNotion(cfg) {
-    const parsed = useValidate(NotionConfigSchema, cfg);
-    if (!parsed.ok) {
-        throw new Error("[Notion] Invalid config: " + parsed.error.message);
-    }
-    config = { ...parsed.data };
+    NotionService.getInstance().useInit(cfg);
 }
 /* -------------------------------------------------------------------------- */
-/* Pages                                                                      */
+/* Wrappers (backward compatibility)                                          */
 /* -------------------------------------------------------------------------- */
 /**
  * Retrieves a single Notion page by its ID.
  *
- * Use when you need the full page object including all its properties
- * (title, status, dates, relations, etc.).
- *
  * @param pageId - The page UUID.
  * @returns The page object with all its properties.
  *
@@ -155,77 +389,44 @@ export function useInitNotion(cfg) {
  * ```
  */
 export async function useNotionGetPage(pageId) {
-    return notionFetch(`/pages/${pageId}`, {}, NotionPageResponseSchema);
+    return NotionService.getInstance().useGetPage(pageId);
 }
 /**
  * Creates a new Notion page inside a database or as a child of another page.
  *
- * Use to add new entries to a database (tasks, notes, CRM records) or to
- * create nested page structures.
- *
- * @param parent - Where to create the page: `{ type: "database_id", database_id }`
- *   for database entries, or `{ type: "page_id", page_id }` for child pages.
+ * @param parent - Where to create the page (`database_id` or `page_id`).
  * @param properties - Page properties matching the parent database schema.
  * @param children - Optional block children to populate the page content.
  * @returns The created page.
  *
  * @example
  * ```ts
- * // Add a task to a database
  * const result = await useNotionCreatePage(
  *   { type: "database_id", database_id: "db-id" },
  *   { Name: { title: [{ type: "text", text: { content: "My Task" } }] } },
  * );
- *
- * // Create a child page with content
- * const result = await useNotionCreatePage(
- *   { type: "page_id", page_id: "parent-id" },
- *   { title: { title: [{ type: "text", text: { content: "Child Page" } }] } },
- *   [{ type: "paragraph", paragraph: { rich_text: [{ type: "text", text: { content: "Hello!" } }] } }],
- * );
  * ```
  */
 export async function useNotionCreatePage(parent, properties, children) {
-    // Payload is Record<string, unknown>: no strict shape possible, skip input validation.
-    return notionFetch("/pages", {
-        method: "POST",
-        body: JSON.stringify({ parent, properties, children }),
-    }, NotionPageResponseSchema);
+    return NotionService.getInstance().useCreatePage(parent, properties, children);
 }
 /**
  * Updates properties of an existing Notion page.
  *
- * Use to change a page's status, dates, relations, or any other property
- * without touching the page content (blocks).
- *
  * @param pageId - The page UUID to update.
  * @param properties - Properties to update (only changed properties).
  * @returns The updated page.
  *
  * @example
  * ```ts
- * // Mark a task as done
- * await useNotionUpdatePage("page-id", {
- *   Status: { select: { name: "Done" } },
- * });
- *
- * // Update multiple properties
- * await useNotionUpdatePage("page-id", {
- *   Priority: { select: { name: "High" } },
- *   DueDate: { date: { start: "2025-12-31" } },
- * });
+ * await useNotionUpdatePage("page-id", { Status: { select: { name: "Done" } } });
  * ```
  */
 export async function useNotionUpdatePage(pageId, properties) {
-    // Payload is Record<string, unknown>: no strict shape possible, skip input validation.
-    return notionFetch(`/pages/${pageId}`, {
-        method: "PATCH",
-        body: JSON.stringify({ properties }),
-    }, NotionPageResponseSchema);
+    return NotionService.getInstance().useUpdatePage(pageId, properties);
 }
 /**
- * Archives (soft-deletes) a Notion page. The page becomes hidden but
- * can be restored from Notion's trash.
+ * Archives (soft-deletes) a Notion page.
  *
  * @param pageId - The page UUID to archive.
  * @returns The archived page.
@@ -236,69 +437,40 @@ export async function useNotionUpdatePage(pageId, properties) {
  * ```
  */
 export async function useNotionArchivePage(pageId) {
-    return notionFetch(`/pages/${pageId}`, {
-        method: "PATCH",
-        body: JSON.stringify({ archived: true }),
-    }, NotionPageResponseSchema);
+    return NotionService.getInstance().useArchivePage(pageId);
 }
-/* -------------------------------------------------------------------------- */
-/* Blocks                                                                     */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a single Notion block by its ID.
  *
- * A block is any content element: paragraph, heading, list item, image,
- * table, callout, etc. Use to inspect a specific block's type and content.
- *
  * @param blockId - The block UUID.
  * @returns The block object with its type-specific content.
  *
  * @example
  * ```ts
  * const result = await useNotionGetBlock("block-id");
- * if (result.ok) console.log(result.data.type); // "paragraph", "heading_1", etc.
  * ```
  */
 export async function useNotionGetBlock(blockId) {
-    return notionFetch(`/blocks/${blockId}`, {}, NotionBlockResponseSchema);
+    return NotionService.getInstance().useGetBlock(blockId);
 }
 /**
  * Retrieves the direct children blocks of a block (single page).
  *
- * Use for manual pagination when you need fine-grained control over
- * cursor-based pagination. For most cases, prefer
- * {@link useNotionListAllBlockChildren} which handles pagination automatically.
- *
  * @param blockId - The parent block ID (usually a page ID).
- * @param options - Pagination: `start_cursor` for next page, `page_size` (max 100).
- * @returns Paginated list of child blocks with `has_more` and `next_cursor`.
+ * @param options - Pagination: `start_cursor`, `page_size` (max 100).
+ * @returns Paginated list of child blocks.
  *
  * @example
  * ```ts
  * const result = await useNotionGetBlockChildren("page-id");
- * if (result.ok) {
- *   console.log(result.data.results); // First page of blocks
- *   if (result.data.has_more) {
- *     // Fetch next page with result.data.next_cursor
- *   }
- * }
  * ```
  */
 export async function useNotionGetBlockChildren(blockId, options) {
-    const params = new URLSearchParams();
-    if (options?.start_cursor)
-        params.set("start_cursor", options.start_cursor);
-    if (options?.page_size)
-        params.set("page_size", String(options.page_size));
-    const qs = params.toString();
-    return notionFetch(`/blocks/${blockId}/children${qs ? `?${qs}` : ""}`, {}, NotionBlockListSchema);
+    return NotionService.getInstance().useGetBlockChildren(blockId, options);
 }
 /**
  * Appends new child blocks to a parent block.
  *
- * Use to add content to a page: paragraphs, headings, lists, toggles,
- * code blocks, etc. Blocks are appended at the end.
- *
  * @param blockId - The parent block ID (usually a page ID).
  * @param children - Array of block objects to append.
  * @returns The parent block.
@@ -306,32 +478,18 @@ export async function useNotionGetBlockChildren(blockId, options) {
  * @example
  * ```ts
  * await useNotionAppendBlocks("page-id", [
- *   {
- *     type: "heading_2",
- *     heading_2: { rich_text: [{ type: "text", text: { content: "Section Title" } }] },
- *   },
- *   {
- *     type: "paragraph",
- *     paragraph: { rich_text: [{ type: "text", text: { content: "Body text here." } }] },
- *   },
+ *   { type: "paragraph", paragraph: { rich_text: [{ type: "text", text: { content: "Hi" } }] } },
  * ]);
  * ```
  */
 export async function useNotionAppendBlocks(blockId, children) {
-    // Payload is unknown[]: no strict shape possible, skip input validation.
-    return notionFetch(`/blocks/${blockId}/children`, {
-        method: "PATCH",
-        body: JSON.stringify({ children }),
-    }, NotionBlockResponseSchema);
+    return NotionService.getInstance().useAppendBlocks(blockId, children);
 }
 /**
  * Updates the content of an existing block.
  *
- * Use to modify text, toggle content, code blocks, etc. without
- * deleting and recreating the block.
- *
  * @param blockId - The block UUID to update.
- * @param content - The new content for the block type (e.g. `{ paragraph: { rich_text: [...] } }`).
+ * @param content - The new content for the block type.
  * @returns The updated block.
  *
  * @example
@@ -342,15 +500,10 @@ export async function useNotionAppendBlocks(blockId, children) {
  * ```
  */
 export async function useNotionUpdateBlock(blockId, content) {
-    // Payload is Record<string, unknown>: no strict shape possible, skip input validation.
-    return notionFetch(`/blocks/${blockId}`, {
-        method: "PATCH",
-        body: JSON.stringify(content),
-    }, NotionBlockResponseSchema);
+    return NotionService.getInstance().useUpdateBlock(blockId, content);
 }
 /**
- * Deletes (archives) a Notion block. The block is soft-deleted and
- * can be restored.
+ * Deletes (archives) a Notion block.
  *
  * @param blockId - The block UUID to delete.
  * @returns The deleted block.
@@ -361,81 +514,45 @@ export async function useNotionUpdateBlock(blockId, content) {
  * ```
  */
 export async function useNotionDeleteBlock(blockId) {
-    return notionFetch(`/blocks/${blockId}`, {
-        method: "DELETE",
-    }, NotionBlockResponseSchema);
+    return NotionService.getInstance().useDeleteBlock(blockId);
 }
-/* -------------------------------------------------------------------------- */
-/* Databases                                                                  */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a Notion database schema by its ID.
  *
- * Use to inspect the database structure: property names, types, and
- * configuration (select options, formula definitions, etc.).
- *
  * @param databaseId - The database UUID.
  * @returns The database object with its full property schema.
  *
  * @example
  * ```ts
  * const result = await useNotionGetDatabase("db-id");
- * if (result.ok) {
- *   // See all available properties
- *   Object.entries(result.data.properties).forEach(([name, prop]) => {
- *     console.log(`${name}: ${prop.type}`);
- *   });
- * }
  * ```
  */
 export async function useNotionGetDatabase(databaseId) {
-    return notionFetch(`/databases/${databaseId}`, {}, NotionDatabaseResponseSchema);
+    return NotionService.getInstance().useGetDatabase(databaseId);
 }
 /**
  * Queries a Notion database with filters and sorts (single page).
  *
- * Use for manual pagination or when you only need the first page of
- * results. For most cases, prefer {@link useNotionListAllDatabasePages}
- * which handles pagination automatically.
- *
  * @param databaseId - The database UUID to query.
  * @param query - Filter, sort, and pagination options.
  * @returns Paginated list of pages matching the query.
  *
  * @example
  * ```ts
- * // Get first page of all entries
- * const all = await useNotionQueryDatabase("db-id");
- *
- * // With filter and sort
  * const filtered = await useNotionQueryDatabase("db-id", {
  *   filter: { property: "Status", select: { equals: "Done" } },
- *   sorts: [{ property: "Date", direction: "descending" }],
- *   page_size: 10,
  * });
  * ```
  */
 export async function useNotionQueryDatabase(databaseId, query) {
-    if (query !== undefined) {
-        const parsed = useValidate(NotionDatabaseQuerySchema, query);
-        if (!parsed.ok) {
-            return { data: null, error: parsed.error, url: "", status: parsed.status, ok: false };
-        }
-    }
-    return notionFetch(`/databases/${databaseId}/query`, {
-        method: "POST",
-        body: JSON.stringify(query ?? {}),
-    }, NotionPageListSchema);
+    return NotionService.getInstance().useQueryDatabase(databaseId, query);
 }
 /**
  * Creates a new Notion database inside a page.
  *
- * Use to programmatically create structured databases with custom
- * property schemas (select options, formulas, relations, etc.).
- *
  * @param parent - The parent page (`{ type: "page_id", page_id }`).
  * @param title - Database title as rich text array.
- * @param properties - Property schema definitions (Name, Status, Date, etc.).
+ * @param properties - Property schema definitions.
  * @returns The created database.
  *
  * @example
@@ -443,26 +560,16 @@ export async function useNotionQueryDatabase(databaseId, query) {
  * await useNotionCreateDatabase(
  *   { type: "page_id", page_id: "parent-id" },
  *   [{ type: "text", text: { content: "My Tasks" } }],
- *   {
- *     Name: { title: {} },
- *     Status: { select: { options: [{ name: "To Do" }, { name: "Done" }] } },
- *     Priority: { select: { options: [{ name: "Low" }, { name: "High" }] } },
- *   },
+ *   { Name: { title: {} } },
  * );
  * ```
  */
 export async function useNotionCreateDatabase(parent, title, properties) {
-    // Payload properties are Record<string, NotionPropertySchema>: free-form, skip input validation.
-    return notionFetch("/databases", {
-        method: "POST",
-        body: JSON.stringify({ parent, title, properties }),
-    }, NotionDatabaseResponseSchema);
+    return NotionService.getInstance().useCreateDatabase(parent, title, properties);
 }
 /**
  * Updates a Notion database title and/or property schemas.
  *
- * Use to rename a database or add/modify property definitions.
- *
  * @param databaseId - The database UUID to update.
  * @param title - New title as rich text array.
  * @param properties - Optional property schema updates to merge.
@@ -470,116 +577,57 @@ export async function useNotionCreateDatabase(parent, title, properties) {
  *
  * @example
  * ```ts
- * await useNotionUpdateDatabase("db-id", [
- *   { type: "text", text: { content: "Renamed Database" } },
- * ]);
+ * await useNotionUpdateDatabase("db-id", [{ type: "text", text: { content: "Renamed" } }]);
  * ```
  */
 export async function useNotionUpdateDatabase(databaseId, title, properties) {
-    const body = { title };
-    if (properties)
-        body.properties = properties;
-    // Payload properties are Record<string, NotionPropertySchema>: free-form, skip input validation.
-    return notionFetch(`/databases/${databaseId}`, {
-        method: "PATCH",
-        body: JSON.stringify(body),
-    }, NotionDatabaseResponseSchema);
+    return NotionService.getInstance().useUpdateDatabase(databaseId, title, properties);
 }
-/* -------------------------------------------------------------------------- */
-/* Users                                                                      */
-/* -------------------------------------------------------------------------- */
 /**
  * Retrieves a Notion workspace member or bot by their user ID.
  *
- * Use to get display name, avatar, or email of the person who created
- * or last edited a page.
- *
- * @param userId - The user UUID (from page.created_by.id or page.last_edited_by.id).
+ * @param userId - The user UUID.
  * @returns The user object.
  *
  * @example
  * ```ts
  * const result = await useNotionGetUser("user-id");
- * if (result.ok) console.log(result.data.name);
  * ```
  */
 export async function useNotionGetUser(userId) {
-    return notionFetch(`/users/${userId}`, {}, NotionUserResponseSchema);
+    return NotionService.getInstance().useGetUser(userId);
 }
 /**
  * Lists all users (members + bots) in the workspace (paginated).
  *
- * Use to enumerate workspace members for assignment, mention, or
- * permission checks.
- *
  * @param options - Pagination: `start_cursor`, `page_size` (max 100).
  * @returns Paginated list of users.
  *
  * @example
  * ```ts
  * const result = await useNotionListUsers();
- * if (result.ok) result.data.results.forEach(u => console.log(u.name));
  * ```
  */
 export async function useNotionListUsers(options) {
-    const params = new URLSearchParams();
-    if (options?.start_cursor)
-        params.set("start_cursor", options.start_cursor);
-    if (options?.page_size)
-        params.set("page_size", String(options.page_size));
-    const qs = params.toString();
-    return notionFetch(`/users${qs ? `?${qs}` : ""}`, {}, NotionUserListSchema);
+    return NotionService.getInstance().useListUsers(options);
 }
-/* -------------------------------------------------------------------------- */
-/* Search                                                                     */
-/* -------------------------------------------------------------------------- */
 /**
  * Searches across all pages and databases the integration has access to.
  *
- * Use to find content by keyword when you don't have the page/database ID.
- * Supports filtering by object type (page or database) and sorting by
- * last edit time.
- *
  * @param query - Search options: text query, object type filter, sort direction.
  * @returns Paginated search results (mixed pages and databases).
  *
  * @example
  * ```ts
- * // Search everything for a keyword
  * const result = await useNotionSearchContent({ query: "meeting notes" });
- *
- * // Search only databases
- * const dbs = await useNotionSearchContent({
- *   query: "tasks",
- *   filter: { value: "database", property: "object" },
- * });
- *
- * // Search only pages, sorted by recent
- * const pages = await useNotionSearchContent({
- *   filter: { value: "page", property: "object" },
- *   sort: { direction: "descending", timestamp: "last_edited_time" },
- * });
  * ```
  */
 export async function useNotionSearchContent(query) {
-    const parsed = useValidate(NotionSearchQuerySchema, query);
-    if (!parsed.ok) {
-        return { data: null, error: parsed.error, url: "", status: parsed.status, ok: false };
-    }
-    return notionFetch("/search", {
-        method: "POST",
-        body: JSON.stringify(query),
-    }, NotionSearchResultSchema);
+    return NotionService.getInstance().useSearchContent(query);
 }
-/* -------------------------------------------------------------------------- */
-/* Pagination Helpers                                                         */
-/* -------------------------------------------------------------------------- */
 /**
  * Fetches ALL child blocks of a block, automatically handling cursor pagination.
  *
- * Use when you need the complete content of a page without worrying about
- * pagination cursors. Loops through all pages until `has_more` is false.
- *
  * @param blockId - The parent block ID (usually a page ID).
  * @param maxItems - Cap on the total number of blocks to fetch (default `1000`).
  * @returns All child blocks as a flat array.
@@ -587,42 +635,14 @@ export async function useNotionSearchContent(query) {
  * @example
  * ```ts
  * const result = await useNotionListAllBlockChildren("page-id");
- * if (result.ok) {
- *   console.log(`Total blocks: ${result.data.length}`);
- *   result.data.forEach(block => console.log(block.type));
- * }
  * ```
  */
 export async function useNotionListAllBlockChildren(blockId, maxItems = 1000) {
-    const allBlocks = [];
-    let cursor;
-    do {
-        const result = await useNotionGetBlockChildren(blockId, {
-            start_cursor: cursor,
-            page_size: 100,
-        });
-        if (!result.ok)
-            return result;
-        allBlocks.push(...result.data.results);
-        if (maxItems && allBlocks.length >= maxItems)
-            break;
-        cursor = result.data.has_more ? (result.data.next_cursor ?? undefined) : undefined;
-    } while (cursor);
-    return {
-        data: allBlocks.slice(0, maxItems),
-        error: null,
-        url: "",
-        status: 200,
-        ok: true,
-    };
+    return NotionService.getInstance().useListAllBlockChildren(blockId, maxItems);
 }
 /**
  * Fetches ALL pages in a database, automatically handling cursor pagination.
  *
- * Use when you need every entry from a database without worrying about
- * pagination. Supports optional filters and sorts. Loops through all
- * pages until `has_more` is false.
- *
  * @param databaseId - The database UUID.
  * @param filter - Optional filter to apply (same syntax as Notion API).
  * @param sorts - Optional sort options.
@@ -631,41 +651,10 @@ export async function useNotionListAllBlockChildren(blockId, maxItems = 1000) {
  *
  * @example
  * ```ts
- * // Get ALL pages in a database
  * const result = await useNotionListAllDatabasePages("db-id");
- * if (result.ok) console.log(`Total entries: ${result.data.length}`);
- *
- * // Get only published pages, sorted by date
- * const published = await useNotionListAllDatabasePages(
- *   "db-id",
- *   { property: "Status", select: { equals: "Published" } },
- *   [{ property: "Date", direction: "descending" }],
- * );
  * ```
  */
 export async function useNotionListAllDatabasePages(databaseId, filter, sorts, maxItems = 1000) {
-    const allPages = [];
-    let cursor;
-    do {
-        const result = await useNotionQueryDatabase(databaseId, {
-            filter,
-            sorts,
-            start_cursor: cursor,
-            page_size: 100,
-        });
-        if (!result.ok)
-            return result;
-        allPages.push(...result.data.results);
-        if (maxItems && allPages.length >= maxItems)
-            break;
-        cursor = result.data.has_more ? (result.data.next_cursor ?? undefined) : undefined;
-    } while (cursor);
-    return {
-        data: allPages.slice(0, maxItems),
-        error: null,
-        url: "",
-        status: 200,
-        ok: true,
-    };
+    return NotionService.getInstance().useListAllDatabasePages(databaseId, filter, sorts, maxItems);
 }
 //# sourceMappingURL=notion.service.js.map