@knpkv/confluence-to-markdown 0.2.0 → 0.4.1

package/test/schemas/nodes/block/BlockSchema.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, it } from "@effect/vitest"
+import type { UnsupportedBlock } from "../../../../src/ast/BlockNode.js"
+import {
+  CodeBlock,
+  Heading,
+  Paragraph,
+  Table,
+  TableCell,
+  TableRow,
+  ThematicBreak
+} from "../../../../src/ast/BlockNode.js"
+import { Text } from "../../../../src/ast/InlineNode.js"
+import { makeMdastHeading, makeMdastParagraph, makeMdastText } from "../../../../src/schemas/mdast/index.js"
+import { blockNodeFromMdast, blockNodeToHast, blockNodeToMdast } from "../../../../src/schemas/nodes/block/index.js"
+
+describe("BlockSchema", () => {
+  describe("blockNodeToHast", () => {
+    it("converts Heading to hast h element", () => {
+      const heading = new Heading({ level: 2, children: [new Text({ value: "Title" })] })
+      const result = blockNodeToHast(heading)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("h2")
+    })
+
+    it("converts Paragraph to hast p element", () => {
+      const para = new Paragraph({ children: [new Text({ value: "Hello" })] })
+      const result = blockNodeToHast(para)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("p")
+    })
+
+    it("converts CodeBlock to hast pre/code elements", () => {
+      const code = new CodeBlock({ code: "const x = 1", language: "ts" })
+      const result = blockNodeToHast(code)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("pre")
+      expect(result.properties?.dataLanguage).toBe("ts")
+    })
+
+    it("converts ThematicBreak to hast hr element", () => {
+      const hr = new ThematicBreak({})
+      const result = blockNodeToHast(hr)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("hr")
+    })
+
+    it("converts Table to hast table element", () => {
+      const table = new Table({
+        header: new TableRow({
+          cells: [new TableCell({ isHeader: true, children: [new Text({ value: "Col" })] })]
+        }),
+        rows: [
+          new TableRow({
+            cells: [new TableCell({ children: [new Text({ value: "Val" })] })]
+          })
+        ]
+      })
+      const result = blockNodeToHast(table)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("table")
+    })
+  })
+
+  describe("blockNodeToMdast", () => {
+    it("converts Heading to mdast heading", () => {
+      const heading = new Heading({ level: 1, children: [new Text({ value: "Title" })] })
+      const result = blockNodeToMdast(heading)
+      expect(result.type).toBe("heading")
+    })
+
+    it("converts Paragraph to mdast paragraph", () => {
+      const para = new Paragraph({ children: [new Text({ value: "Hello" })] })
+      const result = blockNodeToMdast(para)
+      expect(result.type).toBe("paragraph")
+    })
+
+    it("converts CodeBlock to mdast code", () => {
+      const code = new CodeBlock({ code: "const x = 1", language: "ts" })
+      const result = blockNodeToMdast(code)
+      expect(result.type).toBe("code")
+      expect((result as { value: string }).value).toBe("const x = 1")
+    })
+
+    it("converts ThematicBreak to mdast thematicBreak", () => {
+      const hr = new ThematicBreak({})
+      const result = blockNodeToMdast(hr)
+      expect(result.type).toBe("thematicBreak")
+    })
+
+    it("converts Table to mdast table", () => {
+      const table = new Table({ rows: [] })
+      const result = blockNodeToMdast(table)
+      expect(result.type).toBe("table")
+    })
+  })
+
+  describe("blockNodeFromMdast", () => {
+    it("converts mdast heading to Heading", () => {
+      const mdast = makeMdastHeading(2, [makeMdastText("Title")])
+      const result = blockNodeFromMdast(mdast)
+      expect(result._tag).toBe("Heading")
+      expect((result as Heading).level).toBe(2)
+    })
+
+    it("converts mdast paragraph to Paragraph", () => {
+      const mdast = makeMdastParagraph([makeMdastText("Hello")])
+      const result = blockNodeFromMdast(mdast)
+      expect(result._tag).toBe("Paragraph")
+    })
+
+    it("converts mdast code to CodeBlock", () => {
+      const mdast = { type: "code" as const, value: "const x = 1", lang: "ts" }
+      const result = blockNodeFromMdast(mdast)
+      expect(result._tag).toBe("CodeBlock")
+      expect((result as CodeBlock).code).toBe("const x = 1")
+      expect((result as CodeBlock).language).toBe("ts")
+    })
+
+    it("converts mdast thematicBreak to ThematicBreak", () => {
+      const mdast = { type: "thematicBreak" as const }
+      const result = blockNodeFromMdast(mdast)
+      expect(result._tag).toBe("ThematicBreak")
+    })
+
+    it("converts mdast blockquote to BlockQuote", () => {
+      const mdast = {
+        type: "blockquote" as const,
+        children: [makeMdastParagraph([makeMdastText("Quote")])]
+      }
+      const result = blockNodeFromMdast(mdast)
+      expect(result._tag).toBe("BlockQuote")
+    })
+
+    it("converts mdast list to List", () => {
+      const mdast = {
+        type: "list" as const,
+        ordered: true,
+        children: [{
+          type: "listItem" as const,
+          children: [makeMdastParagraph([makeMdastText("Item")])]
+        }]
+      }
+      const result = blockNodeFromMdast(mdast)
+      expect(result._tag).toBe("List")
+    })
+
+    it("converts mdast html to UnsupportedBlock", () => {
+      const mdast = { type: "html" as const, value: "<custom>x</custom>" }
+      const result = blockNodeFromMdast(mdast)
+      expect(result._tag).toBe("UnsupportedBlock")
+      expect((result as UnsupportedBlock).rawMarkdown).toBe("<custom>x</custom>")
+    })
+  })
+
+  describe("roundtrip", () => {
+    it("Heading roundtrips through MDAST", () => {
+      const original = new Heading({ level: 3, children: [new Text({ value: "Title" })] })
+      const mdast = blockNodeToMdast(original)
+      const result = blockNodeFromMdast(mdast)
+      expect(result._tag).toBe("Heading")
+      expect((result as Heading).level).toBe(3)
+    })
+
+    it("CodeBlock roundtrips through MDAST", () => {
+      const original = new CodeBlock({ code: "x = 1", language: "py" })
+      const mdast = blockNodeToMdast(original)
+      const result = blockNodeFromMdast(mdast)
+      expect(result._tag).toBe("CodeBlock")
+      expect((result as CodeBlock).code).toBe("x = 1")
+      expect((result as CodeBlock).language).toBe("py")
+    })
+  })
+})

