@knpkv/confluence-to-markdown 0.5.0 → 0.7.0

package/test/AtlaskitTransformers.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "@effect/vitest"
+import * as Effect from "effect/Effect"
+import { AtlaskitTransformers, layer as AtlaskitTransformersLayer } from "../src/AtlaskitTransformers.js"
+
+describe("AtlaskitTransformers", () => {
+  it.effect("encodes markdown to ADF JSON", () =>
+    Effect.gen(function*() {
+      const t = yield* AtlaskitTransformers
+      const adf = yield* t.use(({ json, md }) => json.encode(md.parse("# Hello")))
+      expect(adf.type).toBe("doc")
+      expect(adf.content[0]?.type).toBe("heading")
+    }).pipe(Effect.provide(AtlaskitTransformersLayer)))
+
+  it.effect("surfaces synchronous throws as AtlaskitTransformersError", () =>
+    Effect.gen(function*() {
+      const t = yield* AtlaskitTransformers
+      const result = yield* Effect.result(t.use(() => {
+        throw new Error("boom")
+      }))
+      expect(result._tag).toBe("Failure")
+      if (result._tag === "Failure") {
+        expect(result.failure._tag).toBe("AtlaskitTransformersError")
+      }
+    }).pipe(Effect.provide(AtlaskitTransformersLayer)))
+})

package/test/Brand.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "@effect/vitest"
-import * as Either from "effect/Either"
+import * as Result from "effect/Result"
 import * as Schema from "effect/Schema"
 import { ContentHash, PageId, PageIdSchema, SpaceKey, SpaceKeySchema } from "../src/Brand.js"
 
