fix: to_archive and task threads (#38)

* feat: extendable builder

Adobe SDK extends the builder for compliance signing.

* fix: to_archive and task threads

fixes to_archive work with buffers as well as files.
Settings work on Neon/Node tasks

* chore: add changeset

* fix: Fix return type of resourceToAsset

* Update trustmark version

Author: cdmurph32

.changeset/nice-dingos-work.md

@@ -0,0 +1,5 @@
+---
+"@contentauth/c2pa-node": patch
+---
+
+Fix settings on tasks. Fix Builder toArchive

Cargo.lock

@@ -34,5 +34,5 @@ toml = "0.8"
 thiserror = "1.0.61"
 tokio = { version = "1.43.0", features = ["rt-multi-thread"] }
 tokio-util = "0.7.13"
-trustmark = "0.2"
+trustmark = "0.2.2"
 rand = "0.8.5"

Cargo.toml

@@ -29,6 +29,7 @@ import { isActionsAssertion } from "./assertions.js";
 import { CallbackSigner, LocalSigner } from "./Signer.js";
 import { Reader } from "./Reader.js";
 import { Builder } from "./Builder.js";
+import { loadC2paSettings, resetSettings } from "./Settings.js";
 
 const tempDir = path.join(__dirname, "tmp");
 
@@ -277,6 +278,81 @@ describe("Builder", () => {
       expect(activeManifest?.title).toBe("Test_Manifest");
     });
 
+    it("should populate buffer when archiving to buffer", async () => {
+      const archive: DestinationBufferAsset = {
+        buffer: null,
+      };
+      await builder.toArchive(archive);
+      expect(archive.buffer).not.toBeNull();
+      expect(archive.buffer!.length).toBeGreaterThan(0);
+    });
+
+    it("should write archive to file", async () => {
+      const archivePath = path.join(tempDir, "archive_file_test.zip");
+      const archive = { path: archivePath };
+      await builder.toArchive(archive);
+
+      // Verify file was created and has content
+      expect(await fs.pathExists(archivePath)).toBe(true);
+      const stats = await fs.stat(archivePath);
+      expect(stats.size).toBeGreaterThan(0);
+    });
+
+    it("should construct reader directly from builder archive buffer", async () => {
+      // Enable c2pa archive format
+      loadC2paSettings(
+        JSON.stringify({
+          builder: {
+            generate_c2pa_archive: true,
+          },
+          verify: {
+            verify_after_reading: false,
+          },
+        }),
+      );
+
+      try {
+        // Create a builder
+        const simpleManifestDefinition = {
+          claim_generator_info: [
+            {
+              name: "c2pa_test",
+              version: "1.0.0",
+            },
+          ],
+          title: "Test_Manifest",
+          format: "image/jpeg",
+          assertions: [],
+          resources: { resources: {} },
+        };
+
+        const testBuilder = Builder.withJson(simpleManifestDefinition);
+
+        // Add an ingredient
+        await testBuilder.addIngredient(parent_json, source);
+
+        // Create an archive from the builder written to a buffer
+        const archive: DestinationBufferAsset = {
+          buffer: null,
+        };
+        await testBuilder.toArchive(archive);
+
+        // Verify buffer was populated
+        expect(archive.buffer).not.toBeNull();
+        expect(archive.buffer!.length).toBeGreaterThan(0);
+
+        // Construct a reader from the builder archive with mime-type "application/c2pa"
+        const reader = await Reader.fromAsset({
+          buffer: archive.buffer! as Buffer,
+          mimeType: "application/c2pa",
+        });
+        expect(reader).not.toBeNull();
+      } finally {
+        // Reset settings to defaults
+        resetSettings();
+      }
+    });
+
     it("should sign data with callback to file", async () => {
       const dest: FileAsset = {
         path: path.join(tempDir, "callback_signed.jpg"),

js-src/Builder.spec.ts

@@ -35,7 +35,7 @@ import type {
 import { IdentityAssertionSigner } from "./IdentityAssertion.js";
 
 export class Builder implements BuilderInterface {
-  private constructor(private builder: NeonBuilderHandle) {}
+  constructor(private builder: NeonBuilderHandle) {}
 
   static new(): Builder {
     const builder: NeonBuilderHandle = getNeonBinary().builderNew();
@@ -235,4 +235,8 @@ export class Builder implements BuilderInterface {
       value,
     );
   }
+
+  getHandle(): NeonBuilderHandle {
+    return this.builder;
+  }
 }

js-src/Builder.ts

@@ -172,7 +172,6 @@ describe("Reader", () => {
   });
 
   it("should write to a file", async () => {
-    let bytesWritten = 0;
     const outputPath = path.join(tempDir, "thumbnail.jpg");
     const reader = await Reader.fromAsset({
       path: "./tests/fixtures/CA.jpg",
@@ -181,12 +180,12 @@ describe("Reader", () => {
     const activeManifest = reader!.getActive();
     const uri = activeManifest?.thumbnail?.identifier;
 
-    if (uri !== undefined) {
-      bytesWritten = await reader!.resourceToAsset(uri, {
-        path: outputPath,
-      });
-    }
-    expect(bytesWritten).toBe(49690);
+    expect(uri).toBeDefined();
+    const bytesWritten = await reader!.resourceToAsset(uri!, {
+      path: outputPath,
+    });
+
+    expect(bytesWritten.bytes_written).toBe(49690);
     expect(fs.existsSync(outputPath));
   });
 

js-src/Reader.spec.ts

@@ -17,6 +17,7 @@ import { getNeonBinary } from "./binary.js";
 import type {
   DestinationAsset,
   ReaderInterface,
+  ResourceAsset,
   SourceAsset,
   NeonReaderHandle,
 } from "./types.d.ts";
@@ -36,7 +37,7 @@ export class Reader implements ReaderInterface {
     return getNeonBinary().readerIsEmbedded.call(this.reader);
   }
 
-  async resourceToAsset(uri: string, asset: DestinationAsset): Promise<number> {
+  async resourceToAsset(uri: string, asset: DestinationAsset): Promise<ResourceAsset> {
     return getNeonBinary().readerResourceToAsset.call(this.reader, uri, asset);
   }
 

js-src/Reader.ts

@@ -102,6 +102,13 @@ export type SourceAsset = SourceBufferAsset | FileAsset;
  */
 export type DestinationAsset = DestinationBufferAsset | FileAsset;
 
+/**
+ * The return type of resourceToAsset.
+ * When the asset is a file, returns the number of bytes written.
+ * When the asset is a buffer, returns an object with the buffer and bytes written.
+ */
+export type ResourceAsset = { buffer: Buffer; bytes_written: number };
+
 /**
  * A signer that uses a local certificate and private key to sign data
  */
@@ -315,6 +322,11 @@ export interface BuilderInterface {
    * @returns The manifest definition
    */
   updateManifestProperty(property: string, value: string | ClaimVersion): void;
+
+  /**
+   * Get the internal handle for use with Neon bindings
+   */
+  getHandle(): NeonBuilderHandle;
 }
 
 export interface ReaderInterface {
@@ -336,9 +348,14 @@ export interface ReaderInterface {
   /**
    * Write a resource to a buffer or file
    * @param uri The URI of the resource
-   * @param filePath The path to the file
+   * @param output The destination asset (file or buffer)
+   * @returns When output is a file, returns the number of bytes written.
+   *          When output is a buffer, returns an object with the buffer and bytes written.
    */
-  resourceToAsset(uri: string, output: DestinationAsset): Promise<number>;
+  resourceToAsset(
+    uri: string,
+    output: DestinationAsset,
+  ): Promise<ResourceAsset>;
 
   /**
    * Get the internal handle for use with Neon bindings

js-src/types.d.ts

@@ -51,6 +51,9 @@ pub enum Error {
     #[error("Settings handling failed: {0}")]
     Settings(String),
 
+    #[error("Reading failed: {0}")]
+    Reading(String),
+
     #[error("Signing failed: {0}")]
     Signing(String),
 

src/error.rs

@@ -235,25 +235,47 @@ impl NeonBuilder {
 
     pub fn to_archive(mut cx: FunctionContext) -> JsResult<JsPromise> {
         let this = cx.this::<JsBox<Self>>()?;
-        let dest = cx
-            .argument::<JsObject>(0)
-            .and_then(|obj| parse_asset(&mut cx, obj))?;
+        let dest_obj = cx.argument::<JsObject>(0)?;
+        let dest = parse_asset(&mut cx, dest_obj)?;
+        let is_buffer = dest.name() == "destination_buffer";
         let builder = Arc::clone(&this.builder);
+        let dest_obj_root: Arc<Root<JsObject>> = Arc::new(Root::new(&mut cx, &dest_obj));
 
         let promise = cx
             .task(move || {
                 // Block on acquiring the async mutex lock
+                // Settings are automatically applied when runtime() is called
                 let rt = runtime();
                 let mut builder = rt.block_on(async { builder.lock().await });
 
-                dest.write_stream().and_then(|dest_stream| {
-                    builder.to_archive(dest_stream)?;
-                    Ok(())
+                dest.write_stream().and_then(|mut dest_stream| {
+                    builder.to_archive(&mut dest_stream)?;
+                    if is_buffer {
+                        let mut archive_data = Vec::new();
+                        dest_stream
+                            .rewind()
+                            .map_err(|e| Error::Asset(format!("Failed to rewind stream: {e}")))?;
+                        dest_stream
+                            .read_to_end(&mut archive_data)
+                            .map_err(|e| Error::Asset(format!("Failed to read stream: {e}")))?;
+                        Ok(Some(archive_data))
+                    } else {
+                        Ok(None)
+                    }
                 })
             })
-            .promise(move |mut cx, result: Result<(), Error>| match result {
-                Ok(_) => Ok(cx.undefined()),
-                Err(err) => as_js_error(&mut cx, err).and_then(|err| cx.throw(err)),
+            .promise(move |mut cx, result: Result<Option<Vec<u8>>, Error>| {
+                match result {
+                    Ok(Some(archive_data)) => {
+                        // If the output is a buffer, populate it with the archive data
+                        let buffer = JsBuffer::from_slice(&mut cx, &archive_data)?;
+                        let dest_obj = dest_obj_root.to_inner(&mut cx);
+                        dest_obj.set(&mut cx, "buffer", buffer)?;
+                        Ok(cx.undefined())
+                    }
+                    Ok(None) => Ok(cx.undefined()),
+                    Err(err) => as_js_error(&mut cx, err).and_then(|err| cx.throw(err)),
+                }
             });
         Ok(promise)
     }