package/test/schemas/nodes/inline/InlineSchema.test.ts

@@ -0,0 +1,198 @@
+import { describe, expect, it } from "@effect/vitest"
+import type { UnsupportedInline } from "../../../../src/ast/InlineNode.js"
+import { Emphasis, InlineCode, LineBreak, Link, Strong, Text } from "../../../../src/ast/InlineNode.js"
+import { makeHastText } from "../../../../src/schemas/hast/index.js"
+import { makeMdastText } from "../../../../src/schemas/mdast/index.js"
+import {
+  inlineNodeFromMdast,
+  inlineNodeToHast,
+  inlineNodeToMdast,
+  textFromHastText
+} from "../../../../src/schemas/nodes/inline/index.js"
+
+describe("InlineSchema", () => {
+  describe("textFromHastText", () => {
+    it("converts hast text to Text node", () => {
+      const hastText = makeHastText("hello")
+      const result = textFromHastText(hastText)
+      expect(result._tag).toBe("Text")
+      expect(result.value).toBe("hello")
+    })
+  })
+
+  describe("inlineNodeToHast", () => {
+    it("converts Text to hast text", () => {
+      const text = new Text({ value: "hello" })
+      const result = inlineNodeToHast(text)
+      expect(result._tag).toBe("text")
+      expect((result as { value: string }).value).toBe("hello")
+    })
+
+    it("converts Strong to hast strong", () => {
+      const strong = new Strong({ children: [new Text({ value: "bold" })] })
+      const result = inlineNodeToHast(strong)
+      expect(result._tag).toBe("element")
+      expect((result as { tagName: string }).tagName).toBe("strong")
+    })
+
+    it("converts Emphasis to hast em", () => {
+      const emphasis = new Emphasis({ children: [new Text({ value: "italic" })] })
+      const result = inlineNodeToHast(emphasis)
+      expect(result._tag).toBe("element")
+      expect((result as { tagName: string }).tagName).toBe("em")
+    })
+
+    it("converts InlineCode to hast code", () => {
+      const code = new InlineCode({ value: "const x = 1" })
+      const result = inlineNodeToHast(code)
+      expect(result._tag).toBe("element")
+      expect((result as { tagName: string }).tagName).toBe("code")
+    })
+
+    it("converts Link to hast anchor", () => {
+      const link = new Link({
+        href: "https://example.com",
+        title: "Example",
+        children: [new Text({ value: "click" })]
+      })
+      const result = inlineNodeToHast(link)
+      expect(result._tag).toBe("element")
+      expect((result as { tagName: string }).tagName).toBe("a")
+    })
+
+    it("converts LineBreak to hast br", () => {
+      const br = new LineBreak({})
+      const result = inlineNodeToHast(br)
+      expect(result._tag).toBe("element")
+      expect((result as { tagName: string }).tagName).toBe("br")
+    })
+  })
+
+  describe("inlineNodeToMdast", () => {
+    it("converts Text to mdast text", () => {
+      const text = new Text({ value: "hello" })
+      const result = inlineNodeToMdast(text)
+      expect(result.type).toBe("text")
+      expect((result as { value: string }).value).toBe("hello")
+    })
+
+    it("converts Strong to mdast strong", () => {
+      const strong = new Strong({ children: [new Text({ value: "bold" })] })
+      const result = inlineNodeToMdast(strong)
+      expect(result.type).toBe("strong")
+    })
+
+    it("converts Emphasis to mdast emphasis", () => {
+      const emphasis = new Emphasis({ children: [new Text({ value: "italic" })] })
+      const result = inlineNodeToMdast(emphasis)
+      expect(result.type).toBe("emphasis")
+    })
+
+    it("converts InlineCode to mdast inlineCode", () => {
+      const code = new InlineCode({ value: "x" })
+      const result = inlineNodeToMdast(code)
+      expect(result.type).toBe("inlineCode")
+      expect((result as { value: string }).value).toBe("x")
+    })
+
+    it("converts Link to mdast link", () => {
+      const link = new Link({
+        href: "https://example.com",
+        children: [new Text({ value: "click" })]
+      })
+      const result = inlineNodeToMdast(link)
+      expect(result.type).toBe("link")
+      expect((result as { url: string }).url).toBe("https://example.com")
+    })
+
+    it("converts LineBreak to mdast break", () => {
+      const br = new LineBreak({})
+      const result = inlineNodeToMdast(br)
+      expect(result.type).toBe("break")
+    })
+  })
+
+  describe("inlineNodeFromMdast", () => {
+    it("converts mdast text to Text", () => {
+      const mdast = makeMdastText("hello")
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("Text")
+      expect((result as Text).value).toBe("hello")
+    })
+
+    it("converts mdast strong to Strong", () => {
+      const mdast = { type: "strong" as const, children: [makeMdastText("bold")] }
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("Strong")
+    })
+
+    it("converts mdast emphasis to Emphasis", () => {
+      const mdast = { type: "emphasis" as const, children: [makeMdastText("italic")] }
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("Emphasis")
+    })
+
+    it("converts mdast inlineCode to InlineCode", () => {
+      const mdast = { type: "inlineCode" as const, value: "x" }
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("InlineCode")
+      expect((result as InlineCode).value).toBe("x")
+    })
+
+    it("converts mdast link to Link", () => {
+      const mdast = {
+        type: "link" as const,
+        url: "https://example.com",
+        title: null,
+        children: [makeMdastText("click")]
+      }
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("Link")
+      expect((result as Link).href).toBe("https://example.com")
+    })
+
+    it("converts mdast break to LineBreak", () => {
+      const mdast = { type: "break" as const }
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("LineBreak")
+    })
+
+    it("converts mdast delete to Strikethrough", () => {
+      const mdast = { type: "delete" as const, children: [makeMdastText("deleted")] }
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("Strikethrough")
+    })
+
+    it("converts mdast html to UnsupportedInline", () => {
+      const mdast = { type: "html" as const, value: "<custom>x</custom>" }
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("UnsupportedInline")
+      expect((result as UnsupportedInline).raw).toBe("<custom>x</custom>")
+    })
+  })
+
+  describe("roundtrip", () => {
+    it("Text roundtrips through MDAST", () => {
+      const original = new Text({ value: "hello" })
+      const mdast = inlineNodeToMdast(original)
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("Text")
+      expect((result as Text).value).toBe("hello")
+    })
+
+    it("Strong roundtrips through MDAST", () => {
+      const original = new Strong({ children: [new Text({ value: "bold" })] })
+      const mdast = inlineNodeToMdast(original)
+      const result = inlineNodeFromMdast(mdast)
+      expect(result._tag).toBe("Strong")
+    })
+
+    it("Text roundtrips through HAST", () => {
+      const original = new Text({ value: "hello" })
+      const hast = inlineNodeToHast(original)
+      const result = textFromHastText(hast as { _tag: "text"; value: string })
+      expect(result._tag).toBe("Text")
+      expect(result.value).toBe("hello")
+    })
+  })
+})

