@velocitycareerlabs/tests-helpers 1.16.0-dev-build.1c05f9227

package/src/build-mongo-connection.js

@@ -0,0 +1,37 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const env = require('env-var');
+
+const buildMongoConnection = (dbName) => {
+  const isTlsMongo = env.get('TLS_MONGO').default('false').asBool();
+
+  if (!isTlsMongo) {
+    return `mongodb://localhost:27017/${dbName}`;
+  }
+
+  const mongoUsername = env.get('MONGO_USERNAME').default('').asString();
+  const mongoPassword = env.get('MONGO_PASSWORD').default('').asString();
+  const caFilename = env.get('CA_FILENAME').default('').asString();
+
+  // Uses tlsAllowInvalidHostnames to allow localhost SSH tunnleing to remote DB
+  const connUri = `mongodb://${mongoUsername}:${mongoPassword}@localhost:27017/${dbName}`;
+  const connOptions = `tls=true&tlsCAFile=${caFilename}&tlsAllowInvalidHostnames=true&retryWrites=false&directConnection=true`;
+
+  return `${connUri}?${connOptions}`;
+};
+
+module.exports = { buildMongoConnection };

package/src/generate-ion-operations.js

@@ -0,0 +1,120 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { last, map, reduce } = require('lodash/fp');
+const { privateJwkMatcher, publicJwkMatcher } = require('./jwk-matchers');
+
+const generateDidKeyMatcher = (kid) => ({
+  id: last(kid.split('#')),
+  type: 'EcdsaSecp256k1VerificationKey2019',
+  publicKeyJwk: publicJwkMatcher,
+  purposes: ['assertionMethod'],
+});
+
+const createInitOp = (services, keys) => ({
+  operation: 'create',
+  content: {
+    publicKeys: map(generateDidKeyMatcher, keys),
+    services: map(formatService, services),
+  },
+  recovery: {
+    publicJwk: publicJwkMatcher,
+    privateJwk: privateJwkMatcher,
+  },
+  update: {
+    publicJwk: publicJwkMatcher,
+    privateJwk: privateJwkMatcher,
+  },
+});
+
+const addServiceOp = (service, previous, options) => {
+  const content = {};
+  if (!options.remove) {
+    content.addServices = [formatService(service)];
+  }
+  if (options.replace || options.remove) {
+    content.removeServices = [service.id.slice(1)];
+  }
+
+  return {
+    operation: 'update',
+    content,
+    previous,
+    update: {
+      publicJwk: publicJwkMatcher,
+      privateJwk: privateJwkMatcher,
+    },
+  };
+};
+
+const addPublicKeyOp = (publicKey, previous, options) => {
+  const content = {};
+  if (!options.remove) {
+    content.addPublicKeys = [generateDidKeyMatcher(publicKey.id)];
+  }
+  if (options.replace || options.remove) {
+    content.removePublicKeys = [publicKey.id.slice(1)];
+  }
+
+  return {
+    operation: 'update',
+    content,
+    previous,
+    update: {
+      publicJwk: publicJwkMatcher,
+      privateJwk: privateJwkMatcher,
+    },
+  };
+};
+
+const formatService = (service) => ({
+  id: service.id.slice(1),
+  serviceEndpoint: service.serviceEndpoint,
+  type: service.type,
+});
+
+// Should really also include initialKeys. See thread at:
+// https://github.com/velocitycareerlabs/monorepo/pull/1271#discussion_r714185994
+const generateIonOperations = (
+  initialServices = [],
+  additionalServices = [],
+  kids = ['vc-signing-key-1', 'eth-account-key-1', 'exchange-key-1'],
+  options = {}
+) => {
+  const op0 = createInitOp(initialServices, kids.slice(0, 2));
+  const initialOps = reduce(
+    (acc, kid) => {
+      acc.push(addPublicKeyOp({ id: kid }, last(acc), {}));
+      return acc;
+    },
+    [op0],
+    kids.slice(2)
+  );
+  return reduce(
+    (acc, service) => {
+      acc.push(addServiceOp(service, last(acc), options));
+      return acc;
+    },
+    initialOps,
+    additionalServices
+  );
+};
+
+module.exports = {
+  generateIonOperations,
+  generateDidKeyMatcher,
+  addPublicKeyOp,
+};

