feat: add addIngredientFromReader method (#36)

* feat: add addIngredientFromReader method

Author: cdmurph32

.changeset/odd-banks-write.md

@@ -0,0 +1,5 @@
+---
+"@contentauth/c2pa-node": patch
+---
+
+Add addIngredientFromReader method

js-src/Builder.spec.ts

@@ -696,11 +696,15 @@ describe("Builder", () => {
       expect(actionsAssertion).toBeDefined();
       if (isActionsAssertion(actionsAssertion)) {
         const actions = actionsAssertion.data.actions;
-        const editedAction = actions.find((a: any) => a.action === "c2pa.edited");
+        const editedAction = actions.find(
+          (a: any) => a.action === "c2pa.edited",
+        );
         expect(editedAction).toBeDefined();
         expect(editedAction?.action).toBe("c2pa.edited");
       } else {
-        throw new Error("Actions assertion does not have the expected structure");
+        throw new Error(
+          "Actions assertion does not have the expected structure",
+        );
       }
     });
 
@@ -760,5 +764,48 @@ describe("Builder", () => {
       expect(addedIngredient?.instance_id).toBe("ingredient-12345");
       expect(addedIngredient?.relationship).toBe("componentOf");
     });
+
+    it("should add ingredient from reader", async () => {
+      const builder1 = Builder.new();
+      builder1.setIntent("edit" as any);
+      const signer = LocalSigner.newSigner(publicKey, privateKey, "es256");
+      const dest1: DestinationBufferAsset = {
+        buffer: null,
+      };
+      builder1.sign(signer, source, dest1);
+
+      // Read the signed file back with Reader
+      const reader = await Reader.fromAsset({
+        buffer: dest1.buffer! as Buffer,
+        mimeType: "image/jpeg",
+      });
+      expect(reader).not.toBeNull();
+
+      // Create a new builder and add ingredient from the reader
+      const builder2 = Builder.new();
+      const ingredient = builder2.addIngredientFromReader(reader!);
+      expect(ingredient).toBeDefined();
+
+      // Verify the ingredient was added to the builder
+      const definition = builder2.getManifestDefinition();
+      expect(definition.ingredients).toBeDefined();
+      expect(definition.ingredients!.length).toBeGreaterThan(0);
+
+      // Sign again with the new builder
+      const dest2: DestinationBufferAsset = {
+        buffer: null,
+      };
+      builder2.sign(signer, source, dest2);
+
+      // Verify the ingredient is in the signed manifest
+      const reader2 = await Reader.fromAsset({
+        buffer: dest2.buffer! as Buffer,
+        mimeType: "image/jpeg",
+      });
+      expect(reader2).not.toBeNull();
+      const activeManifest = reader2!.getActive();
+      expect(activeManifest?.ingredients).toBeDefined();
+      expect(activeManifest?.ingredients?.length).toBe(1);
+    });
   });
 });

js-src/Builder.ts

@@ -11,7 +11,11 @@
 // specific language governing permissions and limitations under
 // each license.
 
-import type { BuilderIntent, Manifest } from "@contentauth/c2pa-types";
+import type {
+  BuilderIntent,
+  Ingredient,
+  Manifest,
+} from "@contentauth/c2pa-types";
 
 import { getNeonBinary } from "./binary.js";
 import type {
@@ -24,6 +28,7 @@ import type {
   JsCallbackSignerConfig,
   LocalSignerInterface,
   ManifestAssertionKind,
+  ReaderInterface,
   SourceAsset,
   NeonBuilderHandle,
 } from "./types.d.ts";
@@ -109,6 +114,15 @@ export class Builder implements BuilderInterface {
     }
   }
 
+  addIngredientFromReader(reader: ReaderInterface): Ingredient {
+    const readerHandle = reader.getHandle();
+    const result = getNeonBinary().builderAddIngredientFromReader.call(
+      this.builder,
+      readerHandle,
+    );
+    return JSON.parse(result);
+  }
+
   async toArchive(asset: DestinationAsset): Promise<void> {
     return getNeonBinary().builderToArchive.call(this.builder, asset);
   }
