@eluvio/elv-client-js 4.0.89 → 4.0.91

package/src/Utils.js

@@ -545,18 +545,40 @@ const Utils = {
     });
   },
 
-  ResponseToJson: async (response) => {
-    return Utils.ResponseToFormat("json", response);
+  /**
+   * Interprets an http response body obtained from an http call as JSON and returns result of parsing it.
+   *
+   * @param {Promise} response - An http response from node-fetch
+   * @param {boolean=} debug - Whether or not to log the body
+   * @param {Function} logFn - Log function to use if debug is truthy
+   * @return {*} - Result of parsing response body as JSON
+   */
+  ResponseToJson: async (response, debug = false, logFn) => {
+    return await Utils.ResponseToFormat("json", response, debug, logFn);
   },
 
-  ResponseToFormat: async (format, response) => {
+  /**
+   * Interprets an http response body obtained from an http call as a requested format and returns result of converting/formatting.
+   *
+   * @param {string} format - The format to use when interpreting response body (e.g. "json", "text" et. al.)
+   * @param {Promise} response - An http response from node-fetch
+   * @param {boolean=} debug - Whether or not to log a debug statement containing the body (ignored for formats other than "json" and "text")
+   * @param {Function} logFn - Log function to use if debug is truthy
+   * @return {*} - Result of converting response body into the requested format
+   */
+  ResponseToFormat: async (format, response, debug = false, logFn) => {
     response = await response;
+    let formattedBody;
 
     switch(format.toLowerCase()) {
       case "json":
-        return await response.json();
+        formattedBody = await response.json();
+        if(debug) logFn(`response body: ${JSON.stringify(formattedBody, null, 2)}`);
+        return formattedBody;
       case "text":
-        return await response.text();
+        formattedBody = await response.text();
+        if(debug) logFn(`response body: ${formattedBody}`);
+        return formattedBody;
       case "blob":
         return await response.blob();
       case "arraybuffer":

package/src/client/ContentAccess.js

@@ -390,13 +390,11 @@ exports.ContentLibrary = async function({libraryId}) {
 
   const path = UrlJoin("qlibs", libraryId);
 
-  const library = await this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId}),
-      method: "GET",
-      path: path
-    })
-  );
+  const library = await this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId}),
+    method: "GET",
+    path: path
+  });
 
   return {
     ...library,
@@ -566,14 +564,12 @@ exports.ContentObjects = async function({libraryId, filterOptions={}}) {
   this.Log("Filter options:");
   this.Log(filterOptions);
 
-  return await this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId}),
-      method: "GET",
-      path: path,
-      queryParams
-    })
-  );
+  return await this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId}),
+    method: "GET",
+    path: path,
+    queryParams
+  });
 };
 
 /**
@@ -597,13 +593,11 @@ exports.ContentObject = async function({libraryId, objectId, versionHash, writeT
 
   let path = UrlJoin("q", writeToken || versionHash || objectId);
 
-  return await this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId, objectId, versionHash}),
-      method: "GET",
-      path: path
-    })
-  );
+  return await this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, versionHash}),
+    method: "GET",
+    path: path
+  });
 };
 
 /**
@@ -919,22 +913,20 @@ exports.ContentObjectMetadata = async function({
 
   let metadata;
   try {
-    metadata = await this.utils.ResponseToJson(
-      this.HttpClient.Request({
-        headers: { "Authorization": authTokens.map(token => `Bearer ${token}`) },
-        queryParams: {
-          ...queryParams,
-          select,
-          remove,
-          link_depth: linkDepthLimit,
-          resolve: resolveLinks,
-          resolve_include_source: resolveIncludeSource,
-          resolve_ignore_errors: resolveIgnoreErrors,
-        },
-        method: "GET",
-        path: path
-      })
-    );
+    metadata = await this.HttpClient.RequestJsonBody({
+      headers: { "Authorization": authTokens.map(token => `Bearer ${token}`) },
+      queryParams: {
+        ...queryParams,
+        select,
+        remove,
+        link_depth: linkDepthLimit,
+        resolve: resolveLinks,
+        resolve_include_source: resolveIncludeSource,
+        resolve_ignore_errors: resolveIgnoreErrors,
+      },
+      method: "GET",
+      path: path
+    });
   } catch(error) {
     if(error.status !== 404) {
       throw error;
@@ -1066,13 +1058,11 @@ exports.ContentObjectVersions = async function({libraryId, objectId}) {
 
   let path = UrlJoin("qid", objectId);
 
-  return this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId, objectId}),
-      method: "GET",
-      path: path
-    })
-  );
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId}),
+    method: "GET",
+    path: path
+  });
 };
 
 /**
@@ -1143,13 +1133,11 @@ exports.LatestVersionHashV2 = async function({objectId, versionHash}) {
   try {
     let path = UrlJoin("q", objectId);
 
-    let q = await this.utils.ResponseToJson(
-      this.HttpClient.Request({
-        headers: await this.authClient.AuthorizationHeader({objectId}),
-        method: "GET",
-        path: path
-      })
-    );
+    let q = await this.HttpClient.RequestJsonBody({
+      headers: await this.authClient.AuthorizationHeader({objectId}),
+      method: "GET",
+      path: path
+    });
     latestHash = q.hash;
 
   } catch(error) {
@@ -1379,15 +1367,13 @@ exports.AvailableOfferings = async function({
       .flat()
       .filter(token => token);
 
-    return await this.utils.ResponseToJson(
-      this.HttpClient.Request({
-        path: path,
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${authorization.join(",")}`
-        }
-      })
-    );
+    return await this.HttpClient.RequestJsonBody({
+      path: path,
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${authorization.join(",")}`
+      }
+    });
   } catch(error) {
     if(error.status && parseInt(error.status) === 500) {
       return {};
@@ -1526,13 +1512,11 @@ exports.PlayoutOptions = async function({
   };
 
   const playoutOptions = Object.values(
-    await this.utils.ResponseToJson(
-      this.HttpClient.Request({
-        path,
-        method: "GET",
-        queryParams
-      })
-    )
+    await this.HttpClient.RequestJsonBody({
+      path,
+      method: "GET",
+      queryParams
+    })
   );
 
   if(!signedLink && linkTarget.versionHash) {
@@ -1638,17 +1622,14 @@ exports.PlayoutOptions = async function({
     playoutMap.multiview = true;
 
     playoutMap.AvailableViews = async () => {
-      return await this.utils.ResponseToFormat(
-        "json",
-        await this.HttpClient.Request({
-          path: UrlJoin("q", linkTarget.versionHash || versionHash, "rep", handler, offering, "views.json"),
-          method: "GET",
-          queryParams: {
-            sid: sessionId,
-            authorization
-          }
-        })
-      );
+      return await this.HttpClient.RequestJsonBody({
+        path: UrlJoin("q", linkTarget.versionHash || versionHash, "rep", handler, offering, "views.json"),
+        method: "GET",
+        queryParams: {
+          sid: sessionId,
+          authorization
+        }
+      });
     };
 
     playoutMap.SwitchView = async (view) => {
@@ -1882,7 +1863,9 @@ exports.CallBitcodeMethod = async function({
       path,
       queryParams,
       allowFailover: false
-    })
+    }),
+    this.HttpClient.debug,
+    this.HttpClient.Log.bind(this.HttpClient)
   );
 };
 

package/src/client/ContentManagement.js

@@ -183,8 +183,13 @@ exports.CreateContentType = async function({name, metadata={}, bitcode}) {
     path: path
   });
   // extract the url for the node that handled the request
+  // TODO: remove/simplify after we start using /nodes API call to get node URLs for write tokens
   const nodeUrl = (new URL(rawCreateResponse.url)).origin;
-  const createResponse = await this.utils.ResponseToJson(rawCreateResponse);
+  const createResponse = await this.utils.ResponseToJson(
+    rawCreateResponse,
+    this.HttpClient.debug,
+    this.HttpClient.Log.bind(this.HttpClient)
+  );
 
   // Record the node used in creating this write token
   this.RecordWriteToken({writeToken: createResponse.write_token, fabricNodeUrl: nodeUrl});
@@ -602,8 +607,14 @@ exports.CreateContentObject = async function({libraryId, objectId, options={}})
     path: path,
     body: options
   });
+  // extract the url for the node that handled the request
+  // TODO: remove/simplify after we start using /nodes API call to get node URLs for write tokens
   const nodeUrl = (new URL(rawCreateResponse.url)).origin;
-  const createResponse = await this.utils.ResponseToJson(rawCreateResponse);
+  const createResponse = await this.utils.ResponseToJson(
+    rawCreateResponse,
+    this.HttpClient.debug,
+    this.HttpClient.Log.bind(this.HttpClient)
+  );
 
   // Record the node used in creating this write token
   this.RecordWriteToken({writeToken: createResponse.write_token, fabricNodeUrl: nodeUrl});
@@ -773,8 +784,13 @@ exports.EditContentObject = async function({libraryId, objectId, options={}}) {
     body: options
   });
   // extract the url for the node that handled the request
+  // TODO: remove/simplify after we start using /nodes API call to get node URLs for write tokens
   const nodeUrl = (new URL(rawEditResponse.url)).origin;
-  const editResponse = await this.utils.ResponseToJson(rawEditResponse);
+  const editResponse = await this.utils.ResponseToJson(
+    rawEditResponse,
+    this.HttpClient.debug,
+    this.HttpClient.Log.bind(this.HttpClient)
+  );
 
   // Record the node used in creating this write token
   this.RecordWriteToken({writeToken: editResponse.write_token, fabricNodeUrl: nodeUrl});
@@ -957,14 +973,12 @@ exports.FinalizeContentObject = async function({
 
   let path = UrlJoin("q", writeToken);
 
-  const finalizeResponse = await this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
-      method: "POST",
-      path: path,
-      allowFailover: false
-    })
-  );
+  const finalizeResponse = await this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "POST",
+    path: path,
+    allowFailover: false
+  });
 
   this.Log(`Finalized: ${finalizeResponse.hash}`);
 
@@ -1006,7 +1020,8 @@ exports.PublishContentVersion = async function({objectId, versionHash, awaitComm
   });
 
   const abi = await this.ContractAbi({id: objectId});
-  const fromBlock = commit.blockNumber + 1;
+  const fromBlock = commit.blockNumber - 30; // due to block re-org
+
   const objectHash = await this.ExtractValueFromEvent({
     abi,
     event: commit,
@@ -1035,6 +1050,7 @@ exports.PublishContentVersion = async function({objectId, versionHash, awaitComm
         contractAddress: this.utils.HashToAddress(objectId),
         abi,
         fromBlock,
+        topics: [ Ethers.utils.id("VersionConfirm(address,address,string)") ],
         count: 1000
       });
 
@@ -1077,7 +1093,6 @@ exports.PublishContentVersion = async function({objectId, versionHash, awaitComm
       }
     }
   }
-
 };
 
 /**

package/src/client/Files.js

@@ -45,13 +45,11 @@ exports.ListFiles = async function({libraryId, objectId, path = "", versionHash,
 
   let urlPath = UrlJoin("q", writeToken || versionHash || objectId, "files_list", path);
 
-  return this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId, objectId, versionHash}),
-      method: "GET",
-      path: urlPath,
-    })
-  );
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, versionHash}),
+    method: "GET",
+    path: urlPath,
+  });
 };
 
 /**
@@ -121,7 +119,11 @@ exports.UploadFilesFromS3 = async function({
     }
   }
 
-  this.Log(`Uploading files from S3: ${libraryId} ${objectId} ${writeToken}`);
+  if(copy) {
+    this.Log(`Copying files from S3: ${libraryId} ${objectId} ${writeToken}`);
+  } else {
+    this.Log(`Adding links to files in S3: ${libraryId} ${objectId} ${writeToken}`);
+  }
 
   let encryption_key;
   if(encryption === "cgck") {
@@ -485,15 +487,13 @@ exports.CreateFileUploadJob = async function({libraryId, objectId, writeToken, o
 
   const path = UrlJoin("q", writeToken, "file_jobs");
 
-  return this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true, encryption}),
-      method: "POST",
-      path: path,
-      body,
-      allowFailover: false
-    })
-  );
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true, encryption}),
+    method: "POST",
+    path: path,
+    body,
+    allowFailover: false
+  });
 };
 
 exports.UploadStatus = async function({libraryId, objectId, writeToken, uploadId}) {
@@ -815,13 +815,11 @@ exports.ContentParts = async function({libraryId, objectId, versionHash}) {
 
   const path = UrlJoin("q", versionHash || objectId, "parts");
 
-  const response = await this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId, objectId, versionHash}),
-      method: "GET",
-      path: path
-    })
-  );
+  const response = await this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, versionHash}),
+    method: "GET",
+    path: path
+  });
 
   return response.parts;
 };
@@ -849,13 +847,11 @@ exports.ContentPart = async function({libraryId, objectId, versionHash, partHash
 
   let path = UrlJoin("q", versionHash || objectId, "parts", partHash);
 
-  return await this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId, objectId, versionHash}),
-      method: "GET",
-      path: path
-    })
-  );
+  return await this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, versionHash}),
+    method: "GET",
+    path: path
+  });
 };
 
 /**
@@ -1079,16 +1075,14 @@ exports.CreatePart = async function({libraryId, objectId, writeToken, encryption
 
   const path = UrlJoin("q", writeToken, "parts");
 
-  const openResponse = await this.utils.ResponseToJson(
-    this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true, encryption}),
-      method: "POST",
-      path,
-      bodyType: "BINARY",
-      body: "",
-      allowFailover: false
-    })
-  );
+  const openResponse = await this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true, encryption}),
+    method: "POST",
+    path,
+    bodyType: "BINARY",
+    body: "",
+    allowFailover: false
+  });
 
   return openResponse.part.write_token;
 };
@@ -1149,16 +1143,14 @@ exports.FinalizePart = async function({libraryId, objectId, writeToken, partWrit
   ValidateWriteToken(writeToken);
 
   const path = UrlJoin("q", writeToken, "parts");
-  return await this.utils.ResponseToJson(
-    await this.HttpClient.Request({
-      headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true, encryption}),
-      method: "POST",
-      path: UrlJoin(path, partWriteToken),
-      bodyType: "BINARY",
-      body: "",
-      allowFailover: false
-    })
-  );
+  return await this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true, encryption}),
+    method: "POST",
+    path: UrlJoin(path, partWriteToken),
+    bodyType: "BINARY",
+    body: "",
+    allowFailover: false
+  });
 };
 
 /**

package/src/client/LiveStream.js

@@ -1350,7 +1350,11 @@ exports.StreamConfig = async function({name, customSettings={}, probeMetadata})
   status.user_config = userConfig;
 
   // Get node URI from user config
-  const hostName = userConfig.url.replace("udp://", "").replace("rtmp://", "").replace("srt://", "").split(":")[0];
+  const parsedName = userConfig.url
+    .replace("udp://", "https://")
+    .replace("rtmp://", "https://")
+    .replace("srt://", "https://");
+  const hostName = new URL(parsedName).hostname;
   const streamUrl = new URL(userConfig.url);
 
   console.log("Retrieving nodes - matching", hostName);

package/testScripts/BasicObjectOperations.js

@@ -0,0 +1,93 @@
+/* eslint-disable no-console */
+
+const { ElvClient } = require("../src/ElvClient");
+
+const configUrl = "https://test.net955205.contentfabric.io/config";
+const libraryId = "ilibE6vhm2YCR6vZCtW9mope6Dbo2Tn"; // to create and edit content
+
+const Tool = async () => {
+
+  const client = await ElvClient.FromConfigurationUrl({configUrl});
+
+  let wallet = client.GenerateWallet();
+  let signer = wallet.AddAccount({
+    privateKey: process.env.PRIVATE_KEY
+  });
+
+  client.SetSigner({signer});
+  client.ToggleLogging(true);
+
+
+  try {
+    let start = new Date().getTime();
+    const {objectId, writeToken} = await client.CreateContentObject({
+      libraryId: libraryId,
+      options: {
+        meta: {commit: "Create Content-" + start.toString()}
+      }
+    });
+    let end = new Date().getTime();
+    let timeDifference = end - start;
+    console.log("content object completed after: ", timeDifference, "ms");
+
+    start = new Date().getTime();
+    const {hash} = await client.FinalizeContentObject({
+      libraryId,
+      objectId,
+      writeToken
+    });
+    end = new Date();
+    timeDifference = end - start;
+    console.log("finalize object completed after: ", timeDifference, "ms");
+
+    start = new Date().getTime();
+    const editResponse = await client.EditContentObject({
+      libraryId,
+      objectId,
+    });
+    end = new Date().getTime();
+    timeDifference = end - start;
+    console.log("edit object completed after: ", timeDifference, "ms");
+
+    const metadata = {
+      description: "edit content",
+    };
+
+    start = new Date().getTime();
+    await client.ReplaceMetadata({
+      libraryId,
+      objectId,
+      writeToken: editResponse.write_token,
+      metadata
+    });
+    end = new Date().getTime();
+    timeDifference = end - start;
+    console.log("replace metadata completed after: ", timeDifference, "ms");
+
+
+    start = new Date().getTime();
+    await client.FinalizeContentObject({
+      libraryId,
+      objectId,
+      writeToken: editResponse.write_token,
+    });
+    end = new Date().getTime();
+    timeDifference = end - start;
+    console.log("finalize object completed after: ", timeDifference, "ms");
+
+    console.log(`\nSuccessfully created new content version: ${hash}`);
+  } catch(error) {
+    console.error("Error creating content object:");
+    console.error(error);
+  }
+};
+
+const privateKey = process.env.PRIVATE_KEY;
+if(!privateKey) {
+  console.error("PRIVATE_KEY environment variable must be specified");
+  return;
+}
+
+Tool();
+
+