@hesed/conni 0.1.0

package/dist/conni/conni-api.d.ts

@@ -0,0 +1,88 @@
+import { ConfluenceClient } from 'confluence.js';
+/**
+ * Generic API result
+ */
+export interface ApiResult {
+    data?: unknown;
+    error?: unknown;
+    success: boolean;
+}
+export interface Config {
+    apiToken: string;
+    email: string;
+    host: string;
+}
+export interface ConniError {
+    data: unknown;
+    message: string;
+    statusCode: string;
+}
+/**
+ * Confluence API Utility
+ * Provides core Confluence API operations
+ */
+export declare class ConniApi {
+    private client?;
+    private config;
+    constructor(config: Config);
+    /**
+     * Add an attachment to a page
+     */
+    addAttachment(pageId: string, filePath: string): Promise<ApiResult>;
+    /**
+     * Add a comment to a page
+     */
+    addComment(pageId: string, body: string): Promise<ApiResult>;
+    /**
+     * Clear client (for cleanup)
+     */
+    clearClients(): void;
+    /**
+     * Create a new page
+     */
+    createPage(fields: Record<string, unknown>): Promise<ApiResult>;
+    /**
+     * Delete a comment from a page
+     */
+    deleteComment(id: string): Promise<ApiResult>;
+    /**
+     * Delete a page
+     */
+    deleteContent(pageId: string): Promise<ApiResult>;
+    /**
+     * Download attachment from a page
+     */
+    downloadAttachment(attachmentId: string, outputPath?: string): Promise<ApiResult>;
+    /**
+     * Get or create Confluence client
+     */
+    getClient(): ConfluenceClient;
+    /**
+     * Get page details
+     */
+    getContent(pageId: string): Promise<ApiResult>;
+    /**
+     * Get space details
+     */
+    getSpace(spaceKey: string): Promise<ApiResult>;
+    /**
+     * List all spaces
+     */
+    listSpaces(): Promise<ApiResult>;
+    /**
+     * Search pages using CQL
+     */
+    searchContents(cql: string, limit?: number, expand?: string[]): Promise<ApiResult>;
+    /**
+     * Test Confluence API connection
+     */
+    testConnection(): Promise<ApiResult>;
+    /**
+     * Update a comment on a page
+     */
+    updateComment(commentId: string, body: string): Promise<ApiResult>;
+    /**
+     * Update an existing page
+     */
+    updateContent(pageId: string, fields: Record<string, unknown>): Promise<ApiResult>;
+}

package/dist/conni/conni-api.js