@@ -124,7 +138,7 @@ export class Builder implements BuilderInterface {
   ): Buffer {
     return getNeonBinary().builderSign.call(
       this.builder,
-      signer.signer(),
+      signer.getHandle(),
       input,
       output,
     );
@@ -138,7 +152,7 @@ export class Builder implements BuilderInterface {
     const input: FileAsset = { path: filePath };
     return getNeonBinary().builderSign.call(
       this.builder,
-      signer.signer(),
+      signer.getHandle(),
       input,
       output,
     );
@@ -182,7 +196,7 @@ export class Builder implements BuilderInterface {
     input: SourceAsset,
     output: DestinationAsset,
   ): Promise<Buffer> {
-    const neonHandle = signer.signer();
+    const neonHandle = signer.getHandle();
     const isIdentity = signer instanceof IdentityAssertionSigner;
     const neonFn = isIdentity
       ? getNeonBinary().builderIdentitySignAsync

js-src/IdentityAssertion.spec.ts

@@ -171,7 +171,7 @@ describe("IdentityAssertionBuilder", () => {
     });
 
     // Create and configure the identity assertion
-    const iaSigner = IdentityAssertionSigner.new(c2paSigner.signer());
+    const iaSigner = IdentityAssertionSigner.new(c2paSigner.getHandle());
     const iab =
       await IdentityAssertionBuilder.identityBuilderForCredentialHolder(
         cawgSigner,

js-src/IdentityAssertion.ts

@@ -32,7 +32,7 @@ export class IdentityAssertionBuilder
     credentialHolder: CallbackCredentialHolderInterface,
   ): Promise<IdentityAssertionBuilder> {
     const builder = getNeonBinary().identityBuilderForCredentialHolder(
-      credentialHolder.signer(),
+      credentialHolder.getHandle(),
     );
     return new IdentityAssertionBuilder(builder);
   }
@@ -72,7 +72,7 @@ export class IdentityAssertionSigner
     );
   }
 
-  signer(): NeonIdentityAssertionSignerHandle {
+  getHandle(): NeonIdentityAssertionSignerHandle {
     return this._signer;
   }
 }
@@ -84,7 +84,7 @@ export class CallbackCredentialHolder
     private callbackCredentialHolder: NeonCallbackCredentialHolderHandle,
   ) {}
 
-  signer(): NeonCallbackCredentialHolderHandle {
+  getHandle(): NeonCallbackCredentialHolderHandle {
     return this.callbackCredentialHolder;
   }
 

js-src/Reader.ts

@@ -72,4 +72,8 @@ export class Reader implements ReaderInterface {
 
     return manifestStore.manifests[activeManifest];
   }
+
+  getHandle(): NeonReaderHandle {
+    return this.reader;
+  }
 }

js-src/Signer.ts

@@ -59,15 +59,15 @@ export class LocalSigner implements LocalSignerInterface {
     return getNeonBinary().localSignerTimeAuthorityUrl.call(this.localSigner);
   }
 
