@uploadista/flow-documents-nodes 0.0.16-beta.2 → 0.0.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/flow-documents-nodes",
   "type": "module",
-  "version": "0.0.16-beta.2",
+  "version": "0.0.16",
   "description": "Document processing nodes for Uploadista Flow",
   "license": "MIT",
   "author": "Uploadista",
@@ -11,22 +11,32 @@
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs",
       "default": "./dist/index.mjs"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.mts",
+      "import": "./dist/types/index.mjs",
+      "require": "./dist/types/index.cjs",
+      "default": "./dist/types/index.mjs"
     }
   },
   "dependencies": {
     "effect": "3.19.4",
     "zod": "4.1.12",
-    "@uploadista/core": "0.0.16-beta.2"
+    "@uploadista/core": "0.0.16"
   },
   "devDependencies": {
+    "@effect/vitest": "0.27.0",
     "@types/node": "24.10.1",
     "tsdown": "0.16.5",
-    "@uploadista/typescript-config": "0.0.16-beta.2"
+    "vitest": "4.0.9",
+    "@uploadista/typescript-config": "0.0.16"
   },
   "scripts": {
     "build": "tsdown",
     "format": "biome format --write ./src",
     "lint": "biome lint --write ./src",
-    "check": "biome check --write ./src"
+    "check": "biome check --write ./src",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
 }

package/src/index.ts

@@ -25,3 +25,6 @@ export {
   createSplitPdfNode,
   type SplitPdfNodeParams,
 } from "./split-pdf-node";
+
+// Parameter schemas for validation
+export * from "./types";

package/src/types/convert-to-markdown-node.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const convertToMarkdownParamsSchema = z.object({
+  credentialId: z.string().optional(),
+  resolution: z
+    .enum(["tiny", "small", "base", "gundam", "large"])
+    .optional(),
+});
+
+export type ConvertToMarkdownParams = z.infer<
+  typeof convertToMarkdownParamsSchema
+>;

package/src/types/describe-document-node.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const describeDocumentParamsSchema = z.object({});
+
+export type DescribeDocumentParams = z.infer<
+  typeof describeDocumentParamsSchema
+>;

package/src/types/extract-text-node.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+export const extractTextParamsSchema = z.object({});
+
+export type ExtractTextParams = z.infer<typeof extractTextParamsSchema>;

package/src/types/index.ts

@@ -0,0 +1,23 @@
+// Document node parameter schemas
+
+export {
+  convertToMarkdownParamsSchema,
+  type ConvertToMarkdownParams,
+} from "./convert-to-markdown-node.js";
+export {
+  describeDocumentParamsSchema,
+  type DescribeDocumentParams,
+} from "./describe-document-node.js";
+export {
+  extractTextParamsSchema,
+  type ExtractTextParams,
+} from "./extract-text-node.js";
+export {
+  mergePdfParamsSchema,
+  type MergePdfParams,
+} from "./merge-pdf-node.js";
+export { ocrParamsSchema, type OcrParams } from "./ocr-node.js";
+export {
+  splitPdfParamsSchema,
+  type SplitPdfParams,
+} from "./split-pdf-node.js";

package/src/types/merge-pdf-node.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+
+export const mergePdfParamsSchema = z.object({
+  inputCount: z.number().positive().optional(),
+});
+
+export type MergePdfParams = z.infer<typeof mergePdfParamsSchema>;

package/src/types/ocr-node.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+
+export const ocrParamsSchema = z.object({
+  taskType: z.enum([
+    "convertToMarkdown",
+    "freeOcr",
+    "parseFigure",
+    "locateObject",
+  ]),
+  resolution: z
+    .enum(["tiny", "small", "base", "gundam", "large"])
+    .optional(),
+  credentialId: z.string().optional(),
+  referenceText: z.string().optional(),
+});
+
+export type OcrParams = z.infer<typeof ocrParamsSchema>;