package/test/schemas/nodes/macro/MacroSchema.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Paragraph } from "../../../../src/ast/BlockNode.js"
+import { Text } from "../../../../src/ast/InlineNode.js"
+import type { CodeMacro, ExpandMacro, InfoPanel, StatusMacro, TocMacro } from "../../../../src/ast/MacroNode.js"
+import { macroNodeToHast, macroNodeToMdast } from "../../../../src/schemas/nodes/macro/index.js"
+
+describe("MacroSchema", () => {
+  describe("macroNodeToHast", () => {
+    it("converts InfoPanel to hast div with data attributes", () => {
+      const panel: InfoPanel = {
+        _tag: "InfoPanel",
+        version: 1,
+        panelType: "warning",
+        title: "Important",
+        children: [new Paragraph({ children: [new Text({ value: "Content" })] })]
+      }
+      const result = macroNodeToHast(panel)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("div")
+      expect(result.properties?.dataMacro).toBe("warning")
+      expect(result.properties?.dataTitle).toBe("Important")
+    })
+
+    it("converts ExpandMacro to hast details element", () => {
+      const expand: ExpandMacro = {
+        _tag: "ExpandMacro",
+        version: 1,
+        title: "Click to expand",
+        children: [new Paragraph({ children: [new Text({ value: "Hidden" })] })]
+      }
+      const result = macroNodeToHast(expand)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("details")
+    })
+
+    it("converts TocMacro to hast nav element", () => {
+      const toc: TocMacro = {
+        _tag: "TocMacro",
+        version: 1,
+        minLevel: 2,
+        maxLevel: 4
+      }
+      const result = macroNodeToHast(toc)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("nav")
+      expect(result.properties?.dataMacro).toBe("toc")
+      expect(result.properties?.dataMin).toBe("2")
+      expect(result.properties?.dataMax).toBe("4")
+    })
+
+    it("converts CodeMacro to hast pre/code elements", () => {
+      const code: CodeMacro = {
+        _tag: "CodeMacro",
+        version: 1,
+        language: "typescript",
+        code: "const x = 1",
+        lineNumbers: false,
+        collapse: false
+      }
+      const result = macroNodeToHast(code)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("pre")
+      expect(result.properties?.dataLanguage).toBe("typescript")
+    })
+
+    it("converts StatusMacro to hast span element", () => {
+      const status: StatusMacro = {
+        _tag: "StatusMacro",
+        version: 1,
+        text: "Done",
+        color: "Green"
+      }
+      const result = macroNodeToHast(status)
+      expect(result._tag).toBe("element")
+      expect(result.tagName).toBe("span")
+      expect(result.properties?.dataMacro).toBe("status")
+      expect(result.properties?.dataColor).toBe("Green")
+    })
+  })
+
+  describe("macroNodeToMdast", () => {
+    it("converts InfoPanel to mdast html with container syntax", () => {
+      const panel: InfoPanel = {
+        _tag: "InfoPanel",
+        version: 1,
+        panelType: "info",
+        children: [new Paragraph({ children: [new Text({ value: "Note content" })] })]
+      }
+      const result = macroNodeToMdast(panel)
+      expect(result.type).toBe("html")
+      expect((result as { value: string }).value).toContain(":::info")
+    })
+
+    it("converts ExpandMacro to mdast html with details element", () => {
+      const expand: ExpandMacro = {
+        _tag: "ExpandMacro",
+        version: 1,
+        title: "More info",
+        children: []
+      }
+      const result = macroNodeToMdast(expand)
+      expect(result.type).toBe("html")
+      expect((result as { value: string }).value).toContain("<details>")
+      expect((result as { value: string }).value).toContain("More info")
+    })
+
+    it("converts TocMacro to mdast html with toc marker", () => {
+      const toc: TocMacro = {
+        _tag: "TocMacro",
+        version: 1
+      }
+      const result = macroNodeToMdast(toc)
+      expect(result.type).toBe("html")
+      expect((result as { value: string }).value).toBe("[[toc]]")
+    })
+
+    it("converts CodeMacro to mdast code", () => {
+      const code: CodeMacro = {
+        _tag: "CodeMacro",
+        version: 1,
+        language: "py",
+        code: "print(1)",
+        lineNumbers: false,
+        collapse: false
+      }
+      const result = macroNodeToMdast(code)
+      expect(result.type).toBe("code")
+      expect((result as { value: string }).value).toBe("print(1)")
+    })
+
+    it("converts StatusMacro to mdast paragraph with badge text", () => {
+      const status: StatusMacro = {
+        _tag: "StatusMacro",
+        version: 1,
+        text: "In Progress",
+        color: "Blue"
+      }
+      const result = macroNodeToMdast(status)
+      expect(result.type).toBe("paragraph")
+    })
+  })
+})

