@eluvio/elv-client-js 4.0.144 → 4.0.146

package/src/client/ABRPublishing.js

@@ -13,7 +13,8 @@ const {
   ValidateLibrary,
   ValidateVersion,
   ValidateParameters,
-  ValidateWriteToken
+  ValidateWriteToken,
+  ValidateObject
 } = require("../Validation");
 
 // When `/abr_mezzanine/offerings` contains more than one entry, only 1 is the 'real' offering, the others are
@@ -98,13 +99,15 @@ exports.CreateProductionMaster = async function({
   structLogLevel="none"
 }) {
   ValidateLibrary(libraryId);
-  let id;
+  let objectId;
   const finalize = !writeToken;
 
   if(writeToken) {
-    id = this.utils.DecodeWriteToken(writeToken).objectId;
+    // if write token passed in, don't create a new object
+    objectId = this.utils.DecodeWriteToken(writeToken).objectId;
   } else {
-    ({id, writeToken} = await this.CreateContentObject({
+    // no write token supplied - create a new object and get write token
+    ({objectId, writeToken} = await this.CreateContentObject({
       libraryId,
       options: type ? { type } : {}
     }));
@@ -166,7 +169,7 @@ exports.CreateProductionMaster = async function({
 
           await this.UploadFilesFromS3({
             libraryId,
-            objectId: id,
+            objectId,
             writeToken,
             fileInfo: credentialSet.matched,
             region,
@@ -183,7 +186,7 @@ exports.CreateProductionMaster = async function({
     } else {
       await this.UploadFiles({
         libraryId,
-        objectId: id,
+        objectId,
         writeToken,
         fileInfo,
         callback,
@@ -192,11 +195,11 @@ exports.CreateProductionMaster = async function({
     }
   }
 
-  await this.CreateEncryptionConk({libraryId, objectId: id, writeToken, createKMSConk: true});
+  await this.CreateEncryptionConk({libraryId, objectId, writeToken, createKMSConk: true});
 
   const { logs, errors, warnings } = await this.CallBitcodeMethod({
     libraryId,
-    objectId: id,
+    objectId,
     writeToken,
     method: UrlJoin("media", "production_master", "init"),
     queryParams: {
@@ -211,7 +214,7 @@ exports.CreateProductionMaster = async function({
 
   await this.MergeMetadata({
     libraryId,
-    objectId: id,
+    objectId,
     writeToken,
     metadata: {
       ...(metadata || {}),
@@ -227,22 +230,22 @@ exports.CreateProductionMaster = async function({
     }
   });
 
-  let finalizeResponse;
+  let additionalReturnVals;
 
   if(finalize) {
-    finalizeResponse = await this.FinalizeContentObject({
+    additionalReturnVals = await this.FinalizeContentObject({
       libraryId,
-      objectId: id,
+      objectId,
       writeToken,
       commitMessage: "Create master",
       awaitCommitConfirmation: false
     });
   } else {
-    finalizeResponse = {
+    additionalReturnVals = {
       write_token: writeToken,
       type,
       qlib_id: libraryId,
-      id
+      id: objectId
     };
   }
 
@@ -250,7 +253,7 @@ exports.CreateProductionMaster = async function({
     errors: errors || [],
     logs: logs || [],
     warnings: warnings || [],
-    ...finalizeResponse
+    ...additionalReturnVals
   };
 };
 
@@ -265,8 +268,8 @@ exports.CreateProductionMaster = async function({
  * @param {boolean=} keepOtherStreams=false - If objectId is specified, whether to preserve existing streams with keys other than the ones specified in production master
  * @param {string} libraryId - ID of the mezzanine library
  * @param {string} masterVersionHash - The version hash of the production master content object
- * @param {string=} masterWriteToken - The write token of the production master content object draft. If provided, the object will not be finalized
- * @param {string=} writeToken - The write token of the mezzanine object draft. If specified, the object will not be finalized
+ * @param {string=} masterWriteToken - The write token of the production master content object draft.
+ * @param {string=} writeToken - The write token of the mezzanine object draft. If specified, the object will not be finalized, and no extra version of the object will be created to hold "bread crumb" metadata entry /lro_draft
  * @param {Object=} metadata - Additional metadata for mezzanine content object
  * @param {string} name - Name for mezzanine content object
  * @param {string=} objectId - ID of existing object (if not specified, new object will be created)
@@ -298,91 +301,94 @@ exports.CreateABRMezzanine = async function({
   structLogLevel="none",
   streamKeys
 }) {
+
+  if(!masterVersionHash && !masterWriteToken) {
+    throw Error("Neither master version hash nor master write token specified. One must be provided");
+  }
+
+  if(masterVersionHash && masterWriteToken) {
+    throw Error("Both master version hash and master write token specified. Only one can be provided");
+  }
+
+  // double-check library id for mez
   ValidateLibrary(libraryId);
 
+  // The following 2 vars are used only if masterWriteToken is passed in (to retrieve master name)
   let masterObjectId;
+  let masterLibId;
   if(masterVersionHash) {
+    // NOTE: masterObjectId is left undefined if masterWriteToken not passed in
     ValidateVersion(masterVersionHash);
   } else if(masterWriteToken) {
+    // determine master object id if a master write token was passed in
     ValidateWriteToken(masterWriteToken);
-
     masterObjectId = this.utils.DecodeWriteToken(masterWriteToken).objectId;
+    masterLibId = await client.ContentObjectLibraryId({masterObjectId});
   }
 
-  if(writeToken) {
-    ValidateWriteToken(writeToken);
-
-    if(!objectId) {
-      objectId = this.utils.DecodeWriteToken(writeToken).objectId;
-    }
-  }
+  // if pre-existing mez object id passed in, validate
+  if(objectId) ValidateObject(objectId);
 
-  if(!masterVersionHash && !masterWriteToken) {
-    throw Error("Master version hash and master write token not specified. One must be provided");
-  }
+  // if mez write token supplied, validate it
+  if(writeToken) {
+    ValidateWriteToken(writeToken, objectId);
 
-  if(!objectId && (keepOtherStreams)) {
-    throw Error("Existing mezzanine object ID required in order to use 'keepOtherStreams'");
+    // if pre-existing mez object id not passed in, decode it from write token
+    objectId = objectId || this.utils.DecodeWriteToken(writeToken).objectId;
   }
+  // After above, if objectId is undefined then no mez writeToken was passed in, no mez objectId was passed in,
+  // meaning we must create a new object
+  const useExistingMez = !!objectId; // type coerce string or undefined to boolean: "" -> false, undefined -> false, all else -> true
 
-  if(addlOfferingSpecs && !abrProfile) {
-    throw Error("abrProfile required when using addlOfferingSpecs");
-  }
+  if(!objectId && (keepOtherStreams)) throw Error("Existing mezzanine object ID required in order to use 'keepOtherStreams'");
 
-  const existingMez = !!objectId;
+  if(addlOfferingSpecs && !abrProfile) throw Error("abrProfile required when using addlOfferingSpecs");
 
   let options = type ? { type } : {};
 
-  let id;
   const finalize = !writeToken;
 
-  if(existingMez) {
-    // Edit existing
-    if(writeToken) {
-      id = objectId;
-    } else {
-      ({writeToken, id} = await this.EditContentObject({
-        libraryId,
-        objectId,
-        options
-      }));
-    }
-  } else {
-    // Create new
-    const createResponse = await this.CreateContentObject({
+  // are we ingesting to an existing mez (and did NOT supply a write token?)
+  if(useExistingMez && !writeToken) {
+    // then we need to obtain a write token for the existing object
+    ({writeToken} = await this.EditContentObject({
       libraryId,
+      objectId,
       options
-    });
+    }));
+  }
 
-    id = createResponse.id;
-    writeToken = createResponse.write_token;
+  // if we are not using an existing mez, we need to create a brand new object (in draft form)
+  if(!useExistingMez) {
+    // Create new mez object
+    ({objectId, writeToken} = await this.CreateContentObject({
+      libraryId,
+      options
+    }));
   }
 
-  await this.CreateEncryptionConk({libraryId, objectId: id, writeToken, createKMSConk: true});
+  // from here forwards, objectId and writeToken can be assumed to be populated (both refer to mez)
 
+  // ensure this object has encryption/kms conk
+  await this.CreateEncryptionConk({libraryId, objectId, writeToken, createKMSConk: true});
 
-  let nameMetaPayload;
-  if(masterWriteToken) {
-    nameMetaPayload = {
-      libraryId,
-      objectId: masterObjectId,
-      writeToken: masterWriteToken
-    };
-  } else if(masterVersionHash) {
-    nameMetaPayload = {
-      versionHash: masterVersionHash
-    };
-  }
+  // figure out where to read master metadata from
+  const masterMetaSource = masterWriteToken ? {
+    libraryId: masterLibId,
+    objectId: masterObjectId,
+    writeToken: masterWriteToken
+  } : {versionHash: masterVersionHash};
 
   const masterName = await this.ContentObjectMetadata({
-    ...nameMetaPayload,
+    ...masterMetaSource,
     metadataSubtree: "public/name"
   });
 
   // Include authorization for library, master, and mezzanine
   let authorizationTokens = [];
-  authorizationTokens.push(await this.authClient.AuthorizationToken({libraryId, objectId: id, update: true}));
+  authorizationTokens.push(await this.authClient.AuthorizationToken({libraryId, objectId, update: true}));
   authorizationTokens.push(await this.authClient.AuthorizationToken({libraryId}));
+  // only 1 of the vars masterVersionHash and masterObjectId below will contain a value
   authorizationTokens.push(await this.authClient.AuthorizationToken({versionHash: masterVersionHash, objectId: masterObjectId}));
 
   const headers = {
@@ -398,7 +404,7 @@ exports.CreateABRMezzanine = async function({
     variant_key: variant
   };
 
-  let storeClear = false;
+  let storeClear;
   if(abrProfile) {
     body.abr_profile = abrProfile;
     storeClear = abrProfile.store_clear;
@@ -415,14 +421,14 @@ exports.CreateABRMezzanine = async function({
     // If mez parts are to be encrypted, generate encryption conks
     await this.EncryptionConk({
       libraryId,
-      objectId: id,
+      objectId,
       writeToken
     });
   }
 
   const {logs, errors, warnings} = await this.CallBitcodeMethod({
     libraryId,
-    objectId: id,
+    objectId,
     writeToken,
     method: UrlJoin("media", "abr_mezzanine", "init"),
     queryParams: {
@@ -465,12 +471,12 @@ exports.CreateABRMezzanine = async function({
     ...metadata.public.asset_metadata
   };
 
-  if(name || !existingMez) {
+  if(name || !useExistingMez) {
     metadata.name = name || `${masterName} Mezzanine`;
     metadata.public.name = name || `${masterName} Mezzanine`;
   }
 
-  if(description || !existingMez) {
+  if(description || !useExistingMez) {
     metadata.description = description || "";
     metadata.public.description = description || "";
   }
@@ -478,14 +484,14 @@ exports.CreateABRMezzanine = async function({
   // retrieve existing metadata to merge with updated metadata
   const existingMetadata = await this.ContentObjectMetadata({
     libraryId,
-    objectId: id,
+    objectId,
     writeToken,
   });
   // newer metadata values replace existing metadata, unless both new and old values are objects,
   // in which case their keys are merged recursively
   metadata = R.mergeDeepRight(existingMetadata, metadata);
 
-  if(!existingMez) {
+  if(!useExistingMez) {
     // set creation date
     metadata.elv_created_at = new Date().getTime();
   }
@@ -493,25 +499,25 @@ exports.CreateABRMezzanine = async function({
   // write metadata to mezzanine object
   await this.ReplaceMetadata({
     libraryId,
-    objectId: id,
+    objectId,
     writeToken,
     metadata
   });
 
-  let finalizeResponse;
+  let additionalReturnVals;
   if(finalize) {
-    finalizeResponse = await this.FinalizeContentObject({
+    additionalReturnVals = await this.FinalizeContentObject({
       libraryId,
-      objectId: id,
+      objectId,
       writeToken,
       commitMessage: "Create ABR mezzanine"
     });
   } else {
-    finalizeResponse = {
+    additionalReturnVals = {
       write_token: writeToken,
       type,
       qlib_id: libraryId,
-      id
+      id: objectId
     };
   }
 
@@ -519,7 +525,7 @@ exports.CreateABRMezzanine = async function({
     logs: logs || [],
     warnings: warnings || [],
     errors: errors || [],
-    ...finalizeResponse
+    ...additionalReturnVals
   };
 };
 
@@ -530,7 +536,7 @@ exports.CreateABRMezzanine = async function({
  * @namedParams
  * @param {string} libraryId - ID of the mezzanine library
  * @param {string} objectId - ID of the mezzanine object
- * @param {string=} writeToken - Write token of the mezzanine object draft. If provided, the object will not be finalized
+ * @param {string=} writeToken - Write token of the mezzanine object draft. If provided, no "bread crumb" metadata /lro_draft will be created, nor saved as an extra finalized version
  * @param {Array<Object>=} access - Array of S3 credentials, along with path matching regexes - Required if any files in the masters are S3 references (See CreateProductionMaster method)
  * - Format: {region, bucket, accessKey, secret}
  * @param {number[]} jobIndexes - Array of LRO job indexes to start. LROs are listed in a map under metadata key /abr_mezzanine/offerings/(offeringKey)/mez_prep_specs/, and job indexes start with 0, corresponding to map keys in alphabetical order
@@ -546,12 +552,11 @@ exports.StartABRMezzanineJobs = async function({
 }) {
   ValidateParameters({libraryId, objectId});
 
-  if(writeToken) {
-    ValidateWriteToken(writeToken);
+  const writeTokenSupplied = !!writeToken;
 
-    if(!objectId) {
-      objectId = this.utils.DecodeWriteToken(writeToken).objectId;
-    }
+  if(writeTokenSupplied) {
+    ValidateWriteToken(writeToken, objectId);
+    objectId = objectId || this.utils.DecodeWriteToken(writeToken).objectId;
   }
 
   const lastJobOfferingsInfo = await this.ContentObjectMetadata({
@@ -595,60 +600,51 @@ exports.StartABRMezzanineJobs = async function({
     ...authorizationTokens
   ];
 
-  const headers = {
-    Authorization: authorizationTokens.map(token => `Bearer ${token}`).join(",")
-  };
-
-  let processingDraft;
-  if(writeToken) {
-    const nodeUrl = await this.WriteTokenNodeUrlNetwork({writeToken});
-
-    processingDraft = {
-      write_token: writeToken,
-      nodeUrl
+  const headers = {Authorization: authorizationTokens.map(token => `Bearer ${token}`).join(",")};
+
+  let breadCrumb;
+  let breadCrumbHash;
+  // If we did not have a write token passed in, get a new write token for the LROs to write to
+  if(!writeTokenSupplied) {
+    const lroWorkingDraft = await this.EditContentObject({libraryId, objectId});
+    writeToken = lroWorkingDraft.writeToken;
+
+    // Save this write token (and node url, and offering key) to ANOTHER, NEW write token in order to
+    // record "bread crumb" metadata at /lro_draft, and save (finalize) this second write token
+    const breadCrumbDraft = await this.EditContentObject({libraryId, objectId});
+    breadCrumb = {
+      write_token: lroWorkingDraft.writeToken,
+      node: lroWorkingDraft.nodeUrl,
+      offering: offeringKey
     };
-  } else {
-    processingDraft = await this.EditContentObject({libraryId, objectId});
-  }
-
-  const lroInfo = {
-    write_token: processingDraft.write_token,
-    node: processingDraft.nodeUrl,
-    offering: offeringKey
-  };
 
-  // Update metadata with LRO version write token
-  let finalizeResponse;
-  if(writeToken) {
-    await this.ReplaceMetadata({
-      libraryId,
-      objectId,
-      writeToken,
-      metadataSubtree: "lro_draft",
-      metadata: lroInfo
-    });
-  } else {
-    const statusDraft = await this.EditContentObject({libraryId, objectId});
     await this.ReplaceMetadata({
       libraryId,
       objectId,
-      writeToken: statusDraft.write_token,
+      writeToken: breadCrumbDraft.writeToken,
       metadataSubtree: "lro_draft",
-      metadata: lroInfo
+      metadata: breadCrumb
     });
 
-    finalizeResponse = await this.FinalizeContentObject({
+    const finalizeResponse = await this.FinalizeContentObject({
       libraryId,
       objectId,
-      writeToken: statusDraft.write_token,
-      commitMessage: "Mezzanine LRO status"
+      writeToken: breadCrumbDraft.write_token,
+      commitMessage: "Save mez LRO write token to /lro_draft"
     });
+    breadCrumbHash = finalizeResponse.hash;
   }
 
+  // make sure we have correct nodeUrl for this token
+  const nodeUrl = await this.WriteTokenNodeUrlNetwork({writeToken});
+  // tell http client what node to contact for this write token
+  this.RecordWriteToken({writeToken, fabricNodeUrl: nodeUrl});
+
+  // Make the API call that actually starts the LROs
   const {data, errors, warnings, logs} = await this.CallBitcodeMethod({
     libraryId,
     objectId,
-    writeToken: processingDraft.write_token,
+    writeToken,
     headers,
     method: UrlJoin("media", "abr_mezzanine", "prep_start"),
     constant: false,
@@ -660,10 +656,10 @@ exports.StartABRMezzanineJobs = async function({
   });
 
   return {
-    hash: finalizeResponse ? finalizeResponse.hash : "",
-    lro_draft: lroInfo,
-    writeToken: processingDraft.write_token,
-    nodeUrl: processingDraft.nodeUrl,
+    hash: breadCrumbHash,
+    lro_draft: breadCrumb,
+    writeToken,
+    nodeUrl,
     data,
     logs: logs || [],
     warnings: warnings || [],
@@ -675,6 +671,10 @@ exports.StartABRMezzanineJobs = async function({
  * Retrieve node and write token for a mezzanine's current offering preparation job (if any).
  * Also returns the offering key.
  *
+ * This information is contained in metadata at /lro_draft, in an extra version of the object
+ * that gets created and finalized as part of creating a mezzanine. This serves as a "bread crumb trail" to
+ * allow users to find the active draft/write token that the ingest LROs are writing to.
+ *
  * @methodGroup ABR Publishing
  * @namedParams
  * @param {string} libraryId - ID of the library
@@ -682,11 +682,10 @@ exports.StartABRMezzanineJobs = async function({
  *
  * @return {Promise<Object>} - LRO status
  */
-exports.LRODraftInfo = async function({libraryId, objectId, writeToken}) {
+exports.LRODraftInfo = async function({libraryId, objectId}) {
   const standardPathContents = await this.ContentObjectMetadata({
     libraryId,
     objectId,
-    writeToken,
     metadataSubtree: "lro_draft"
   });
 
@@ -728,53 +727,74 @@ exports.LRODraftInfo = async function({libraryId, objectId, writeToken}) {
 
 /**
  * Retrieve status information for mezzanine transcoding jobs, aka long running operations (LROs) on the given object.
+ * If a write token is passed in, its draft will be checked directly by lookiing at /lro_status.
+ * If a write token is not passed in, then the latest version of objectId will be checked for "bread crumb" entry
+ * at /lro_draft, to determine the write token that current ingest LRO(s) are writing to.
  *
  * @methodGroup ABR Publishing
  * @namedParams
  * @param {string} libraryId - ID of the library
  * @param {string} objectId - ID of the object
+ * @param {string=} writeToken - Write token of the active draft (that the transcode LROs are writing to)
  *
  * @return {Promise<Object>} - LRO status
  */
-exports.LROStatus = async function({libraryId, objectId, writeToken}) {
+exports.LROStatus = async function({libraryId, objectId, writeToken= ""}) {
   ValidateParameters({libraryId, objectId});
 
-  const lroDraft = await this.LRODraftInfo({libraryId, objectId, writeToken});
-
-  this.RecordWriteToken({writeToken: lroDraft.write_token, fabricNodeUrl: lroDraft.node});
+  let activeWriteToken;
+  if(writeToken) {
+    ValidateWriteToken(writeToken, objectId);
+    activeWriteToken = writeToken;
+  } else {
+    const lroDraft = await this.LRODraftInfo({libraryId, objectId});
+    activeWriteToken = lroDraft.write_token;
+    const fabricNodeUrl = await this.WriteTokenNodeUrlNetwork({writeToken: activeWriteToken});
+    this.RecordWriteToken({writeToken: lroDraft.write_token, fabricNodeUrl});
+  }
 
   return await this.ContentObjectMetadata({
     libraryId,
     objectId,
-    writeToken,
+    writeToken: activeWriteToken,
     metadataSubtree: "lro_status"
   });
 };
 
 /**
- * Finalize a mezzanine object after all jobs have finished
+ * Process completed mezzanine transcoding LRO(s), creating the final offering(s) from the transcode(s)
+ * Unless a writeToken is passed in, finalize the mez object working draft as well.
+ *
+ * If a writeToken is not passed in, then it will be retrieved from /lro_draft of most recent version of object.
+ * This is a "bread crumb" entry that gets created by StartABRMezzanineJobs() - unless a writeToken was passed in to StartABRMezzanineJobs() also.
  *
  * @methodGroup ABR Publishing
  * @namedParams
  * @param {string} libraryId - ID of the mezzanine library
  * @param {string} objectId - ID of the mezzanine object
- * @param {string} writeToken - Write token for the mezzanine object. If specified, the object will not be finalized.
+ * @param {string=} writeToken - Write token for the mezzanine object. If specified, the object will not be finalized.
  * @param {function=} preFinalizeFn - A function to call before finalizing changes, to allow further modifications to offering. The function will be invoked with {elvClient, nodeUrl, writeToken} to allow access to the draft and MUST NOT finalize the draft.
  * @param {boolean=} preFinalizeThrow - If set to `true` then any error thrown by preFinalizeFn will not be caught. Otherwise, any exception will be appended to the `warnings` array returned after finalization.
  *
  * @return {Promise<Object>} - The finalize response for the mezzanine object, as well as any logs, warnings and errors from the finalization
  */
-exports.FinalizeABRMezzanine = async function({libraryId, objectId, preFinalizeFn, preFinalizeThrow, writeToken}) {
+exports.FinalizeABRMezzanine = async function({libraryId, objectId, preFinalizeFn, preFinalizeThrow, writeToken=""}) {
   ValidateParameters({libraryId, objectId});
 
-  if(writeToken) {
-    ValidateWriteToken(writeToken);
-  }
+  const writeTokenSupplied = !!writeToken;
 
-  const nodeUrl = await this.WriteTokenNodeUrlNetwork({writeToken});
+  if(writeTokenSupplied) {
+    ValidateWriteToken(writeToken, objectId);
+    objectId = objectId || this.utils.DecodeWriteToken(writeToken).objectId;
+  } else {
+    // get write token from draft info
+    const lroDraft = await this.LRODraftInfo({libraryId, objectId});
+    writeToken = lroDraft.write_token;
+  }
 
+  const fabricNodeUrl = await this.WriteTokenNodeUrlNetwork({writeToken});
   // tell http client what node to contact for this write token
-  this.RecordWriteToken({writeToken: writeToken, fabricNodeUrl: nodeUrl});
+  this.RecordWriteToken({writeToken, fabricNodeUrl});
 
   const lastJobOfferingsInfo = await this.ContentObjectMetadata({
     libraryId,
@@ -786,22 +806,20 @@ exports.FinalizeABRMezzanine = async function({libraryId, objectId, preFinalizeF
   const offeringKey = MezJobMainOfferingKey(lastJobOfferingsInfo);
   const masterHash = lastJobOfferingsInfo[offeringKey].prod_master_hash;
 
-  let authPayload = {};
+  let masterIdentifier = {};
   if(masterHash.startsWith("tqw__")) {
-    authPayload["objectId"] = this.utils.DecodeWriteToken(masterHash).objectId;
+    masterIdentifier["objectId"] = this.utils.DecodeWriteToken(masterHash).objectId;
   } else {
-    authPayload["versionHash"] = masterHash;
+    masterIdentifier["versionHash"] = masterHash;
   }
 
   // Authorization token for mezzanine and master
   let authorizationTokens = [
     await this.authClient.AuthorizationToken({libraryId, objectId, update: true}),
-    await this.authClient.AuthorizationToken({...authPayload})
+    await this.authClient.AuthorizationToken({...masterIdentifier})
   ];
 
-  const headers = {
-    Authorization: authorizationTokens.map(token => `Bearer ${token}`).join(",")
-  };
+  const headers = {Authorization: authorizationTokens.map(token => `Bearer ${token}`).join(",")};
 
   const {data, errors, warnings, logs} = await this.CallBitcodeMethod({
     objectId,
@@ -831,16 +849,15 @@ exports.FinalizeABRMezzanine = async function({libraryId, objectId, preFinalizeF
     }
   }
 
-  let finalizeResponse = {};
-  if(!writeToken) {
-    finalizeResponse = await this.FinalizeContentObject({
-      libraryId,
-      objectId: objectId,
-      writeToken,
-      commitMessage: "Finalize ABR mezzanine",
-      awaitCommitConfirmation: false
-    });
-  }
+  // only finalize if we did NOT have a writeToken passed in
+  const finalizeResponse = writeTokenSupplied ? {} : await this.FinalizeContentObject({
+    libraryId,
+    objectId,
+    writeToken,
+    commitMessage: "Finalize ABR mezzanine",
+    awaitCommitConfirmation: false
+  });
+
 
   return {
     data,