package/src/types/split-pdf-node.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const splitPdfParamsSchema = z.object({
+  mode: z.enum(["range", "individual"]),
+  startPage: z.number().positive().optional(),
+  endPage: z.number().positive().optional(),
+});
+
+export type SplitPdfParams = z.infer<typeof splitPdfParamsSchema>;

package/tests/document-nodes.test.ts

@@ -0,0 +1,318 @@
+import { describe, expect, it, vi } from "@effect/vitest";
+import {
+  TestDocumentAiPlugin,
+  TestDocumentPlugin,
+  TestUploadServer,
+} from "@uploadista/core/testing";
+import type { UploadFile } from "@uploadista/core/types";
+import { Effect, Layer } from "effect";
+import {
+  createConvertToMarkdownNode,
+  createDescribeDocumentNode,
+  createExtractTextNode,
+  createMergePdfNode,
+  createOcrNode,
+  createSplitPdfNode,
+} from "../src/index";
+
+/**
+ * Test utilities for creating sample data
+ */
+const createTestUploadFile = (overrides?: Partial<UploadFile>): UploadFile => ({
+  id: "test-file-1",
+  offset: 0,
+  size: 2048,
+  storage: {
+    id: "test-storage",
+    type: "memory",
+  },
+  metadata: {
+    mimeType: "application/pdf",
+    originalName: "test-document.pdf",
+    fileName: "test-document.pdf",
+    extension: "pdf",
+  },
+  url: "https://example.com/test-document.pdf",
+  creationDate: new Date().toISOString(),
+  ...overrides,
+});
+
+/**
+ * Test layer combining all mocks
+ */
+const TestLayer = Layer.mergeAll(
+  TestDocumentPlugin,
+  TestDocumentAiPlugin,
+  TestUploadServer,
+);
+
+// Mock fetch for URL availability tests
+global.fetch = vi.fn(() =>
+  Promise.resolve({
+    ok: true,
+    status: 200,
+  } as Response),
+);
+
+describe("Document Nodes", () => {
+  describe("ExtractTextNode", () => {
+    it.effect("should create extract text node with correct properties", () =>
+      Effect.gen(function* () {
+        const node = yield* createExtractTextNode("extract-1", {});
+
+        expect(node.id).toBe("extract-1");
+        expect(node.name).toBe("Extract Text");
+        expect(node.description).toContain("Extract text");
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should extract text from PDF", () =>
+      Effect.gen(function* () {
+        const node = yield* createExtractTextNode("extract-text", {});
+        const testFile = createTestUploadFile();
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data.metadata?.extractedText).toBeDefined();
+          expect(result.data.metadata?.extractedText).toContain("extracted text");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+  });
+
+  describe("SplitPdfNode", () => {
+    it.effect("should create split PDF node with correct properties", () =>
+      Effect.gen(function* () {
+        const node = yield* createSplitPdfNode("split-1", {
+          mode: "range",
+          startPage: 1,
+          endPage: 3,
+        });
+
+        expect(node.id).toBe("split-1");
+        expect(node.name).toBe("Split PDF");
+        expect(node.description).toContain("Split");
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should split PDF by page range", () =>
+      Effect.gen(function* () {
+        const node = yield* createSplitPdfNode("split-range", {
+          mode: "range",
+          startPage: 2,
+          endPage: 4,
+        });
+        const testFile = createTestUploadFile();
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should split PDF into individual pages", () =>
+      Effect.gen(function* () {
+        const node = yield* createSplitPdfNode("split-individual", {
+          mode: "individual",
+        });
+        const testFile = createTestUploadFile();
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          // Individual mode outputs array of files
+          expect(result.data).toBeDefined();
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+  });
+
+  describe("MergePdfNode", () => {
+    it.effect("should create merge PDF node with correct properties", () =>
+      Effect.gen(function* () {
+        const node = yield* createMergePdfNode("merge-1", {});
+
+        expect(node.id).toBe("merge-1");
+        expect(node.name).toBe("Merge PDFs");
+        expect(node.description).toContain("Merge");
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should merge multiple PDFs", () =>
+      Effect.gen(function* () {
+        const node = yield* createMergePdfNode("merge-pdfs", {});
+        const testFiles = [
+          createTestUploadFile({ id: "file-1" }),
+          createTestUploadFile({ id: "file-2" }),
+          createTestUploadFile({ id: "file-3" }),
+        ];
+
+        const result = yield* node.run({
+          data: testFiles,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data).toBeDefined();
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+  });
+
+  describe("DescribeDocumentNode", () => {
+    it.effect("should create describe document node with correct properties", () =>
+      Effect.gen(function* () {
+        const node = yield* createDescribeDocumentNode("describe-1", {});
+
+        expect(node.id).toBe("describe-1");
+        expect(node.name).toBe("Describe Document");
+        expect(node.description).toContain("metadata");
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should extract document metadata", () =>
+      Effect.gen(function* () {
+        const node = yield* createDescribeDocumentNode("describe-doc", {});
+        const testFile = createTestUploadFile();
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data.metadata?.pageCount).toBeDefined();
+          expect(result.data.metadata?.author).toBeDefined();
+          expect(result.data.metadata?.title).toBeDefined();
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+  });
+
+  describe("OcrNode", () => {
+    it.effect("should create OCR node with correct properties", () =>
+      Effect.gen(function* () {
+        const node = yield* createOcrNode("ocr-1", {
+          taskType: "convertToMarkdown",
+          resolution: "gundam",
+        });
+
+        expect(node.id).toBe("ocr-1");
+        expect(node.name).toBe("OCR");
+        expect(node.description).toContain("text");
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should perform OCR with markdown conversion", () =>
+      Effect.gen(function* () {
+        const node = yield* createOcrNode("ocr-markdown", {
+          taskType: "convertToMarkdown",
+          resolution: "gundam",
+        });
+        const testFile = createTestUploadFile();
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data.metadata?.ocrText).toBeDefined();
+          expect(result.data.metadata?.ocrFormat).toBe("markdown");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should perform free OCR", () =>
+      Effect.gen(function* () {
+        const node = yield* createOcrNode("ocr-free", {
+          taskType: "freeOcr",
+          resolution: "base",
+        });
+        const testFile = createTestUploadFile();
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data.metadata?.ocrText).toBeDefined();
+          expect(result.data.metadata?.ocrFormat).toBe("plain");
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+  });
+
+  describe("ConvertToMarkdownNode", () => {
+    it.effect("should create convert to markdown node with correct properties", () =>
+      Effect.gen(function* () {
+        const node = yield* createConvertToMarkdownNode("convert-1", {});
+
+        expect(node.id).toBe("convert-1");
+        expect(node.name).toBe("Convert to Markdown");
+        expect(node.description).toContain("Markdown");
+      }).pipe(Effect.provide(TestLayer)),
+    );
+
+    it.effect("should convert document to markdown", () =>
+      Effect.gen(function* () {
+        const node = yield* createConvertToMarkdownNode("convert-md", {});
+        const testFile = createTestUploadFile();
+
+        const result = yield* node.run({
+          data: testFile,
+          jobId: "test-job",
+          flowId: "test-flow",
+          storageId: "test-storage",
+          clientId: "test-client",
+        });
+
+        expect(result.type).toBe("complete");
+        if (result.type === "complete") {
+          expect(result.data.metadata?.markdown).toBeDefined();
+        }
+      }).pipe(Effect.provide(TestLayer)),
+    );
+  });
+});

package/tsdown.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: {
+    index: "src/index.ts",
+    "types/index": "src/types/index.ts",
+  },
+  minify: true,
+  format: ["esm", "cjs"],
+  dts: true,
+  outDir: "dist",
+});

package/vitest.config.ts

@@ -0,0 +1,21 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}"],
+    exclude: ["node_modules", "dist"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: [
+        "node_modules/",
+        "dist/",
+        "**/*.d.ts",
+        "**/*.test.ts",
+        "**/*.spec.ts",
+      ],
+    },
+  },
+});