@@ -17,13 +17,13 @@ describe("Brand", () => {
 
   describe("PageIdSchema", () => {
     it("decodes valid page IDs", () => {
-      const result = Schema.decodeEither(PageIdSchema)("123456")
-      expect(Either.isRight(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(PageIdSchema)("123456")
+      expect(Result.isSuccess(result)).toBe(true)
     })
 
     it("rejects empty strings", () => {
-      const result = Schema.decodeEither(PageIdSchema)("")
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(PageIdSchema)("")
+      expect(Result.isFailure(result)).toBe(true)
     })
   })
 
@@ -40,18 +40,18 @@ describe("Brand", () => {
 
   describe("SpaceKeySchema", () => {
     it("decodes uppercase alphanumeric keys", () => {
-      const result = Schema.decodeEither(SpaceKeySchema)("MYSPACE123")
-      expect(Either.isRight(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(SpaceKeySchema)("MYSPACE123")
+      expect(Result.isSuccess(result)).toBe(true)
     })
 
     it("rejects lowercase keys", () => {
-      const result = Schema.decodeEither(SpaceKeySchema)("myspace")
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(SpaceKeySchema)("myspace")
+      expect(Result.isFailure(result)).toBe(true)
     })
 
     it("rejects keys with special characters", () => {
-      const result = Schema.decodeEither(SpaceKeySchema)("MY-SPACE")
-      expect(Either.isLeft(result)).toBe(true)
+      const result = Schema.decodeUnknownResult(SpaceKeySchema)("MY-SPACE")
+      expect(Result.isFailure(result)).toBe(true)
     })
   })
 

package/test/GitService.test.ts

@@ -1,5 +1,7 @@
+import { NodeServices } from "@effect/platform-node"
 import { describe, expect, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
 import { GitService, layer as GitServiceLayer } from "../src/GitService.js"
 import { getConflictedFiles, GIT_LOG_FORMAT, parseGitLog, parseGitStatus } from "../src/internal/gitCommands.js"
 
@@ -7,6 +9,8 @@ import { getConflictedFiles, GIT_LOG_FORMAT, parseGitLog, parseGitStatus } from
  * Tests for git parsing utilities and GitService.
  */
 describe("GitService", () => {
+  const TestLayer = Layer.provideMerge(GitServiceLayer, NodeServices.layer)
+
   describe("parseGitStatus", () => {
     it("parses empty status", () => {
       const entries = parseGitStatus("")
@@ -197,13 +201,13 @@ M  normal.ts`
         const git = yield* GitService
         const version = yield* git.validateGit()
         expect(version).toContain("git version")
-      }).pipe(Effect.provide(GitServiceLayer)))
+      }).pipe(Effect.provide(TestLayer)))
 
     it.effect("isInitialized returns boolean", () =>
       Effect.gen(function*() {
         const git = yield* GitService
         const initialized = yield* git.isInitialized()
         expect(typeof initialized).toBe("boolean")
-      }).pipe(Effect.provide(GitServiceLayer)))
+      }).pipe(Effect.provide(TestLayer)))
   })
 })

package/test/MarkdownConverter.test.ts

@@ -1,142 +1,158 @@
 import { describe, expect, it } from "@effect/vitest"
 import * as Effect from "effect/Effect"
-import { layer as MarkdownConverterLayer, MarkdownConverter, schemaBasedLayer } from "../src/MarkdownConverter.js"
+import * as Layer from "effect/Layer"
+import { layer as AdfSchemaValidatorLayer } from "../src/AdfSchemaValidator.js"
+import { layer as AtlaskitTransformersLayer } from "../src/AtlaskitTransformers.js"
+import { layer as MarkdownConverterLayer, MarkdownConverter } from "../src/MarkdownConverter.js"
 
-describe("MarkdownConverter", () => {
-  describe("htmlToMarkdown", () => {
-    it.effect("converts basic HTML to markdown", () =>
-      Effect.gen(function*() {
-        const converter = yield* MarkdownConverter
-        const html = "<p>Hello <strong>world</strong></p>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("Hello")
-        expect(markdown).toContain("**world**")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+const TestLayer = MarkdownConverterLayer.pipe(
+  Layer.provide(AtlaskitTransformersLayer),
+  Layer.provide(AdfSchemaValidatorLayer)
+)
 
-    it.effect("converts headings", () =>
-      Effect.gen(function*() {
-        const converter = yield* MarkdownConverter
-        const html = "<h1>Title</h1><h2>Subtitle</h2>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("# Title")
-        expect(markdown).toContain("## Subtitle")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+const minimalDoc = (content: ReadonlyArray<unknown>): string => JSON.stringify({ version: 1, type: "doc", content })
 
-    it.effect("converts lists", () =>
-      Effect.gen(function*() {
-        const converter = yield* MarkdownConverter
-        const html = "<ul><li>Item 1</li><li>Item 2</li></ul>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        // 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", () =>
+describe("MarkdownConverter", () => {
+  describe("adfToMarkdown", () => {
+    it.effect("converts a heading", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const html = "<a href=\"https://example.com\">Link</a>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("[Link](https://example.com)")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{ type: "heading", attrs: { level: 1 }, content: [{ type: "text", text: "Hello" }] }])
+        )
+        expect(md).toContain("# Hello")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts code blocks", () =>
+    it.effect("converts a paragraph with marks", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const html = "<pre><code>const x = 1;</code></pre>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("```")
-        expect(markdown).toContain("const x = 1;")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{
+            type: "paragraph",
+            content: [
+              { type: "text", text: "Hello " },
+              { type: "text", text: "world", marks: [{ type: "strong" }] }
+            ]
+          }])
+        )
+        expect(md).toContain("Hello")
+        expect(md).toContain("**world**")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("strips Confluence macros with rich-text-body", () =>
+    it.effect("converts a bullet list", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const html =
-          "<ac:structured-macro ac:name=\"info\"><ac:rich-text-body><p>Content</p></ac:rich-text-body></ac:structured-macro>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("Content")
-        expect(markdown).not.toContain("ac:structured-macro")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{
+            type: "bulletList",
+            content: [
+              {
+                type: "listItem",
+                content: [{ type: "paragraph", content: [{ type: "text", text: "one" }] }]
+              },
+              {
+                type: "listItem",
+                content: [{ type: "paragraph", content: [{ type: "text", text: "two" }] }]
+              }
+            ]
+          }])
+        )
+        expect(md).toContain("- one")
+        expect(md).toContain("- two")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts Confluence code macros to code blocks", () =>
+    it.effect("converts a code block with language", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const html =
-          "<ac:structured-macro ac:name=\"code\"><ac:plain-text-body><![CDATA[const x = 1;]]></ac:plain-text-body></ac:structured-macro>"
-        const markdown = yield* converter.htmlToMarkdown(html)
-        expect(markdown).toContain("const x = 1;")
-        expect(markdown).toContain("```")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
-  })
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{
+            type: "codeBlock",
+            attrs: { language: "ts" },
+            content: [{ type: "text", text: "const x = 1" }]
+          }])
+        )
+        expect(md).toContain("```ts")
+        expect(md).toContain("const x = 1")
+      }).pipe(Effect.provide(TestLayer)))
 
-  describe("markdownToHtml", () => {
-    it.effect("converts basic markdown to HTML", () =>
+    it.effect("converts a panel to a Confluence-preserving placeholder", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const markdown = "Hello **world**"
-        const html = yield* converter.markdownToHtml(markdown)
-        expect(html).toContain("<strong>world</strong>")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const md = yield* converter.adfToMarkdown(
+          minimalDoc([{
+            type: "panel",
+            attrs: { panelType: "info" },
+            content: [{ type: "paragraph", content: [{ type: "text", text: "heads up" }] }]
+          }])
+        )
+        expect(md).toContain("<!-- adf:panel type=info attrs=")
+        expect(md).toContain("heads up")
+        expect(md).toContain("<!-- adf:/panel -->")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts headings", () =>
+    it.effect("fails with ConversionError on invalid JSON", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const markdown = "# Title\n\n## Subtitle"
-        const html = yield* converter.markdownToHtml(markdown)
-        expect(html).toContain("<h1>Title</h1>")
-        expect(html).toContain("<h2>Subtitle</h2>")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        const result = yield* Effect.result(converter.adfToMarkdown("not json"))
+        expect(result._tag).toBe("Failure")
+        if (result._tag === "Failure") {
+          expect(result.failure._tag).toBe("ConversionError")
+          expect(result.failure.direction).toBe("adfToMarkdown")
+        }
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts GFM tables", () =>
+    it.effect("treats schema-invalid incoming ADF as advisory and still converts", () =>
       Effect.gen(function*() {
         const converter = yield* MarkdownConverter
-        const markdown = "| A | B |\n|---|---|\n| 1 | 2 |"
-        const html = yield* converter.markdownToHtml(markdown)
-        expect(html).toContain("<table>")
-        expect(html).toContain("<th>A</th>")
-        expect(html).toContain("<td>1</td>")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        // Missing `version`, and `attrs.level` should be a number — both are
+        // schema violations Confluence would never produce, but representative
+        // of the schema drift we tolerate on the incoming side.
+        const md = yield* converter.adfToMarkdown(JSON.stringify({
+          type: "doc",
+          content: [{
+            type: "heading",
+            attrs: { level: "1" },
+            content: [{ type: "text", text: "Hello" }]
+          }]
+        }))
+        expect(md).toContain("Hello")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("converts task lists", () =>
+    it.effect("still fails on input too malformed to walk", () =>
       Effect.gen(function*() {
+        // Advisory validation tolerates schema drift, not non-documents:
+        // walking `null` is a defect, `{}`/arrays silently produce an empty
+        // page that could overwrite a real local file.
         const converter = yield* MarkdownConverter
-        const markdown = "- [ ] Todo\n- [x] Done"
-        const html = yield* converter.markdownToHtml(markdown)
-        expect(html).toContain("checkbox")
-      }).pipe(Effect.provide(MarkdownConverterLayer)))
+        for (const bad of ["null", "{}", "[1,2]", `{"type":"doc","content":"not an array"}`]) {
+          const result = yield* Effect.result(converter.adfToMarkdown(bad))
+          expect(result._tag).toBe("Failure")
+          if (result._tag === "Failure") {
+            expect(result.failure._tag).toBe("ConversionError")
+          }
+        }
+      }).pipe(Effect.provide(TestLayer)))
   })
 
-  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", () =>
+  describe("markdownToAdf", () => {
+    it.effect("produces a valid ADF doc for a heading", () =>
       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)))
+        const adf = yield* converter.markdownToAdf("# Title\n\nBody")
+        const parsed = JSON.parse(adf) as { type: string; version: number; content: ReadonlyArray<{ type: string }> }
+        expect(parsed.type).toBe("doc")
+        expect(parsed.version).toBe(1)
+        expect(parsed.content[0]?.type).toBe("heading")
+      }).pipe(Effect.provide(TestLayer)))
 
-    it.effect("markdownToAst parses Markdown to Document", () =>
+    it.effect("round-trips a heading + paragraph through both directions", () =>
       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)))
+        const md1 = "# Title\n\nHello **world**"
+        const adf = yield* converter.markdownToAdf(md1)
+        const md2 = yield* converter.adfToMarkdown(adf)
+        expect(md2).toContain("# Title")
+        expect(md2).toContain("**world**")
+      }).pipe(Effect.provide(TestLayer)))
   })
 })