effect-libreoffice 1.0.0

package/src/misc/benchmark.ts

@@ -0,0 +1,116 @@
+import * as fs from "node:fs";
+import path from "node:path";
+import { NodeContext, NodeHttpClient } from "@effect/platform-node";
+import { Effect, Layer } from "effect";
+import { Bench } from "tinybench";
+import { LibreOffice } from "../index";
+import { UnoClient, UnoServer } from "../uno/uno";
+
+const bench = new Bench({ time: 5000 }); // Run for 5 seconds
+
+// Setup paths
+const fixturesDir = path.resolve(__dirname, "../fixtures");
+const outputDir = path.resolve(__dirname, "../tmp/benchmark");
+const inputFile = path.join(fixturesDir, "test.txt");
+
+if (!fs.existsSync(outputDir)) {
+  fs.mkdirSync(outputDir, { recursive: true });
+}
+
+// Ensure input file exists
+if (!fs.existsSync(inputFile)) {
+  console.error(`Input file not found: ${inputFile}`);
+  process.exit(1);
+}
+
+// Setup shared volume for Uno
+const sharedDir = "/tmp/test-convert";
+const sharedInputFile = path.join(sharedDir, "test.txt");
+if (!fs.existsSync(sharedDir)) {
+  console.error(`Shared directory not found: ${sharedDir}`);
+  process.exit(1);
+}
+fs.copyFileSync(inputFile, sharedInputFile);
+
+const outputDefault = path.join(outputDir, "output_default.pdf");
+const outputUno = path.join(sharedDir, "output_uno.pdf");
+
+// 1. Default Implementation (CLI)
+// Needs: NodeContext (for FileSystem, Path)
+// AND the resulting effect needs CommandExecutor which comes from NodeContext
+const DefaultEnv = LibreOffice.Default.pipe(
+  Layer.provideMerge(NodeContext.layer),
+);
+
+const runDefault = Effect.gen(function* () {
+  const lo = yield* LibreOffice;
+  yield* lo.convertLocalFile(inputFile, outputDefault);
+}).pipe(Effect.provide(DefaultEnv));
+
+// 2. Uno Implementation (Remote)
+// Needs: UnoClient, UnoServer.Remote, NodeContext, NodeHttpClient
+const UnoEnv = LibreOffice.Uno.pipe(
+  Layer.provide(UnoClient.Default),
+  Layer.provide(UnoServer.Remote),
+  Layer.provideMerge(NodeHttpClient.layer),
+  Layer.provideMerge(NodeContext.layer),
+);
+
+const runUno = Effect.gen(function* () {
+  const lo = yield* LibreOffice;
+  yield* lo.convertLocalFile(sharedInputFile, outputUno);
+}).pipe(Effect.provide(UnoEnv));
+
+const runUnoParallel = Effect.gen(function* () {
+  const lo = yield* LibreOffice;
+  yield* Effect.all(
+    Array.from({ length: 6 }, (_, i) =>
+      lo.convertLocalFile(
+        sharedInputFile,
+        path.join(sharedDir, `output_uno_p${i}.pdf`),
+      ),
+    ),
+    { concurrency: "unbounded" },
+  );
+}).pipe(Effect.provide(UnoEnv));
+
+const main = async () => {
+  console.log("Starting benchmark...");
+  console.log(`Input: ${inputFile}`);
+  console.log("Warming up...");
+
+  // Verify they work first to avoid silent failures in bench
+  try {
+    await Effect.runPromise(runDefault);
+    console.log("Default implementation verified.");
+  } catch (e) {
+    console.error("Default implementation failed:", e);
+    process.exit(1);
+  }
+
+  try {
+    await Effect.runPromise(runUno);
+    console.log("Uno implementation verified.");
+  } catch (e) {
+    console.error("Uno implementation failed:", e);
+    process.exit(1);
+  }
+
+  bench
+    .add("Default (CLI)", async () => {
+      await Effect.runPromise(runDefault);
+    })
+    .add("Uno (Remote)", async () => {
+      await Effect.runPromise(runUno);
+    })
+    .add("Uno (Remote) - Parallel", async () => {
+      await Effect.runPromise(runUnoParallel);
+    });
+
+  console.log("Running benchmark...");
+  await bench.run();
+
+  console.table(bench.table());
+};
+
+main().catch(console.error);