package/src/generate-key-pair-in-hex-and-jwk.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { generateKeyPair } = require('@velocitycareerlabs/crypto');
+const { jwkFromSecp256k1Key } = require('@velocitycareerlabs/jwt');
+
+const generateKeyPairInHexAndJwk = () => {
+  const { publicKey, privateKey } = generateKeyPair();
+  return {
+    publicKey,
+    publicJwk: jwkFromSecp256k1Key(publicKey, false),
+    privateKey,
+    privateJwk: jwkFromSecp256k1Key(privateKey, true),
+  };
+};
+
+module.exports = {
+  generateKeyPairInHexAndJwk,
+};

package/src/generate-organization-key-matcher.js

@@ -0,0 +1,94 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { last, omit } = require('lodash/fp');
+const { Regexes } = require('@velocitycareerlabs/common-functions');
+const { privateKeyMatcher, publicKeyMatcher } = require('./matchers');
+
+// eslint-disable-next-line complexity
+const generateOrganizationKeyMatcher = ({
+  kid,
+  purpose,
+  publicKey,
+  format = 'hex',
+  type = 'JsonWebKey2020',
+  withKidFragment = false,
+}) => {
+  if (!withKidFragment) {
+    const baseMatcher = {
+      algorithm: 'SECP256K1',
+      encoding: 'hex',
+      id: kidMatcher(kid),
+      key:
+        format === 'hex'
+          ? expect.stringMatching(Regexes.HEX_FORMAT)
+          : privateKeyMatcher,
+      publicKey:
+        format === 'hex'
+          ? expect.stringMatching(Regexes.HEX_FORMAT)
+          : publicKeyMatcher,
+      purposes: [purpose],
+      type: expect.stringMatching(
+        /^(JsonWebKey2020|Ed25519VerificationKey2018|EcdsaSecp256k1VerificationKey2019)$/
+      ),
+    };
+    if (publicKey) {
+      return {
+        ...omit(['key'], baseMatcher),
+        publicKey,
+      };
+    }
+    return baseMatcher;
+  }
+
+  const baseMatcher = {
+    kidFragment: kidMatcher(kid),
+    algorithm: 'SECP256K1',
+    encoding: 'hex',
+    ...(!publicKey && {
+      key:
+        format === 'hex'
+          ? expect.stringMatching(Regexes.HEX_FORMAT)
+          : privateKeyMatcher,
+    }),
+    purposes: [purpose],
+    didDocumentKey: {
+      id: kid,
+      type: expect.stringMatching(
+        /^(JsonWebKey2020|Ed25519VerificationKey2018|EcdsaSecp256k1VerificationKey2019)$/
+      ),
+      controller: expect.any(String),
+      ...(type === 'JsonWebKey2020'
+        ? {
+            publicKeyJwk: publicKeyMatcher,
+          }
+        : {
+            publicKeyMultibase: expect.stringMatching(Regexes.HEX_FORMAT),
+          }),
+    },
+  };
+  return baseMatcher;
+};
+
+const kidMatcher = (kid) => {
+  if (kid instanceof RegExp) {
+    return expect.stringMatching(kid);
+  }
+
+  return `#${last(kid.split('#'))}`;
+};
+
+module.exports = { generateOrganizationKeyMatcher };

package/src/generate-presentation.js