package/test/tokenStorage.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Either from "effect/Either"
+import * as Schema from "effect/Schema"
+import { OAuthConfigSchema, OAuthTokenSchema } from "../src/Schemas.js"
+
+/**
+ * Tests for OAuth schema validation used by tokenStorage.
+ * Full integration tests for file operations would require mocking the filesystem.
+ */
+describe("tokenStorage schemas", () => {
+  describe("OAuthTokenSchema", () => {
+    it("validates complete token", () => {
+      const token = {
+        access_token: "test_access_token",
+        refresh_token: "test_refresh_token",
+        expires_at: Date.now() + 3600000,
+        scope: "read:confluence-content.all",
+        cloud_id: "test_cloud_id",
+        site_url: "https://test.atlassian.net"
+      }
+      const result = Schema.decodeUnknownEither(OAuthTokenSchema)(token)
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("validates token with user info", () => {
+      const token = {
+        access_token: "test_access_token",
+        refresh_token: "test_refresh_token",
+        expires_at: Date.now() + 3600000,
+        scope: "read:confluence-content.all",
+        cloud_id: "test_cloud_id",
+        site_url: "https://test.atlassian.net",
+        user: {
+          account_id: "user123",
+          name: "Test User",
+          email: "test@example.com"
+        }
+      }
+      const result = Schema.decodeUnknownEither(OAuthTokenSchema)(token)
+      expect(Either.isRight(result)).toBe(true)
+      if (Either.isRight(result)) {
+        expect(result.right.user?.name).toBe("Test User")
+      }
+    })
+
+    it("rejects token missing required field", () => {
+      const token = {
+        access_token: "test",
+        // missing refresh_token
+        expires_at: Date.now(),
+        scope: "test",
+        cloud_id: "test",
+        site_url: "https://test.atlassian.net"
+      }
+      const result = Schema.decodeUnknownEither(OAuthTokenSchema)(token)
+      expect(Either.isLeft(result)).toBe(true)
+    })
+
+    it("rejects token with invalid expires_at type", () => {
+      const token = {
+        access_token: "test",
+        refresh_token: "test",
+        expires_at: "not a number",
+        scope: "test",
+        cloud_id: "test",
+        site_url: "https://test.atlassian.net"
+      }
+      const result = Schema.decodeUnknownEither(OAuthTokenSchema)(token)
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+
+  describe("OAuthConfigSchema", () => {
+    it("validates complete config", () => {
+      const config = {
+        clientId: "test_client_id",
+        clientSecret: "test_client_secret"
+      }
+      const result = Schema.decodeUnknownEither(OAuthConfigSchema)(config)
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("rejects config missing clientSecret", () => {
+      const config = {
+        clientId: "test_client_id"
+      }
+      const result = Schema.decodeUnknownEither(OAuthConfigSchema)(config)
+      expect(Either.isLeft(result)).toBe(true)
+    })
+
+    it("rejects config missing clientId", () => {
+      const config = {
+        clientSecret: "test_client_secret"
+      }
+      const result = Schema.decodeUnknownEither(OAuthConfigSchema)(config)
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+})