@knpkv/confluence-to-markdown 0.2.0 → 0.4.2

package/test/MarkdownConverter.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
-import { layer as MarkdownConverterLayer, MarkdownConverter } from "../src/MarkdownConverter.js"
+import { layer as MarkdownConverterLayer, MarkdownConverter, schemaBasedLayer } from "../src/MarkdownConverter.js"
 
 describe("MarkdownConverter", () => {
   describe("htmlToMarkdown", () => {
@@ -27,8 +27,9 @@ describe("MarkdownConverter", () => {
         const converter = yield* MarkdownConverter
         const html = "<ul><li>Item 1</li><li>Item 2</li></ul>"
         const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("* Item 1")
-        expect(markdown).toContain("* Item 2")
+        // AST-based serializer uses - for unordered lists
+        expect(markdown).toContain("- Item 1")
+        expect(markdown).toContain("- Item 2")
       }).pipe(Effect.provide(MarkdownConverterLayer)))
 
     it.effect("converts links", () =>
@@ -105,4 +106,37 @@ describe("MarkdownConverter", () => {
         expect(html).toContain("checkbox")
       }).pipe(Effect.provide(MarkdownConverterLayer)))
   })
+
+  describe("schemaBasedLayer", () => {
+    it.effect("htmlToMarkdown converts basic HTML", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const html = "<h1>Title</h1><p>Hello world</p>"
+        const markdown = yield* converter.htmlToMarkdown(html)
+        expect(markdown).toContain("# Title")
+        expect(markdown).toContain("Hello world")
+      }).pipe(Effect.provide(schemaBasedLayer)))
+
+    it.effect("htmlToAst parses HTML to Document", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const html = "<h1>Title</h1><p>Content</p>"
+        const doc = yield* converter.htmlToAst(html)
+        expect(doc.version).toBe(1)
+        expect(doc.children.length).toBe(2)
+        expect(doc.children[0]?._tag).toBe("Heading")
+        expect(doc.children[1]?._tag).toBe("Paragraph")
+      }).pipe(Effect.provide(schemaBasedLayer)))
+
+    it.effect("markdownToAst parses Markdown to Document", () =>
+      Effect.gen(function*() {
+        const converter = yield* MarkdownConverter
+        const md = "# Title\n\nContent"
+        const doc = yield* converter.markdownToAst(md)
+        expect(doc.version).toBe(1)
+        expect(doc.children.length).toBe(2)
+        expect(doc.children[0]?._tag).toBe("Heading")
+        expect(doc.children[1]?._tag).toBe("Paragraph")
+      }).pipe(Effect.provide(schemaBasedLayer)))
+  })
 })

package/test/Schemas.test.ts

@@ -2,7 +2,13 @@ import { describe, expect, it } from "@effect/vitest"
 import * as Either from "effect/Either"
 import * as Schema from "effect/Schema"
 import type { ContentHash, PageId } from "../src/Brand.js"