@@ -0,0 +1,126 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { generateKeyPair } = require('@velocitycareerlabs/crypto');
+const { mapWithIndex } = require('@velocitycareerlabs/common-functions');
+const {
+  castArray,
+  map,
+  merge,
+  pick,
+  set,
+  values,
+  unset,
+  slice,
+  size,
+} = require('lodash/fp');
+const { nanoid } = require('nanoid/non-secure');
+const {
+  generateDocJwt,
+  generateCredentialJwt,
+  generatePresentationJwt,
+} = require('@velocitycareerlabs/jwt');
+
+const phonePayload = {
+  sub: 'did:velocity:0x0a63c18d09d5430363b2f3b270698a677fb513e4',
+  vc: {
+    '@context': ['https://www.w3.org/2018/credentials/v1'],
+    id: 'did:velocity:0x0a63c18d09d5430363b2f3b270698a677fb513e4',
+    issuer: { id: 'did:velocity:0x0b154da48d0f213c26c4b1d040dc5ff1dbf99ffa' },
+    issued: '2020-08-17T11:27:06.000Z',
+    type: ['PhoneV1.0', 'VerifiableCredential'],
+    credentialSubject: {
+      phone: '+447309917830',
+    },
+  },
+};
+
+const { privateKey } = generateKeyPair();
+
+const generateSimpleKYCPresentation = (idDocTypes, options) => {
+  const idCredentials = {
+    phone: phonePayload,
+  };
+
+  const selectedCredentials = idDocTypes
+    ? pick(castArray(idDocTypes), idCredentials)
+    : values(idCredentials);
+
+  return doSimpleGeneratePresentation(
+    selectedCredentials,
+    'fooDefinitionId',
+    options
+  );
+};
+
+const doSimpleGeneratePresentation = async (
+  credentials,
+  definitionId,
+  options = { isBrokeVCS: false }
+) => {
+  const signedCredentials = await Promise.all(
+    map((c) => generateCredentialJwt(c, privateKey), credentials)
+  );
+
+  const presentation = {
+    id: nanoid(),
+    verifiableCredential: options.isBrokeVCS
+      ? [
+          ...slice(0, 1, signedCredentials),
+          ...Array(size(signedCredentials) - 1).fill(''),
+        ]
+      : signedCredentials,
+    presentation_submission: {
+      id: nanoid(),
+      definition_id: definitionId,
+      descriptor_map: mapWithIndex(
+        (c, i) => ({
+          id: nanoid(),
+          path: `$.verifiableCredential[${i}]`,
+          format: 'jwt_vc',
+        }),
+        signedCredentials
+      ),
+    },
+  };
+
+  return {
+    presentation,
+    credentials,
+    override(overrides) {
+      return merge(this, { presentation: overrides });
+    },
+    delete(key) {
+      return set('presentation', unset(key, this.presentation), this);
+    },
+    sign(kid, personPrivateKey, issuer = 'https://self-issued.me') {
+      return generateDocJwt(this.presentation, personPrivateKey, {
+        issuer,
+        kid,
+        aud: this.presentation.aud,
+        jti: nanoid(),
+      });
+    },
+    selfSign() {
+      return generatePresentationJwt(this.presentation, privateKey);
+    },
+  };
+};
+
+module.exports = {
+  generateSimpleKYCPresentation,
+  phonePayload,
+};

package/src/jsonify.js

@@ -0,0 +1,38 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { reduce, isDate, keys } = require('lodash/fp');
+const { ObjectId } = require('mongodb');
+
+const jsonify = (obj, convertId = true) =>
+  reduce(
+    (acc, k) => {
+      if (isDate(obj[k])) {
+        acc[k] = obj[k].toISOString();
+      } else if (convertId && k === '_id') {
+        acc.id = obj[k].toString();
+      } else if (obj[k] instanceof ObjectId) {
+        acc[k] = obj[k].toString();
+      } else {
+        acc[k] = obj[k];
+      }
+      return acc;
+    },
+    {},
+    keys(obj)
+  );
+
+module.exports = { jsonify };

package/src/jwk-matchers.js

@@ -0,0 +1,34 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { URLSAFE_BASE64_FORMAT } = require('./regexes');
+
+const privateJwkMatcher = {
+  crv: 'secp256k1',
+  kty: 'EC',
+  d: expect.stringMatching(URLSAFE_BASE64_FORMAT),
+  x: expect.stringMatching(URLSAFE_BASE64_FORMAT),
+  y: expect.stringMatching(URLSAFE_BASE64_FORMAT),
+};
+
+const publicJwkMatcher = {
+  crv: 'secp256k1',
+  kty: 'EC',
+  x: expect.stringMatching(URLSAFE_BASE64_FORMAT),
+  y: expect.stringMatching(URLSAFE_BASE64_FORMAT),
+};
+
+module.exports = { publicJwkMatcher, privateJwkMatcher };

package/src/load-test-env.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const dotenv = require('dotenv');
+const path = require('path');
+
+const loadTestEnv = (
+  envFile = path.resolve(__dirname, '..', '.env.test'),
+  override = true
+) => {
+  dotenv.config({ path: envFile, override });
+};
+
+module.exports = { loadTestEnv };

package/src/matchers.js

@@ -0,0 +1,19 @@
+const privateKeyMatcher = {
+  crv: 'secp256k1',
+  kty: 'EC',
+  d: expect.any(String),
+  x: expect.any(String),
+  y: expect.any(String),
+};
+
+const publicKeyMatcher = {
+  crv: 'secp256k1',
+  kty: 'EC',
+  x: expect.any(String),
+  y: expect.any(String),
+};
+
+module.exports = {
+  privateKeyMatcher,
+  publicKeyMatcher,
+};