package/src/misc/scratchpad.ts

@@ -0,0 +1,26 @@
+import { Command } from "@effect/platform";
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { Effect } from "effect";
+
+const compose = Command.make("docker", "compose", "up").pipe(
+  Command.stdout("inherit"),
+  Command.stderr("inherit"),
+);
+
+const program = Effect.gen(function* () {
+  // const process = yield* Command.start(compose);
+
+  yield* Effect.acquireRelease(Command.start(compose), (process) =>
+    Effect.ignore(process.kill("SIGTERM")),
+  );
+
+  yield* Effect.log("hello");
+  yield* Effect.sleep("10 seconds");
+  yield* Effect.log("world");
+
+  // yield* process.kill();
+});
+
+NodeRuntime.runMain(
+  program.pipe(Effect.scoped, Effect.provide(NodeContext.layer)),
+);

package/src/shared.ts

@@ -0,0 +1,30 @@
+import { Data } from "effect";
+
+export type KnownSupportedOutputFormat =
+  | "pdf"
+  | "docx"
+  | "doc"
+  | "odt"
+  | "html"
+  | "rtf"
+  | "epub"
+  | "jpg"
+  | "txt";
+
+export type OutputPath =
+  | `${string}.${KnownSupportedOutputFormat}`
+  | (string & {});
+
+type Reason =
+  | "InputFileNotFound"
+  | "StartFailed"
+  | "Unknown"
+  | "BadOutputExtension"
+  | "MethodNotFound"
+  | "PermissionDenied";
+
+export class LibreOfficeError extends Data.TaggedError("LibreOfficeError")<{
+  reason: Reason;
+  message: string;
+  cause?: unknown;
+}> {}

package/src/ubuntu-docker.test.ts

@@ -0,0 +1,61 @@
+import { Path } from "@effect/platform";
+import { NodeContext } from "@effect/platform-node";
+import { assert, expect, it } from "@effect/vitest";
+import { Effect, Layer, Predicate } from "effect";
+import { GenericContainer } from "testcontainers";
+import { LibreOffice, LibreOfficeCmd } from "./index";
+
+const UbuntuContainer = Layer.scoped(
+  LibreOfficeCmd,
+  Effect.gen(function* () {
+    const path = yield* Path.Path;
+    const dockerfilePath = path.join(process.cwd(), "docker");
+
+    const container = yield* Effect.acquireRelease(
+      Effect.promise(async () => {
+        const image = await GenericContainer.fromDockerfile(
+          dockerfilePath,
+          "ubuntu.Dockerfile",
+        ).build("fiws/effect-libreoffice-ubuntu:latest", {
+          deleteOnExit: false,
+        });
+
+        return await image
+          .withReuse()
+          .withCommand(["tail", "-f", "/dev/null"])
+          .start();
+      }),
+      (container) => Effect.promise(() => container.stop()),
+    );
+
+    return ["docker", "exec", container.getId(), "soffice", "--headless"];
+  }),
+);
+
+const TestLive = LibreOffice.Default.pipe(
+  Layer.provideMerge(UbuntuContainer),
+  Layer.provideMerge(NodeContext.layer),
+);
+
+it.layer(TestLive, { timeout: 120_000 })(
+  "Libreoffice (Ubuntu Docker)",
+  (it) => {
+    it.effect(
+      "should fails with source file not found",
+      Effect.fn(function* () {
+        const libre = yield* LibreOffice;
+        const result = yield* libre
+          .convertLocalFile("./fixtures/test-not-found.txt", "test.out.pdf")
+          .pipe(Effect.flip);
+
+        expect(result._tag).toBe("LibreOfficeError");
+
+        assert(
+          Predicate.isTagged(result, "LibreOfficeError"),
+          "result is not LibreOfficeError",
+        );
+        expect(result.reason).toBe("InputFileNotFound");
+      }),
+    );
+  },
+);

