chore(data and multi format): remove default exports

packages/data-access/src/block.ts

@@ -1,4 +1,4 @@
-import MultiFormat from '@requestnetwork/multi-format';
+import * as MultiFormat from '@requestnetwork/multi-format';
 import { DataAccessTypes } from '@requestnetwork/types';
 import { deepCopy } from '@requestnetwork/utils';
 

packages/data-format/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "import/no-default-export": "error"
+  }
+}

packages/data-format/README.md

@@ -12,7 +12,7 @@ npm install @requestnetwork/data-format
 ### Usage
 
 ```js
-import dataFormat from '@requestnetwork/data-format';
+import * as dataFormat from '@requestnetwork/data-format';
 
 let result = data - format.validate(A_JSON_OBJECT);
 

packages/data-format/src/format/index.ts

@@ -4,11 +4,10 @@ import * as rnf_invoice_0_0_3 from './rnf_invoice/rnf_invoice-0.0.3.json';
 
 // Re-export the JSON files structured by format and version.
 // NB: A dynamic require (require(`${format}/${format}-${version}.json`)) would prevent tree-shaking
-const formats: Record<string, Record<string, any>> = {
+export const formats: Record<string, Record<string, any>> = {
   rnf_invoice: {
     '0.0.1': rnf_invoice_0_0_1,
     '0.0.2': rnf_invoice_0_0_2,
     '0.0.3': rnf_invoice_0_0_3,
   },
 };
-export default formats;

packages/data-format/src/index.ts

@@ -1,54 +1,53 @@
 import * as AJV from 'ajv';
 import * as jsonSchema from 'ajv/lib/refs/json-schema-draft-06.json';
 import * as schemaAddress from './format/address.json';
-import formats from './format';
-
-export default {
-  /**
-   * validation of data
-   * @param   data    object you want to validate
-   * @return  object.valid == true if the json is valid, object.valid == false and object.errors otherwise.
-   */
-  validate(data: any): any {
-    const validationTool = new AJV().addMetaSchema(jsonSchema).addSchema(schemaAddress);
-
-    // Check the meta information
-    if (!data.meta) {
-      return { valid: false, errors: [{ message: 'meta not found' }] };
-    }
-    if (!data.meta.format) {
-      return { valid: false, errors: [{ message: 'meta.format not found' }] };
-    }
-    if (!data.meta.version) {
-      return { valid: false, errors: [{ message: 'meta.version not found' }] };
-    }
-
-    // Try to retrieve the schema json
-    const schema = formats[data.meta.format]?.[data.meta.version];
-    if (!schema) {
-      return { valid: false, errors: [{ message: 'format not found' }] };
-    }
-
-    // Compile and Validate
-    const validate = validationTool.compile(schema);
-    const valid = validate(data);
-
-    // If not valid return the error
-    if (!valid) {
-      return { valid: false, errors: validate.errors };
-    }
-
-    return { valid: true };
-  },
-  /**
-   * Check if the object format is known
-   * @param data the object to check
-   * @return true if the object format is known
-   */
-  isKnownFormat(data: any): boolean {
-    return !!data.meta && data.meta.format === 'rnf_invoice';
-  },
-};
+import { formats } from './format';
+
+/**
+ * validation of data
+ * @param   data    object you want to validate
+ * @return  object.valid == true if the json is valid, object.valid == false and object.errors otherwise.
+ */
+export function validate(data: any): any {
+  const validationTool = new AJV().addMetaSchema(jsonSchema).addSchema(schemaAddress);
+
+  // Check the meta information
+  if (!data.meta) {
+    return { valid: false, errors: [{ message: 'meta not found' }] };
+  }
+  if (!data.meta.format) {
+    return { valid: false, errors: [{ message: 'meta.format not found' }] };
+  }
+  if (!data.meta.version) {
+    return { valid: false, errors: [{ message: 'meta.version not found' }] };
+  }
+
+  // Try to retrieve the schema json
+  const schema = formats[data.meta.format]?.[data.meta.version];
+  if (!schema) {
+    return { valid: false, errors: [{ message: 'format not found' }] };
+  }
+
+  // Compile and Validate
+  const validate = validationTool.compile(schema);
+  const valid = validate(data);
+
+  // If not valid return the error
+  if (!valid) {
+    return { valid: false, errors: validate.errors };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Check if the object format is known
+ * @param data the object to check
+ * @return true if the object format is known
+ */
+export function isKnownFormat(data: any): boolean {
+  return !!data.meta && data.meta.format === 'rnf_invoice';
+}
 
 // FIXME it would be better to export a subpath, ie @requestnetwork/data-format/invoice,
 // using `exports` as introduced in Node 12.7.0 (https://nodejs.org/api/packages.html#packages_subpath_exports)

packages/data-format/test/test.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-var-requires */
-import DataFormat from '../src/index';
+import * as DataFormat from '../src/index';
 
 /* eslint-disable @typescript-eslint/no-unused-expressions */
 describe('Request Network Data Validator', () => {

packages/integration-test/test/layers.test.ts

@@ -11,7 +11,7 @@ import {
   EthereumTransactionSubmitter,
   IpfsStorage,
 } from '@requestnetwork/ethereum-storage';
-import MultiFormat from '@requestnetwork/multi-format';
+import * as MultiFormat from '@requestnetwork/multi-format';
 import { RequestLogic } from '@requestnetwork/request-logic';
 import { TransactionManager } from '@requestnetwork/transaction-manager';
 import {

packages/integration-test/test/node-client.test.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { EthereumPrivateKeyDecryptionProvider } from '@requestnetwork/epk-decryption';
-import MultiFormat from '@requestnetwork/multi-format';
+import * as MultiFormat from '@requestnetwork/multi-format';
 import { Request, RequestNetwork, Types } from '@requestnetwork/request-client.js';
 import {
   IdentityTypes,

packages/multi-format/.eslintrc

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "import/no-default-export": "error"
+  }
+}

packages/multi-format/README.md

@@ -12,7 +12,7 @@ npm install @requestnetwork/multi-format
 ## Usage
 
 ```javascript
