@eluvio/elv-client-js 4.2.25 → 4.2.29

package/utilities/lib/concerns/CloudFile.js

@@ -34,7 +34,10 @@ const accessMatchIndex = R.curry(
 const groupByPathMatch = (access, fileList) => R.groupBy(accessMatchIndex(access), fileList);
 
 const validateBucketMatch = R.curry((credentialSet, sourceFilePath) => {
-  const credentialSetBucket = removeTrailingSlash(credentialSet.remote_access.path);
+  const remotePath = credentialSet.remote_access.path;
+  if(!remotePath) return;
+
+  const credentialSetBucket = removeTrailingSlash(remotePath);
   // if full s3 path supplied, check bucket name
   const s3prefixMatch = s3BucketRegex.exec(sourceFilePath);
   if(s3prefixMatch) {
@@ -92,21 +95,24 @@ const New = context => {
     );
   };
 
-  const add = async ({libraryId, objectId, writeToken, files, access, encrypt, copy}) => {
+  const add = async ({libraryId, objectId, writeToken, files, access, encrypt, copy, resume}) => {
     if(kindOf(copy) === "undefined") copy = isCopy();
     files = files || context.args.files;
     const groupedFiles = groupByPathMatch(access, files);
-    validatePathMatchGroups(groupedFiles);
+    validatePathMatchGroups(access, groupedFiles);
 
     const client = await context.concerns.Client.get();
 
     // iterate over file groups, add to fabric object using credential set for group
     for(const [index, fileList] of R.toPairs(groupedFiles)) {
       const credentialSet = access[index];
-      const region = credentialSet.remote_access.storage_endpoint.region;
-      const bucket = removeTrailingSlash(credentialSet.remote_access.path);
-      const accessKey = credentialSet.remote_access.cloud_credentials.access_key_id;
-      const secret = credentialSet.remote_access.cloud_credentials.secret_access_key;
+      const remoteAccess = credentialSet.remote_access;
+      const cloudCredentials = remoteAccess.cloud_credentials;
+      const region = remoteAccess.storage_endpoint && remoteAccess.storage_endpoint.region;
+      const bucket = remoteAccess.path && removeTrailingSlash(remoteAccess.path);
+      const accessKey = cloudCredentials.access_key_id;
+      const secret = cloudCredentials.secret_access_key;
+      const signedUrl = cloudCredentials.signed_url;
 
       await client.UploadFilesFromS3({
         libraryId,
@@ -117,7 +123,9 @@ const New = context => {
         bucket,
         accessKey,
         secret,
+        signedUrl,
         copy,
+        resume,
         callback,
         encryption: encrypt ? "cgck" : "none"
       });
@@ -134,4 +142,4 @@ const New = context => {
   return {add, callback, credentialSet, fileInfo, isCopy};
 };
 
-module.exports = {blueprint, New};
+module.exports = {blueprint, New};

package/utilities/lib/concerns/LocalFile.js

@@ -19,7 +19,7 @@ const blueprint = {
 
 const New = context => {
 
-  const add = async ({libraryId, objectId, writeToken, fileInfo, encrypt}) => {
+  const add = async ({libraryId, objectId, writeToken, fileInfo, encrypt, resume}) => {
     const client = await context.concerns.Client.get();
     await client.UploadFiles({
       libraryId,
@@ -27,6 +27,7 @@ const New = context => {
       writeToken,
       fileInfo,
       callback,
+      resume,
       encryption: encrypt ? "cgck" : "none"
     });
   };

package/utilities/lib/data/network_specs.json

@@ -0,0 +1,13 @@
+{
+  "dev": {
+    "contentSpaceId": "ispc3ANoVSzNA3P6t7abLR69ho5YPPZU",
+    "networkId": 955210,
+    "networkName": "dev",
+    "fabricVersion": 3,
+    "fabricURIs": ["http://127.0.0.1:8008"],
+    "ethereumURIs": ["https://host-76-74-28-234.contentfabric.io/eth/"],
+    "fileServiceURIs": ["http://127.0.0.1:8008"],
+    "authServiceURIs": [],
+    "searchURIs": []
+  }
+}

package/utilities/lib/models/CredentialSet.js

@@ -16,17 +16,36 @@ const StorageEndpointModel = SealedModel({
 });
 
 const CloudCredentialsModel = SealedModel({
-  access_key_id: NonBlankString,
-  secret_access_key: NonBlankString
-});
+  access_key_id: [NonBlankString],
+  secret_access_key: [NonBlankString],
+  signed_url: [NonBlankString]
+}).assert(
+  function hasOneAuthenticationMethod(credentials) {
+    const hasAccessKey = Boolean(credentials.access_key_id);
+    const hasSecret = Boolean(credentials.secret_access_key);
+    const hasSignedUrl = Boolean(credentials.signed_url);
+
+    return hasSignedUrl
+      ? !hasAccessKey && !hasSecret
+      : hasAccessKey && hasSecret;
+  },
+  "cloud_credentials must contain either signed_url or both access_key_id and secret_access_key"
+);
 
 const RemoteAccessModel = ObjectModel({
   protocol: "s3",
   platform: "aws",
-  path: NonBlankString,
-  storage_endpoint: StorageEndpointModel,
+  path: [NonBlankString],
+  storage_endpoint: [StorageEndpointModel],
   cloud_credentials: CloudCredentialsModel
-});
+}).assert(
+  function hasLocationForAccessKeyCredentials(remoteAccess) {
+    if(remoteAccess.cloud_credentials.signed_url) return true;
+
+    return Boolean(remoteAccess.path && remoteAccess.storage_endpoint);
+  },
+  "path and storage_endpoint are required when using access key credentials"
+);
 
 const CredentialModel = ObjectModel({
   path_matchers: TypedArrayNonEmpty(NonBlankString),
@@ -43,4 +62,4 @@ module.exports = {
   CheckedCredentialSet,
   CredentialModel,
   CredentialSetModel,
-};
+};

package/utilities/tests/unit/lib/concerns/Client.test.js

@@ -0,0 +1,96 @@
+const {expect} = require("chai");
+
+const {ElvClient} = require("../../../../../src/ElvClient");
+const Client = require("../../../../lib/concerns/Client");
+
+const logger = {
+  error: () => {},
+  log: () => {}
+};
+
+const context = ({args={}, env={}} = {}) => ({
+  args: {
+    ethContractTimeout: 10,
+    ...args
+  },
+  concerns: {Logger: logger},
+  env: {
+    PRIVATE_KEY: "private-key",
+    ...env
+  }
+});
+
+const fakeClient = () => {
+  const nodeSelections = [];
+
+  return {
+    GenerateWallet: () => ({AddAccount: () => ({})}),
+    SetNodes: nodes => nodeSelections.push(nodes),
+    SetSigner: async () => {},
+    ToggleLogging: () => {},
+    nodeSelections
+  };
+};
+
+describe("Client concern", () => {
+  let originalFromConfigurationUrl;
+  let originalFromNetworkName;
+
+  beforeEach(() => {
+    originalFromConfigurationUrl = ElvClient.FromConfigurationUrl;
+    originalFromNetworkName = ElvClient.FromNetworkName;
+  });
+
+  afterEach(() => {
+    ElvClient.FromConfigurationUrl = originalFromConfigurationUrl;
+    ElvClient.FromNetworkName = originalFromNetworkName;
+  });
+
+  it("uses the main network by default", async () => {
+    let initArgs;
+    ElvClient.FromNetworkName = async args => {
+      initArgs = args;
+      return fakeClient();
+    };
+
+    await Client.New(context()).get();
+
+    expect(initArgs.networkName).to.equal("main");
+  });
+
+  it("uses a supplied config URL instead of the default network", async () => {
+    let initArgs;
+    ElvClient.FromConfigurationUrl = async args => {
+      initArgs = args;
+      return fakeClient();
+    };
+
+    await Client.New(context({args: {configUrl: "https://example.com/config"}})).get();
+
+    expect(initArgs.configUrl).to.equal("https://example.com/config");
+  });
+
+  it("uses an explicitly selected built-in network", async () => {
+    let initArgs;
+    ElvClient.FromNetworkName = async args => {
+      initArgs = args;
+      return fakeClient();
+    };
+
+    await Client.New(context({args: {network: "demo"}})).get();
+
+    expect(initArgs.networkName).to.equal("demo");
+  });
+
+  it("pins fabric and file-service requests to the supplied node", async () => {
+    const client = fakeClient();
+    ElvClient.FromNetworkName = async () => client;
+
+    await Client.New(context({args: {node: "fabric.example.com"}})).get();
+
+    expect(client.nodeSelections).to.deep.equal([{
+      fabricURIs: ["https://fabric.example.com"],
+      fileServiceURIs: ["https://fabric.example.com"]
+    }]);
+  });
+});