-import { ConfluenceConfigFileSchema, PageFrontMatterSchema } from "../src/Schemas.js"
+import {
+  ConfluenceConfigFileSchema,
+  OAuthConfigSchema,
+  OAuthTokenSchema,
+  OAuthUserSchema,
+  PageFrontMatterSchema
+} from "../src/Schemas.js"
 
 describe("Schemas", () => {
   describe("ConfluenceConfigFileSchema", () => {
@@ -14,7 +20,7 @@ describe("Schemas", () => {
       const result = Schema.decodeUnknownEither(ConfluenceConfigFileSchema)(config)
       expect(Either.isRight(result)).toBe(true)
       if (Either.isRight(result)) {
-        expect(result.right.docsPath).toBe(".docs/confluence")
+        expect(result.right.docsPath).toBe(".confluence/docs")
         expect(result.right.excludePatterns).toEqual([])
       }
     })
@@ -96,4 +102,93 @@ describe("Schemas", () => {
       expect(Either.isLeft(result)).toBe(true)
     })
   })
+
+  describe("OAuthTokenSchema", () => {
+    it("decodes valid token", () => {
+      const token = {
+        access_token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9",
+        refresh_token: "refresh_token_value",
+        expires_at: Date.now() + 3600000,
+        scope: "read:confluence-content.all",
+        cloud_id: "abc123",
+        site_url: "https://mysite.atlassian.net"
+      }
+      const result = Schema.decodeUnknownEither(OAuthTokenSchema)(token)
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("decodes token with user info", () => {
+      const token = {
+        access_token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9",
+        refresh_token: "refresh_token_value",
+        expires_at: Date.now() + 3600000,
+        scope: "read:confluence-content.all",
+        cloud_id: "abc123",
+        site_url: "https://mysite.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 missing required fields", () => {
+      const token = {
+        access_token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9",
+        // missing refresh_token
+        expires_at: Date.now() + 3600000,
+        scope: "read:confluence-content.all",
+        cloud_id: "abc123",
+        site_url: "https://mysite.atlassian.net"
+      }
+      const result = Schema.decodeUnknownEither(OAuthTokenSchema)(token)
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+
+  describe("OAuthConfigSchema", () => {
+    it("decodes valid config", () => {
+      const config = {
+        clientId: "client_id_value",
+        clientSecret: "client_secret_value"
+      }
+      const result = Schema.decodeUnknownEither(OAuthConfigSchema)(config)
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("rejects missing clientSecret", () => {
+      const config = {
+        clientId: "client_id_value"
+      }
+      const result = Schema.decodeUnknownEither(OAuthConfigSchema)(config)
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+
+  describe("OAuthUserSchema", () => {
+    it("decodes valid user info", () => {
+      const user = {
+        account_id: "user123",
+        name: "Test User",
+        email: "test@example.com"
+      }
+      const result = Schema.decodeUnknownEither(OAuthUserSchema)(user)
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("rejects missing email", () => {
+      const user = {
+        account_id: "user123",
+        name: "Test User"
+      }
+      const result = Schema.decodeUnknownEither(OAuthUserSchema)(user)
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
 })

package/test/ast/BlockNode.test.ts

@@ -0,0 +1,265 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Either from "effect/Either"
+import * as Schema from "effect/Schema"
+import {
+  BlockNode,
+  BlockQuote,
+  CodeBlock,
+  Heading,
+  Image,
+  List,
+  ListItem,
+  Paragraph,
+  Table,
+  TableCell,
+  TableRow,
+  ThematicBreak,
+  UnsupportedBlock
+} from "../../src/ast/BlockNode.js"
+import { Text } from "../../src/ast/InlineNode.js"
+
+describe("BlockNode", () => {
+  describe("Heading", () => {
+    it("creates heading with level and children", () => {
+      const h1 = new Heading({
+        level: 1,
+        children: [new Text({ value: "Title" })]
+      })
+      expect(h1._tag).toBe("Heading")
+      expect(h1.level).toBe(1)
+      expect(h1.version).toBe(1)
+    })
+
+    it("decodes heading from plain object", () => {
+      const result = Schema.decodeUnknownEither(Heading)({
+        _tag: "Heading",
+        level: 2,
+        children: [{ _tag: "Text", value: "Subtitle" }]
+      })
+      expect(Either.isRight(result)).toBe(true)
+      if (Either.isRight(result)) {
+        expect(result.right.level).toBe(2)
+        expect(result.right.version).toBe(1)
+      }
+    })
+
+    it("rejects invalid level", () => {
+      const result = Schema.decodeUnknownEither(Heading)({
+        _tag: "Heading",
+        level: 7,
+        children: []
+      })
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+
+  describe("Paragraph", () => {
+    it("creates paragraph with children", () => {
+      const para = new Paragraph({
+        children: [new Text({ value: "Hello" })]
+      })
+      expect(para._tag).toBe("Paragraph")
+      expect(para.children).toHaveLength(1)
+    })
+  })
+
+  describe("CodeBlock", () => {
+    it("creates code block with language", () => {
+      const code = new CodeBlock({
+        language: "typescript",
+        code: "const x = 1"
+      })
+      expect(code._tag).toBe("CodeBlock")
+      expect(code.language).toBe("typescript")
+      expect(code.code).toBe("const x = 1")
+    })
+
+    it("creates code block without language", () => {
+      const code = new CodeBlock({ code: "plain text" })
+      expect(code.language).toBeUndefined()
+    })
+  })
+
+  describe("ThematicBreak", () => {
+    it("creates thematic break", () => {
+      const hr = new ThematicBreak({})
+      expect(hr._tag).toBe("ThematicBreak")
+    })
+  })
+
+  describe("Image", () => {
+    it("creates image with src", () => {
+      const img = new Image({
+        src: "https://example.com/img.png"
+      })
+      expect(img._tag).toBe("Image")
+      expect(img.src).toBe("https://example.com/img.png")
+    })
+
+    it("creates image with alt and title", () => {
+      const img = new Image({
+        src: "https://example.com/img.png",
+        alt: "Alt text",
+        title: "Image title"
+      })
+      expect(img.alt).toBe("Alt text")
+      expect(img.title).toBe("Image title")
+    })
+  })
+
+  describe("Table", () => {
+    it("creates table with header and rows", () => {
+      const table = new Table({
+        header: new TableRow({
+          cells: [
+            new TableCell({
+              isHeader: true,
+              children: [new Text({ value: "Col 1" })]
+            })
+          ]
+        }),
+        rows: [
+          new TableRow({
+            cells: [
+              new TableCell({
+                children: [new Text({ value: "Data" })]
+              })
+            ]
+          })
+        ]
+      })
+      expect(table._tag).toBe("Table")
+      expect(table.header?.cells).toHaveLength(1)
+      expect(table.rows).toHaveLength(1)
+    })
+  })
+
+  describe("List", () => {
+    it("creates unordered list", () => {
+      const result = Schema.decodeUnknownEither(List)({
+        _tag: "List",
+        ordered: false,
+        children: [
+          {
+            _tag: "ListItem",
+            children: [
+              {
+                _tag: "Paragraph",
+                children: [{ _tag: "Text", value: "Item 1" }]
+              }
+            ]
+          }
+        ]
+      })
+      expect(Either.isRight(result)).toBe(true)
+      if (Either.isRight(result)) {
+        expect(result.right.ordered).toBe(false)
+        expect(result.right.children).toHaveLength(1)
+      }
+    })
+
+    it("creates ordered list with start", () => {
+      const result = Schema.decodeUnknownEither(List)({
+        _tag: "List",
+        ordered: true,
+        start: 5,
+        children: []
+      })
+      expect(Either.isRight(result)).toBe(true)
+      if (Either.isRight(result)) {
+        expect(result.right.start).toBe(5)
+      }
+    })
+  })
+
+  describe("ListItem", () => {
+    it("creates list item with checked state", () => {
+      const result = Schema.decodeUnknownEither(ListItem)({
+        _tag: "ListItem",
+        checked: true,
+        children: [
+          {
+            _tag: "Paragraph",
+            children: [{ _tag: "Text", value: "Done" }]
+          }
+        ]
+      })
+      expect(Either.isRight(result)).toBe(true)
+      if (Either.isRight(result)) {
+        expect(result.right.checked).toBe(true)
+      }
+    })
+  })
+
+  describe("BlockQuote", () => {
+    it("creates block quote with children", () => {
+      const result = Schema.decodeUnknownEither(BlockQuote)({
+        _tag: "BlockQuote",
+        children: [
+          {
+            _tag: "Paragraph",
+            children: [{ _tag: "Text", value: "Quote" }]
+          }
+        ]
+      })
+      expect(Either.isRight(result)).toBe(true)
+      if (Either.isRight(result)) {
+        expect(result.right.children).toHaveLength(1)
+      }
+    })
+  })
+
+  describe("UnsupportedBlock", () => {
+    it("creates unsupported block from confluence", () => {
+      const block = new UnsupportedBlock({
+        rawHtml: "<ac:macro/>",
+        source: "confluence"
+      })
+      expect(block._tag).toBe("UnsupportedBlock")
+      expect(block.source).toBe("confluence")
+    })
+  })
+
+  describe("BlockNode union", () => {
+    it("decodes Heading variant", () => {
+      const result = Schema.decodeUnknownEither(BlockNode)({
+        _tag: "Heading",
+        level: 1,
+        children: []
+      })
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("decodes Paragraph variant", () => {
+      const result = Schema.decodeUnknownEither(BlockNode)({
+        _tag: "Paragraph",
+        children: [{ _tag: "Text", value: "text" }]
+      })
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("decodes List variant", () => {
+      const result = Schema.decodeUnknownEither(BlockNode)({
+        _tag: "List",
+        ordered: true,
+        children: []
+      })
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("decodes BlockQuote variant", () => {
+      const result = Schema.decodeUnknownEither(BlockNode)({
+        _tag: "BlockQuote",
+        children: []
+      })
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("rejects unknown tag", () => {
+      const result = Schema.decodeUnknownEither(BlockNode)({
+        _tag: "Unknown"
+      })
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+})

package/test/ast/Document.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Either from "effect/Either"
+import * as Schema from "effect/Schema"
+import { Heading } from "../../src/ast/BlockNode.js"
+import { Document, isDocument, makeDocument } from "../../src/ast/Document.js"
+import { Text } from "../../src/ast/InlineNode.js"
+
+describe("Document", () => {
+  describe("Document schema", () => {
+    it("decodes valid document", () => {
+      const result = Schema.decodeUnknownEither(Document)({
+        children: [
+          {
+            _tag: "Heading",
+            level: 1,
+            children: [{ _tag: "Text", value: "Title" }]
+          },
+          {
+            _tag: "Paragraph",
+            children: [{ _tag: "Text", value: "Content" }]
+          }
+        ]
+      })
+      expect(Either.isRight(result)).toBe(true)
+      if (Either.isRight(result)) {
+        expect(result.right.version).toBe(1)
+        expect(result.right.children).toHaveLength(2)
+      }
+    })
+
+    it("decodes document with explicit version", () => {
+      const result = Schema.decodeUnknownEither(Document)({
+        version: 2,
+        children: []
+      })
+      expect(Either.isRight(result)).toBe(true)
+      if (Either.isRight(result)) {
+        expect(result.right.version).toBe(2)
+      }
+    })
+
+    it("decodes document with macro nodes", () => {
+      const result = Schema.decodeUnknownEither(Document)({
+        children: [
+          {
+            _tag: "InfoPanel",
+            panelType: "warning",
+            children: [
+              {
+                _tag: "Paragraph",
+                children: [{ _tag: "Text", value: "Warning!" }]
+              }
+            ]
+          }
+        ]
+      })
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("encodes document to plain object", () => {
+      const doc: Schema.Schema.Type<typeof Document> = {
+        version: 1,
+        children: [
+          new Heading({
+            level: 1,
+            children: [new Text({ value: "Hello" })]
+          })
+        ]
+      }
+      const result = Schema.encodeUnknownEither(Document)(doc)
+      expect(Either.isRight(result)).toBe(true)
+    })
+
+    it("rejects invalid children", () => {
+      const result = Schema.decodeUnknownEither(Document)({
+        children: [{ invalid: true }]
+      })
+      expect(Either.isLeft(result)).toBe(true)
+    })
+  })
+
+  describe("makeDocument", () => {
+    it("creates document with default version", () => {
+      const doc = makeDocument([
+        new Heading({
+          level: 1,
+          children: [new Text({ value: "Title" })]
+        })
+      ])
+      expect(doc.version).toBe(1)
+      expect(doc.children).toHaveLength(1)
+    })
+
+    it("creates empty document", () => {
+      const doc = makeDocument([])
+      expect(doc.children).toHaveLength(0)
+    })
+  })
+
+  describe("isDocument", () => {
+    it("returns true for valid document", () => {
+      const doc = makeDocument([])
+      expect(isDocument(doc)).toBe(true)
+    })
+
+    it("returns true for document-like object", () => {
+      expect(isDocument({ children: [] })).toBe(true)
+    })
+
+    it("returns false for null", () => {
+      expect(isDocument(null)).toBe(false)
+    })
+
+    it("returns false for non-object", () => {
+      expect(isDocument("string")).toBe(false)
+    })
+
+    it("returns false for object without children", () => {
+      expect(isDocument({ version: 1 })).toBe(false)
+    })
+
+    it("returns false for object with non-array children", () => {
+      expect(isDocument({ children: "not array" })).toBe(false)
+    })
+  })
+})