package/src/uno/schema-utils.test.ts

@@ -0,0 +1,58 @@
+import { Schema } from "effect";
+import { describe, expect, it } from "vitest";
+import { StructFromMembers } from "./schema-utils.js";
+
+describe("StructFromMembers", () => {
+  it("decodes valid members to struct", () => {
+    const Target = StructFromMembers({
+      count: Schema.Number,
+      message: Schema.String,
+      optional: Schema.optional(Schema.String),
+    });
+
+    const input = [
+      { name: "count", value: { int: 42 } },
+      { name: "message", value: { string: "hello" } },
+    ];
+
+    const result = Schema.decodeSync(Target)(input);
+    expect(result).toEqual({ count: 42, message: "hello" });
+  });
+
+  it("encodes struct to members", () => {
+    const Target = StructFromMembers({
+      count: Schema.Number,
+      message: Schema.String,
+    });
+
+    const input = { count: 42, message: "hello" };
+    const result = Schema.encodeSync(Target)(input);
+
+    // Sort to ensure order independence in test, though map preserves order
+    const sorted = [...result].sort((a, b) => a.name.localeCompare(b.name));
+
+    expect(sorted).toEqual([
+      { name: "count", value: { int: 42 } },
+      { name: "message", value: { string: "hello" } },
+    ]);
+  });
+
+  it("fails decode on mismatched types", () => {
+    const Target = StructFromMembers({
+      count: Schema.Number, // Expects number
+    });
+
+    const input = [{ name: "count", value: { string: "not a number" } }];
+
+    expect(() => Schema.decodeSync(Target)(input)).toThrow();
+  });
+
+  it("fails decode on missing required fields", () => {
+    const Target = StructFromMembers({
+      required: Schema.String,
+    });
+
+    const input: unknown[] = [];
+    expect(() => Schema.decodeUnknownSync(Target)(input)).toThrow();
+  });
+});

package/src/uno/schema-utils.ts

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+
+const MemberValue = Schema.Union(
+  Schema.Struct({ int: Schema.Number }),
+  Schema.Struct({ string: Schema.String }),
+);
+
+const Member = Schema.Struct({
+  name: Schema.String,
+  value: MemberValue,
+});
+
+const Members = Schema.Array(Member);
+
+export const StructFromMembers = <Fields extends Schema.Struct.Fields>(
+  fields: Fields,
+) =>
+  Schema.transform(Members, Schema.Struct(fields), {
+    strict: false,
+    decode: (input) => {
+      const output: Record<string, string | number> = {};
+      for (const member of input) {
+        if ("int" in member.value) {
+          output[member.name] = member.value.int;
+        } else if ("string" in member.value) {
+          output[member.name] = member.value.string;
+        }
+      }
+      return output;
+    },
+    encode: (input) => {
+      return Object.entries(input).map(([name, value]) => {
+        if (typeof value === "number") {
+          return { name, value: { int: value } };
+        }
+        if (typeof value === "string") {
+          return { name, value: { string: value } };
+        }
+        throw new Error(
+          `Unsupported value type for member ${name}: ${typeof value}`,
+        );
+      });
+    },
+  });

package/src/uno/uno-response.ts