@@ -0,0 +1,447 @@
+import { ConfluenceClient } from 'confluence.js';
+import fs from 'fs-extra';
+import { markdownToAdf } from 'marklassian';
+import path from 'node:path';
+/**
+ * Confluence API Utility
+ * Provides core Confluence API operations
+ */
+export class ConniApi {
+    client;
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Add an attachment to a page
+     */
+    async addAttachment(pageId, filePath) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                return {
+                    error: `File not found: ${filePath}`,
+                    success: false,
+                };
+            }
+            const stats = fs.statSync(filePath);
+            const maxFileSizeBytes = 10 * 1024 * 1024; // 10MB
+            if (stats.size > maxFileSizeBytes) {
+                return {
+                    error: `File size (${(stats.size / 1024 / 1024).toFixed(2)}MB) exceeds the 10MB limit`,
+                    success: false,
+                };
+            }
+            const client = this.getClient();
+            const fileContent = fs.readFileSync(filePath);
+            const fileName = path.basename(filePath);
+            const response = await client.contentAttachments.createAttachments({
+                attachments: [
+                    {
+                        file: fileContent,
+                        filename: fileName,
+                        minorEdit: false,
+                    },
+                ],
+                id: pageId,
+            });
+            return {
+                data: response,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Add a comment to a page
+     */
+    async addComment(pageId, body) {
+        try {
+            const client = this.getClient();
+            // Convert Markdown body to Confluence ADF
+            // eslint-disable-next-line unicorn/prefer-string-replace-all
+            const bodyContent = markdownToAdf(body.replace(/\\n/g, '\n'));
+            const response = await client.content.createContent({
+                body: {
+                    storage: {
+                        representation: 'atlas_doc_format',
+                        value: JSON.stringify(bodyContent),
+                    },
+                },
+                container: {
+                    id: pageId,
+                    type: 'page',
+                },
+                space: { key: '' },
+                title: '',
+                type: 'comment',
+            });
+            return {
+                data: response,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Clear client (for cleanup)
+     */
+    clearClients() {
+        this.client = undefined;
+    }
+    /**
+     * Create a new page
+     */
+    async createPage(fields) {
+        try {
+            const client = this.getClient();
+            // Convert Markdown body to Confluence ADF
+            // eslint-disable-next-line unicorn/prefer-string-replace-all
+            const bodyContent = markdownToAdf(fields.body.replace(/\\n/g, '\n'));
+            const spaceKey = fields.spaceKey;
+            const title = fields.title;
+            const parentId = fields.parentId;
+            const status = fields.status;
+            const contentBody = {
+                body: {
+                    storage: {
+                        representation: 'atlas_doc_format',
+                        value: JSON.stringify(bodyContent),
+                    },
+                },
+                parentId,
+                space: { key: spaceKey },
+                status,
+                title,
+                type: 'page',
+            };
+            const response = await client.content.createContent(contentBody);
+            return {
+                data: response,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Delete a comment from a page
+     */
+    async deleteComment(id) {
+        try {
+            const client = this.getClient();
+            await client.content.deleteContent({ id });
+            return {
+                data: true,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Delete a page
+     */
+    async deleteContent(pageId) {
+        try {
+            const client = this.getClient();
+            await client.content.deleteContent({ id: pageId });
+            return {
+                data: true,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Download attachment from a page
+     */
+    async downloadAttachment(attachmentId, outputPath) {
+        try {
+            const client = this.getClient();
+            // Get attachment metadata
+            const attachment = await client.content.getContentById({
+                expand: ['container', 'metadata.mediaType', 'version'],
+                id: attachmentId,
+            });
+            const fileName = attachment.title || 'download';
+            const mediaType = attachment.metadata?.mediaType || 'application/octet-stream';
+            const containerId = attachment.container?.id;
+            if (!containerId) {
+                return {
+                    error: `Attachment ${attachmentId} has no parent content`,
+                    success: false,
+                };
+            }
+            const buffer = await client.contentAttachments.downloadAttachment({
+                attachmentId,
+                id: containerId,
+            });
+            const finalPath = outputPath || path.join(process.cwd(), fileName);
+            fs.writeFileSync(finalPath, buffer);
+            return {
+                data: {
+                    attachmentId,
+                    filename: fileName,
+                    mimeType: mediaType,
+                    savedTo: finalPath,
+                    size: buffer.length,
+                },
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Get or create Confluence client
+     */
+    getClient() {
+        if (this.client) {
+            return this.client;
+        }
+        this.client = new ConfluenceClient({
+            authentication: {
+                basic: {
+                    apiToken: this.config.apiToken,
+                    email: this.config.email,
+                },
+            },
+            host: this.config.host,
+        });
+        return this.client;
+    }
+    /**
+     * Get page details
+     */
+    async getContent(pageId) {
+        try {
+            const client = this.getClient();
+            const page = await client.content.getContentById({
+                expand: ['body.storage', 'children.attachment', 'children.comment', 'space', 'version'],
+                id: pageId,
+            });
+            return {
+                data: page,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Get space details
+     */
+    async getSpace(spaceKey) {
+        try {
+            const client = this.getClient();
+            const space = await client.space.getSpace({ spaceKey });
+            return {
+                data: space,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * List all spaces
+     */
+    async listSpaces() {
+        try {
+            const client = this.getClient();
+            const response = await client.space.getSpaces();
+            const spaces = response.results || [];
+            const simplifiedSpaces = spaces.map((s) => ({
+                id: String(s.id),
+                key: s.key,
+                name: s.name,
+                type: s.type,
+            }));
+            return {
+                data: simplifiedSpaces,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Search pages using CQL
+     */
+    async searchContents(cql, limit = 10, expand) {
+        try {
+            const client = this.getClient();
+            const response = await client.content.searchContentByCQL({
+                cql,
+                expand,
+                limit,
+            });
+            return {
+                data: response,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Test Confluence API connection
+     */
+    async testConnection() {
+        try {
+            const client = this.getClient();
+            const currentUser = await client.users.getCurrentUser();
+            return {
+                data: { currentUser, serverInfo: {} },
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                error: typeof error === 'object' ? String(error.message) : String(error),
+                success: false,
+            };
+        }
+    }
+    /**
+     * Update a comment on a page
+     */
+    async updateComment(commentId, body) {
+        try {
+            const client = this.getClient();
+            // Convert Markdown body to Confluence ADF
+            // eslint-disable-next-line unicorn/prefer-string-replace-all
+            const bodyContent = markdownToAdf(body.replace(/\\n/g, '\n'));
+            // Get current comment to find its version
+            const comment = await client.content.getContentById({
+                expand: ['version'],
+                id: commentId,
+            });
+            const currentVersion = (comment.version?.number ?? 0) + 1;
+            const response = await client.content.updateContent({
+                body: {
+                    storage: {
+                        representation: 'atlas_doc_format',
+                        value: JSON.stringify(bodyContent),
+                    },
+                },
+                id: commentId,
+                title: '',
+                type: 'comment',
+                version: {
+                    number: currentVersion,
+                },
+            });
+            return {
+                data: response,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+    /**
+     * Update an existing page
+     */
+    async updateContent(pageId, fields) {
+        try {
+            const client = this.getClient();
+            // Get current page to find its version
+            const page = await client.content.getContentById({
+                expand: ['version'],
+                id: pageId,
+            });
+            const currentVersion = (page.version?.number ?? 0) + 1;
+            const title = fields.title ?? page.title ?? '';
+            const body = fields.body;
+            const response = await client.content.updateContent({
+                id: pageId,
+                type: 'page',
+                ...(body === undefined
+                    ? {}
+                    : {
+                        body: {
+                            storage: {
+                                representation: 'atlas_doc_format',
+                                // eslint-disable-next-line unicorn/prefer-string-replace-all
+                                value: JSON.stringify(markdownToAdf(body.replace(/\\n/g, '\n'))),
+                            },
+                        },
+                    }),
+                title,
+                version: {
+                    number: currentVersion,
+                },
+            });
+            return {
+                data: response,
+                success: true,
+            };
+        }
+        catch (error) {
+            const errorMessage = typeof error === 'object' ? String(error.message) : String(error);
+            return {
+                error: errorMessage,
+                success: false,
+            };
+        }
+    }
+}

package/dist/conni/conni-client.d.ts

@@ -0,0 +1,88 @@
+import type { ApiResult, Config } from './conni-api.js';
+/**
+ * List all spaces
+ * @param config - Confluence configuration
+ */
+export declare function listSpaces(config: Config): Promise<ApiResult>;
+/**
+ * Get space details
+ * @param config - Confluence configuration
+ * @param spaceKey - Space key
+ */
+export declare function getSpace(config: Config, spaceKey: string): Promise<ApiResult>;
+/**
+ * Search pages using CQL
+ * @param config - Confluence configuration
+ * @param cql - CQL query string
+ * @param limit - Maximum number of contents per page
+ * @param expand - Properties of the content to expand
+ */
+export declare function searchContents(config: Config, cql: string, limit?: number, expand?: string[]): Promise<ApiResult>;
+/**
+ * Get page details
+ * @param config - Confluence configuration
+ * @param pageId - Page ID
+ */
+export declare function getContent(config: Config, pageId: string): Promise<ApiResult>;
+/**
+ * Create a new page
+ * @param config - Confluence configuration
+ * @param fields - Page fields (spaceKey, title, body, parentId)
+ */
+export declare function createPage(config: Config, fields: Record<string, unknown>): Promise<ApiResult>;
+/**
+ * Update an existing page
+ * @param config - Confluence configuration
+ * @param pageId - Page ID
+ * @param fields - Page fields to update (title, body)
+ */
+export declare function updateContent(config: Config, pageId: string, fields: Record<string, unknown>): Promise<ApiResult>;
+/**
+ * Add an attachment to a page
+ * @param config - Confluence configuration
+ * @param pageId - Page ID
+ * @param filePath - Path to the file to upload
+ */
+export declare function addAttachment(config: Config, pageId: string, filePath: string): Promise<ApiResult>;
+/**
+ * Add a comment to a page
+ * @param config - Confluence configuration
+ * @param pageId - Page ID
+ * @param body - Comment body
+ */
+export declare function addComment(config: Config, pageId: string, body: string): Promise<ApiResult>;
+/**
+ * Delete a comment from a page
+ * @param config - Confluence configuration
+ * @param id - Comment ID
+ */
+export declare function deleteComment(config: Config, id: string): Promise<ApiResult>;
+/**
+ * Update a comment on a page
+ * @param config - Confluence configuration
+ * @param id - Comment ID
+ * @param body - Comment body
+ */
+export declare function updateComment(config: Config, id: string, body: string): Promise<ApiResult>;
+/**
+ * Delete a page
+ * @param config - Confluence configuration
+ * @param pageId - Page ID
+ */
+export declare function deleteContent(config: Config, pageId: string): Promise<ApiResult>;
+/**
+ * Test Confluence API connection
+ * @param config - Confluence configuration
+ */
+export declare function testConnection(config: Config): Promise<ApiResult>;
+/**
+ * Clear clients (for cleanup)
+ */
+export declare function clearClients(): void;
+/**
+ * Download attachment from a page
+ * @param config - Confluence configuration
+ * @param attachmentId - Attachment ID
+ * @param outputPath - Output file path (optional)
+ */
+export declare function downloadAttachment(config: Config, attachmentId: string, outputPath?: string): Promise<ApiResult>;