package/src/mongoify.js

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const { ObjectId } = require('mongodb');
+const { first, isPlainObject, map, mapValues } = require('lodash/fp');
+const { ISO_DATETIME_FORMAT, OBJECT_ID_FORMAT } = require('./regexes');
+
+// eslint-disable-next-line complexity
+const mongoify = mapValues((v) => {
+  if (ISO_DATETIME_FORMAT.test(v)) {
+    return new Date(v);
+  }
+
+  if (Array.isArray(v) && v.length > 0 && OBJECT_ID_FORMAT.test(first(v))) {
+    return map((_v) => new ObjectId(_v), v);
+  }
+
+  if (OBJECT_ID_FORMAT.test(v)) {
+    return new ObjectId(v);
+  }
+
+  if (Array.isArray(v) && v.length > 0 && isPlainObject(first(v))) {
+    return map(mongoify, v);
+  }
+
+  if (isPlainObject(v)) {
+    return mongoify(v);
+  }
+  return v;
+});
+
+module.exports = { mongoify };

package/src/regexes.js

@@ -0,0 +1,34 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+module.exports = {
+  OBJECT_ID_FORMAT: /^[0-9a-fA-F]{24}$/,
+  UUID_FORMAT:
+    /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+  ISO_DATETIME_FORMAT: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
+  ISO_DATETIME_FORMAT_ONLY_DATE_SECTION: /^\d{4}-\d{2}-\d{2}/,
+  TW0_DECIMAL_POINT_NUMBER: /^[0-9]*\.[0-9]{2}$/,
+  TW0_OR_THREE_DECIMAL_POINT_NUMBER: /^[0-9]*\.[0-9]{2,3}$/,
+  NUMERIC_FORMAT: /^[0-9]+$/,
+  HYPER_ID_FORMAT: /^[0-9a-zA-Z\\+]+$/,
+  NANO_ID_FORMAT: /^([A-Za-z0-9_-]+)/,
+  JWT_FORMAT: /^[A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+\.?[A-Za-z0-9-_.+/=]*$/,
+  URLSAFE_BASE64_FORMAT: /^[A-Za-z0-9-_=]+$/,
+  BASE58_FORMAT: /^[A-NP-Za-z1-9]+$/,
+  DID_FORMAT: 'did:[a-z]+:[a-zA-Z0-9_#;?&=\\.-]+',
+  ETHEREUM_ADDRESS_FORMAT: /^0x[a-fA-F0-9]{40}$/,
+  REQUEST_ID: /req-\w+/,
+};

package/src/s3-utils.js

@@ -0,0 +1,29 @@
+const deleteS3Object = async (s3Client, bucketName) => {
+  const data = await s3Client.listObjects({ Bucket: bucketName }).promise();
+
+  // Check if data.Contents exists and is not empty
+  if (data.Contents && data.Contents.length > 0) {
+    const objects = data.Contents.map(({ Key }) => ({ Key }));
+    await s3Client
+      .deleteObjects({ Bucket: bucketName, Delete: { Objects: objects } })
+      .promise();
+  }
+};
+
+const getObject = async ({ s3Client, bucket, key }) => {
+  const params = {
+    Bucket: bucket,
+    Key: key,
+  };
+
+  try {
+    return await s3Client.getObject(params).promise();
+  } catch (e) {
+    return null;
+  }
+};
+
+module.exports = {
+  deleteS3Object,
+  getObject,
+};

package/src/spence-mongo-repos.js

@@ -0,0 +1,16 @@
+const { set } = require('lodash/fp');
+const { mongoFactory, mongoClose } = require('@spencejs/spence-mongo-repos');
+const { buildMongoConnection } = require('./build-mongo-connection');
+const { loadTestEnv } = require('./load-test-env');
+
+const mongoFactoryWrapper = async (dbName, context) => {
+  const mongoConnection = buildMongoConnection(dbName);
+  loadTestEnv();
+
+  return mongoFactory(set('config.mongoConnection', mongoConnection, context));
+};
+
+module.exports = {
+  mongoFactoryWrapper,
+  mongoCloseWrapper: mongoClose,
+};

package/src/test-auth-token.js

@@ -0,0 +1,20 @@
+/**
+ * Copyright 2023 Velocity Team
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const testAuthToken =
+  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyIjoidmVsb2NpdHkuYWRtaW5AZXhhbXBsZS5jb20ifQ.93NY5S7ohFv37rYYo4_TcPx3NFGdhMucK6yNmvGYE0U';
+
+module.exports = { testAuthToken };