@@ -0,0 +1,102 @@
+import { Schema } from "effect";
+
+import { StructFromMembers } from "./schema-utils";
+
+/**
+ * Schema for fault response
+ *
+ * ## Original xml
+ * ```xml
+ * <?xml version='1.0'?>
+ * <methodResponse>
+ *   <fault>
+ *     <value>
+ *       <struct>
+ *         <member>
+ *           <name>faultCode</name>
+ *           <value>
+ *             <int>1</int>
+ *           </value>
+ *         </member>
+ *         <member>
+ *           <name>faultString</name>
+ *           <value>
+ *             <string>&lt;class 'RuntimeError'&gt;:Path /tmp/test-convert/test.txt does not exist.</string>
+ *           </value>
+ *         </member>
+ *       </struct>
+ *     </value>
+ *   </fault>
+ * </methodResponse>
+ * ```
+ */
+const UnoFault = Schema.Struct({
+  methodResponse: Schema.Struct({
+    fault: Schema.Struct({
+      value: Schema.Struct({
+        struct: Schema.Struct({
+          member: StructFromMembers({
+            faultCode: Schema.Number,
+            faultString: Schema.String,
+          }),
+        }),
+      }),
+    }),
+  }),
+}).pipe(
+  Schema.transform(
+    Schema.Struct({
+      faultCode: Schema.Number,
+      faultString: Schema.String,
+    }),
+    {
+      strict: true,
+      decode: (input) => input.methodResponse.fault.value.struct.member,
+      encode: (input) => ({
+        methodResponse: {
+          fault: {
+            value: {
+              struct: {
+                member: input,
+              },
+            },
+          },
+        },
+      }),
+    },
+  ),
+  Schema.asSchema,
+);
+
+/**
+ * Schema for empty response (success)
+ *
+ * ## Original xml
+ * ```xml
+ * <?xml version='1.0'?>
+ * <methodResponse>
+ *   <params>
+ *     <param>
+ *       <value>
+ *         <nil />
+ *       </value>
+ *     </param>
+ *   </params>
+ * </methodResponse>
+ * ```
+ */
+export const UnoEmpty = Schema.Struct({
+  methodResponse: Schema.Struct({
+    params: Schema.Struct({
+      param: Schema.Struct({
+        value: Schema.Struct({
+          nil: Schema.String,
+        }),
+      }),
+    }),
+  }),
+}).pipe(Schema.asSchema);
+
+export const UnoResponse = Schema.Union(UnoFault, UnoEmpty);
+
+export const decodeUnoResponse = Schema.decodeUnknown(UnoResponse);

package/src/uno/uno.test.ts