-  signer(): NeonLocalSignerHandle {
+  getHandle(): NeonLocalSignerHandle {
     return this.localSigner;
   }
 }
 
 export class CallbackSigner implements CallbackSignerInterface {
   constructor(private callbackSigner: NeonCallbackSignerHandle) {}
 
-  signer(): NeonCallbackSignerHandle {
+  getHandle(): NeonCallbackSignerHandle {
     return this.callbackSigner;
   }
 

js-src/types.d.ts

@@ -15,6 +15,7 @@
 import { Buffer } from "buffer";
 import type {
   BuilderIntent,
+  Ingredient,
   Manifest,
   ManifestStore,
 } from "@contentauth/c2pa-types";
@@ -110,7 +111,7 @@ export interface LocalSignerInterface {
   certs(): Array<Buffer>;
   reserveSize(): number;
   timeAuthorityUrl(): string | undefined;
-  signer(): NeonLocalSignerHandle;
+  getHandle(): NeonLocalSignerHandle;
 }
 
 /**
@@ -123,14 +124,14 @@ export interface CallbackSignerInterface {
   reserveSize(): number;
   timeAuthorityUrl(): string | undefined;
   directCoseHandling(): boolean;
-  signer(): NeonCallbackSignerHandle;
+  getHandle(): NeonCallbackSignerHandle;
 }
 
 export interface CallbackCredentialHolderInterface {
   sigType(): string;
   reserveSize(): number;
   sign(payload: SignerPayload): Promise<Buffer>;
-  signer(): NeonCallbackCredentialHolderHandle;
+  getHandle(): NeonCallbackCredentialHolderHandle;
 }
 
 /**
@@ -235,6 +236,12 @@ export interface BuilderInterface {
     ingredient?: SourceAsset,
   ): Promise<void>;
 
+  /**
+   * Add an ingredient to the manifest from a Reader
+   * @param reader The Reader object of the ingredient
+   */
+  addIngredientFromReader(reader: ReaderInterface): Ingredient;
+
   /**
    * Convert the Builder into a archive formatted buffer or file
    * @param asset The file or buffer for the archive
@@ -332,6 +339,11 @@ export interface ReaderInterface {
    * @param filePath The path to the file
    */
   resourceToAsset(uri: string, output: DestinationAsset): Promise<number>;
+
+  /**
+   * Get the internal handle for use with Neon bindings
+   */
+  getHandle(): NeonReaderHandle;
 }
 
 export interface IdentityAssertionSignerInterface {
@@ -345,7 +357,7 @@ export interface IdentityAssertionSignerInterface {
     identityAssertionBuilder: IdentityAssertionBuilderInterface,
   ): void;
 
-  signer(): NeonIdentityAssertionSignerHandle;
+  getHandle(): NeonIdentityAssertionSignerHandle;
 }
 
 export interface IdentityAssertionBuilderInterface {

src/lib.rs

@@ -55,6 +55,10 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
         "builderAddIngredientFromAsset",
         neon_builder::NeonBuilder::add_ingredient_from_asset,
     )?;
+    cx.export_function(
+        "builderAddIngredientFromReader",
+        neon_builder::NeonBuilder::add_ingredient_from_reader,
+    )?;
     cx.export_function("builderToArchive", neon_builder::NeonBuilder::to_archive)?;
     cx.export_function(
         "builderFromArchive",

src/neon_builder.rs

@@ -14,6 +14,7 @@
 use crate::asset::parse_asset;
 use crate::error::{as_js_error, Error};
 use crate::neon_identity_assertion_signer::NeonIdentityAssertionSigner;
+use crate::neon_reader::NeonReader;
 use crate::neon_signer::{CallbackSignerConfig, NeonCallbackSigner, NeonLocalSigner};
 use crate::runtime::runtime;
 use c2pa::{Builder, BuilderIntent, Ingredient};
@@ -92,8 +93,8 @@ impl NeonBuilder {
         let rt = runtime();
         let this = cx.this::<JsBox<Self>>()?;
         let action_json = cx.argument::<JsString>(0)?.value(&mut cx);
-        let action: c2pa::assertions::Action = serde_json::from_str(&action_json)
-            .or_else(|err| cx.throw_error(err.to_string()))?;
+        let action: c2pa::assertions::Action =
+            serde_json::from_str(&action_json).or_else(|err| cx.throw_error(err.to_string()))?;
         let mut builder = rt.block_on(async { this.builder.lock().await });
         builder
             .add_action(action)
@@ -217,6 +218,21 @@ impl NeonBuilder {
         Ok(promise)
     }
 
+    pub fn add_ingredient_from_reader(mut cx: FunctionContext) -> JsResult<JsString> {
+        let rt = runtime();
+        let this = cx.this::<JsBox<Self>>()?;
+        let reader = cx.argument::<JsBox<NeonReader>>(0)?.reader();
+
+        let mut builder = rt.block_on(async { this.builder.lock().await });
+        let reader = rt.block_on(async { reader.lock().await });
+        let ingredient = builder
+            .add_ingredient_from_reader(&reader)
+            .or_else(|err| cx.throw_error(err.to_string()))?;
+        let json =
+            serde_json::to_string(&ingredient).or_else(|err| cx.throw_error(err.to_string()))?;
+        Ok(cx.string(json))
+    }
+
     pub fn to_archive(mut cx: FunctionContext) -> JsResult<JsPromise> {
         let this = cx.this::<JsBox<Self>>()?;
         let dest = cx