-import MultiFormat from '@requestnetwork/multi-format';
+import * as MultiFormat from '@requestnetwork/multi-format';
 ```
 
 ## Contributing

packages/multi-format/src/encryption/aes256-cbc-format.ts

@@ -1,11 +1,11 @@
 import { EncryptionTypes, MultiFormatTypes } from '@requestnetwork/types';
 
-import SerializableMultiFormat from '../serializable-multi-format';
+import { SerializableMultiFormat } from '../serializable-multi-format';
 
 /**
  * Class to serialize and deserialize multi-format AES-256-CBC encrypted data
  */
-export default class Aes256CbcMultiFormat extends SerializableMultiFormat {
+export class Aes256CbcMultiFormat extends SerializableMultiFormat {
   constructor() {
     super(MultiFormatTypes.prefix.AES256_CBC_ENCRYPTED, EncryptionTypes.METHOD.AES256_CBC);
   }

packages/multi-format/src/encryption/aes256-gcm-format.ts

@@ -1,11 +1,11 @@
 import { EncryptionTypes, MultiFormatTypes } from '@requestnetwork/types';
 
-import SerializableMultiFormat from '../serializable-multi-format';
+import { SerializableMultiFormat } from '../serializable-multi-format';
 
 /**
  * Class to serialize and deserialize multi-format AES-256-GCM encrypted data
  */
-export default class Aes256GcmMultiFormat extends SerializableMultiFormat {
+export class Aes256GcmMultiFormat extends SerializableMultiFormat {
   constructor() {
     super(MultiFormatTypes.prefix.AES256_GCM_ENCRYPTED, EncryptionTypes.METHOD.AES256_GCM);
   }

packages/multi-format/src/encryption/ecies-format.ts

@@ -1,11 +1,11 @@
 import { EncryptionTypes, MultiFormatTypes } from '@requestnetwork/types';
 
-import SerializableMultiFormat from '../serializable-multi-format';
+import { SerializableMultiFormat } from '../serializable-multi-format';
 
 /**
  * Class to serialize and deserialize multi-format AES-256-CBC encrypted data
  */
-export default class ECIESMultiFormat extends SerializableMultiFormat {
+export class ECIESMultiFormat extends SerializableMultiFormat {
   constructor() {
     super(MultiFormatTypes.prefix.ECIES_ENCRYPTED, EncryptionTypes.METHOD.ECIES);
   }

packages/multi-format/src/encryption/encryption-format.ts

@@ -1,8 +1,10 @@
-import GroupMultiFormat from '../group-multi-format';
-import Aes256Cbc from './aes256-cbc-format';
-import Aes256Gcm from './aes256-gcm-format';
-import Ecies from './ecies-format';
+import { MultiFormatGroup } from '../multi-format-group';
+import { Aes256CbcMultiFormat } from './aes256-cbc-format';
+import { Aes256GcmMultiFormat } from './aes256-gcm-format';
+import { ECIESMultiFormat } from './ecies-format';
 
-// group all the multi-format concerning the encryption
-const group = new GroupMultiFormat([new Aes256Cbc(), new Ecies(), new Aes256Gcm()]);
-export default group;
+export const encryptionFormats = new MultiFormatGroup([
+  new Aes256CbcMultiFormat(),
+  new ECIESMultiFormat(),
+  new Aes256GcmMultiFormat(),
+]);

packages/multi-format/src/hash/hash-format.ts

@@ -1,6 +1,5 @@
-import GroupMultiFormat from '../group-multi-format';
-import Keccak256 from './keccak256-format';
+import { MultiFormatGroup } from '../multi-format-group';
+import { Keccak256MultiFormat } from './keccak256-format';
 
 // group all the multi-format concerning the hashing
-const group = new GroupMultiFormat([new Keccak256()]);
-export default group;
+export const hashFormat = new MultiFormatGroup([new Keccak256MultiFormat()]);

packages/multi-format/src/hash/keccak256-format.ts

@@ -1,11 +1,11 @@
 import { MultiFormatTypes } from '@requestnetwork/types';
 
-import HexadecimalSerializableMultiFormat from '../hexadecimal-serializable-multi-format';
+import { HexadecimalSerializableMultiFormat } from '../hexadecimal-serializable-multi-format';
 
 /**
  * Class to serialize and deserialize multi-format AES-256-CBC encrypted data
  */
-export default class EthereumAddressMultiFormat extends HexadecimalSerializableMultiFormat {
+export class Keccak256MultiFormat extends HexadecimalSerializableMultiFormat {
   constructor() {
     super(
       MultiFormatTypes.prefix.NORMALIZE_KECCAK256_HASH,

packages/multi-format/src/hexadecimal-serializable-multi-format.ts

@@ -1,12 +1,12 @@
 import { MultiFormatTypes } from '@requestnetwork/types';
 
-import SerializableMultiFormat from './serializable-multi-format';
+import { SerializableMultiFormat } from './serializable-multi-format';
 
 /**
  * Class to serialize and deserialize multi-format data using hexadecimal values
  * This class is meant to be inherited by all the multi-format using as value a hexadecimal (starting by '0x')
  */
-export default class HexadecimalSerializableMultiFormat extends SerializableMultiFormat {
+export class HexadecimalSerializableMultiFormat extends SerializableMultiFormat {
   /**
    * Checks if an object is a deserialized multi-format
    *

packages/multi-format/src/identity/ethereum-address-format.ts

@@ -1,11 +1,11 @@
 import { IdentityTypes, MultiFormatTypes } from '@requestnetwork/types';
 
-import HexadecimalSerializableMultiFormat from '../hexadecimal-serializable-multi-format';
+import { HexadecimalSerializableMultiFormat } from '../hexadecimal-serializable-multi-format';
 
 /**
  * Class to serialize and deserialize multi-format identity ethereum address
  */
-export default class EthereumAddressMultiFormat extends HexadecimalSerializableMultiFormat {
+export class EthereumAddressMultiFormat extends HexadecimalSerializableMultiFormat {
   constructor() {
     super(MultiFormatTypes.prefix.IDENTITY_ETHEREUM_ADDRESS, IdentityTypes.TYPE.ETHEREUM_ADDRESS);
   }

packages/multi-format/src/identity/identity-format.ts

@@ -1,7 +1,6 @@
-import GroupMultiFormat from '../group-multi-format';
+import { MultiFormatGroup } from '../multi-format-group';
 
-import EthereumAddressFormat from './ethereum-address-format';
+import { EthereumAddressMultiFormat } from './ethereum-address-format';
 
 // group all the multi-format concerning identities
-const group = new GroupMultiFormat([new EthereumAddressFormat()]);
-export default group;
+export const identityFormat = new MultiFormatGroup([new EthereumAddressMultiFormat()]);

packages/multi-format/src/index.ts

@@ -1,23 +1,15 @@
 import { MultiFormatTypes } from '@requestnetwork/types';
 
-import encryptionFormats from './encryption/encryption-format';
-import GroupMultiFormat from './group-multi-format';
-import hashFormat from './hash/hash-format';
-import identityFormat from './identity/identity-format';
-import plainFormat from './plain/plain-format';
-
-/** Serializes and deserializes any multi-format supported */
-export default {
-  deserialize,
-  encryptionFormats,
-  hashFormat,
-  identityFormat,
-  plainFormat,
-  serialize,
-};
+import { encryptionFormats } from './encryption/encryption-format';
+import { MultiFormatGroup } from './multi-format-group';
+import { hashFormat } from './hash/hash-format';
+import { identityFormat } from './identity/identity-format';
+import { plainFormat } from './plain/plain-format';
+
+export { encryptionFormats, MultiFormatGroup, hashFormat, identityFormat, plainFormat };
 
 /** List of the groups of formats available */
-const availableFormats: GroupMultiFormat[] = [
+const availableFormats: MultiFormatGroup[] = [
   encryptionFormats,
   identityFormat,
   hashFormat,
@@ -30,7 +22,7 @@ const availableFormats: GroupMultiFormat[] = [
  * @param formatted the string to deserialize
  * @returns the deserialized object or throw
  */
-function deserialize(formatted: string): MultiFormatTypes.IMultiFormatDeserialized {
+export function deserialize(formatted: string): MultiFormatTypes.IMultiFormatDeserialized {
   const matchingFormat = availableFormats.find((format) =>
     format.isDeserializableString(formatted),
   );
@@ -48,7 +40,7 @@ function deserialize(formatted: string): MultiFormatTypes.IMultiFormatDeserializ
  * @param data the object to serialize
  * @returns the serialized string or throw.
  */
-function serialize(data: MultiFormatTypes.IMultiFormatDeserialized): string {
+export function serialize(data: MultiFormatTypes.IMultiFormatDeserialized): string {
   const matchingFormat = availableFormats.find((format) => format.isSerializableObject(data));
 
   if (matchingFormat) {

packages/multi-format/src/group-multi-format.ts → packages/multi-format/src/multi-format-group.ts

@@ -1,16 +1,16 @@
 import { MultiFormatTypes } from '@requestnetwork/types';
 
-import SerializableMultiFormat from './serializable-multi-format';
+import { SerializableMultiFormat } from './serializable-multi-format';
 
 /**
  * Class to group multi-formats to make the code more maintainable (see index.ts)
  */
-export default class GroupMultiFormat {
+export class MultiFormatGroup {
   /** All the format in the group */
   private availableFormats: SerializableMultiFormat[] = [];
 
   /**
-   * Creates an instance of GroupMultiFormat.
+   * Creates an instance of MultiFormatGroup.
    *
    * @param formats all the formats of this group
    */

packages/multi-format/src/plain/plain-format.ts

@@ -1,6 +1,5 @@
-import GroupMultiFormat from '../group-multi-format';
-import PlainText from './plain-text-format';
+import { MultiFormatGroup } from '../multi-format-group';
+import { PlainTextMultiFormat } from './plain-text-format';
 
 // group all the multi-format concerning plain data
-const group = new GroupMultiFormat([new PlainText()]);
-export default group;
+export const plainFormat = new MultiFormatGroup([new PlainTextMultiFormat()]);

packages/multi-format/src/plain/plain-text-format.ts

@@ -1,11 +1,11 @@
 import { MultiFormatTypes } from '@requestnetwork/types';
 
-import SerializableMultiFormat from '../serializable-multi-format';
+import { SerializableMultiFormat } from '../serializable-multi-format';
 
 /**
  * Class to serialize and deserialize multi-format plain text
  */
-export default class Aes256CbcMultiFormat extends SerializableMultiFormat {
+export class PlainTextMultiFormat extends SerializableMultiFormat {
   constructor() {
     super(MultiFormatTypes.prefix.PLAIN_TEXT, MultiFormatTypes.PlainTypes.TYPE.PLAIN_TEXT);
   }