@@ -0,0 +1,192 @@
+import { FileSystem, Path } from "@effect/platform";
+import { NodeContext, NodeHttpClient } from "@effect/platform-node";
+import { assert, expect, it } from "@effect/vitest";
+import { Effect, Layer, Predicate } from "effect";
+import { GenericContainer, Wait } from "testcontainers";
+import { LibreOffice } from "../index";
+import { testRunning, UnoClient, UnoServer } from "./uno";
+
+class TempDir extends Effect.Service<TempDir>()(
+  "libre-convert-effect/uno/uno.test/TempDir",
+  {
+    scoped: Effect.gen(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      return {
+        dir: yield* fs.makeTempDirectoryScoped(),
+      };
+    }),
+  },
+) {}
+
+const UnoServerTest = Layer.scoped(
+  UnoServer,
+  Effect.gen(function* () {
+    const { dir: tempDir } = yield* TempDir;
+    const container = yield* Effect.acquireRelease(
+      Effect.tryPromise(async () => {
+        const image = await GenericContainer.fromDockerfile(".").build(
+          "fiws/libreoffice-unoserver:latest",
+          {
+            deleteOnExit: false,
+          },
+        );
+        return await image
+          .withExposedPorts(2003)
+          .withUser(
+            `${process.getuid ? process.getuid() : 1000}:${process.getgid ? process.getgid() : 1000}`,
+          )
+          .withBindMounts([{ source: tempDir, target: tempDir }])
+          .withEnvironment({ HOME: tempDir })
+          .withReuse()
+          .withWaitStrategy(
+            Wait.forLogMessage(/INFO:unoserver:Started./).withStartupTimeout(
+              120_000,
+            ),
+          )
+          .start();
+      }),
+      (c) => Effect.promise(() => c.stop()),
+    );
+
+    const port = container.getMappedPort(2003);
+
+    yield* testRunning(`http://localhost:${port}/RPC2`);
+    return UnoServer.make({
+      url: `http://localhost:${port}/RPC2`,
+    });
+  }),
+);
+
+const UnoLayer = LibreOffice.Uno.pipe(
+  Layer.provide(UnoClient.Default),
+  Layer.provideMerge(UnoServerTest),
+  Layer.provideMerge(TempDir.Default),
+);
+
+const TestLive = Layer.provideMerge(
+  UnoLayer,
+  Layer.merge(NodeContext.layer, NodeHttpClient.layer),
+);
+
+it.layer(TestLive, { timeout: 120_000 })("Libreoffice (Uno)", (it) => {
+  it.scoped(
+    "should convert a file",
+    Effect.fn(function* () {
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const libre = yield* LibreOffice;
+
+      const tempDir = yield* fs.makeTempDirectory({
+        directory: (yield* TempDir).dir,
+      });
+      const sourceFile = path.join(tempDir, "test.txt");
+      const targetFile = path.join(tempDir, "test.out.pdf");
+
+      yield* fs.writeFileString(sourceFile, "Hello PDF");
+      yield* libre.convertLocalFile(sourceFile, targetFile);
+
+      const targetContent = yield* fs.readFile(targetFile);
+
+      const header = new TextDecoder().decode(targetContent.slice(0, 4));
+      expect(header).toBe("%PDF");
+    }),
+  );
+
+  it.effect(
+    "should fails with source file not found",
+    Effect.fn(function* () {
+      const libre = yield* LibreOffice;
+      const result = yield* libre
+        .convertLocalFile("./fixtures/test-not-found.txt", "test.out.pdf")
+        .pipe(Effect.flip);
+      assert(
+        Predicate.isTagged(result, "LibreOfficeError"),
+        "result is not LibreOfficeError",
+      );
+      expect(result.reason).toBe("InputFileNotFound");
+    }),
+  );
+
+  it.effect(
+    "Should work with 2 conversions in parallel",
+    Effect.fn(function* () {
+      const libre = yield* LibreOffice;
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+
+      const tempDir = yield* fs.makeTempDirectory({
+        directory: (yield* TempDir).dir,
+      });
+      const sourceFile = path.join(tempDir, "test.txt");
+      const targetFile = path.join(tempDir, "test.out.pdf");
+
+      yield* fs.writeFileString(sourceFile, "Hello PDF");
+
+      yield* Effect.all(
+        [
+          libre.convertLocalFile(sourceFile, targetFile),
+          libre.convertLocalFile(sourceFile, targetFile),
+        ],
+        { concurrency: "unbounded" },
+      );
+
+      const targetContent = yield* fs.readFile(targetFile);
+
+      const header = new TextDecoder().decode(targetContent.slice(0, 4));
+      expect(header).toBe("%PDF");
+    }),
+  );
+
+  it.effect(
+    "should fail with invalid output extension",
+    Effect.fn(function* () {
+      const libre = yield* LibreOffice;
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const tempDir = yield* fs.makeTempDirectory({
+        directory: (yield* TempDir).dir,
+      });
+      const sourceFile = path.join(tempDir, "test.txt");
+      const targetFile = path.join(tempDir, "test.invalidext");
+
+      yield* fs.writeFileString(sourceFile, "Hello PDF");
+
+      const result = yield* libre
+        .convertLocalFile(sourceFile, targetFile)
+        .pipe(Effect.flip);
+
+      assert(
+        Predicate.isTagged(result, "LibreOfficeError"),
+        "result is not LibreOfficeError",
+      );
+      expect(result.reason).toBe("BadOutputExtension");
+    }),
+  );
+
+  it.effect(
+    "should fail with output as directory",
+    Effect.fn(function* () {
+      const libre = yield* LibreOffice;
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const tempDir = yield* fs.makeTempDirectory({
+        directory: (yield* TempDir).dir,
+      });
+      const sourceFile = path.join(tempDir, "test.txt");
+      // Try to write to a directory
+      const targetFile = tempDir;
+
+      yield* fs.writeFileString(sourceFile, "Hello PDF");
+
+      const result = yield* libre
+        .convertLocalFile(sourceFile, targetFile)
+        .pipe(Effect.flip);
+
+      assert(
+        Predicate.isTagged(result, "LibreOfficeError"),
+        "result is not LibreOfficeError",
+      );
+      expect(result.reason).toBe("BadOutputExtension");
+    }),
+  );
+});