dkg.js 6.0.0 → 6.0.2

package/services/validation-service.js

@@ -1,8 +1,211 @@
-const { MAX_FILE_SIZE, BLOCKCHAINS, OPERATIONS, GET_OUTPUT_FORMATS } = require('../constants.js');
+const { ASSET_STATES, CONTENT_TYPES, GRAPH_LOCATIONS, GRAPH_STATES, MAX_FILE_SIZE, OPERATIONS, GET_OUTPUT_FORMATS, QUERY_TYPES } = require('../constants.js');
 const { nodeSupported } = require('./utilities.js');
 
 class ValidationService {
-    validatePublishRequest(content, options) {
+    validateNodeInfo(endpoint, port, authToken) {
+        this.validateEndpoint(endpoint);
+        this.validatePort(port);
+        this.validateAuthToken(authToken);
+    }
+
+    validateGraphQuery(
+        queryString,
+        queryType,
+        graphLocation,
+        graphState,
+        endpoint,
+        port,
+        maxNumberOfRetries,
+        frequency,
+        authToken,
+    ) {
+        this.validateQueryString(queryString);
+        this.validateQueryType(queryType);
+        this.validateGraphLocation(graphLocation);
+        this.validateGraphState(graphState);
+        this.validateEndpoint(endpoint);
+        this.validatePort(port);
+        this.validateMaxNumberOfRetries(maxNumberOfRetries);
+        this.validateFrequency(frequency);
+        this.validateAuthToken(authToken);
+    }
+
+    validateAssetCreate(
+        content,
+        blockchain,
+        endpoint,
+        port,
+        maxNumberOfRetries,
+        frequency,
+        epochsNum,
+        hashFunctionId,
+        scoreFunctionId,
+        immutable,
+        tokenAmount,
+        authToken,
+    ) {
+        this.validateContent(content)
+        this.validateBlockchain(blockchain, OPERATIONS.PUBLISH);
+        this.validateEndpoint(endpoint);
+        this.validatePort(port);
+        this.validateMaxNumberOfRetries(maxNumberOfRetries);
+        this.validateFrequency(frequency);
+        this.validateEpochsNum(epochsNum);
+        this.validateHashFunctionId(hashFunctionId);
+        this.validateScoreFunctionId(scoreFunctionId);
+        this.validateImmutable(immutable);
+        this.validateTokenAmount(tokenAmount);
+        this.validateAuthToken(authToken);
+    }
+
+    validateAssetGet(
+        UAL,
+        blockchain,
+        endpoint,
+        port,
+        maxNumberOfRetries,
+        frequency,
+        state,
+        contentType,
+        hashFunctionId,
+        validate,
+        outputFormat,
+        authToken,
+    ) {
+        this.validateUAL(UAL);
+        this.validateBlockchain(blockchain, OPERATIONS.GET);
+        this.validateEndpoint(endpoint);
+        this.validatePort(port);
+        this.validateMaxNumberOfRetries(maxNumberOfRetries);
+        this.validateFrequency(frequency);
+        this.validateState(state);
+        this.validateContentType(contentType);
+        this.validateHashFunctionId(hashFunctionId);
+        this.validateValidate(validate);
+        this.validateOutputFormat(outputFormat);
+        this.validateAuthToken(authToken);
+    }
+
+    validateAssetUpdate(
+        content,
+        blockchain,
+        endpoint,
+        port,
+        maxNumberOfRetries,
+        frequency,
+        hashFunctionId,
+        scoreFunctionId,
+        tokenAmount,
+        authToken,
+    ) {
+        this.validateContent(content)
+        this.validateBlockchain(blockchain, OPERATIONS.UPDATE);
+        this.validateEndpoint(endpoint);
+        this.validatePort(port);
+        this.validateMaxNumberOfRetries(maxNumberOfRetries);
+        this.validateFrequency(frequency);
+        this.validateHashFunctionId(hashFunctionId);
+        this.validateScoreFunctionId(scoreFunctionId);
+        this.validateTokenAmount(tokenAmount);
+        this.validateAuthToken(authToken);
+    }
+
+    validateWaitAssetUpdateFinalization(UAL, blockchain) {
+        this.validateUAL(UAL);
+        this.validateBlockchain(blockchain);
+    }
+
+    validateAssetUpdateCancel(UAL, blockchain) {
+        this.validateUAL(UAL);
+        this.validateBlockchain(blockchain);
+    }
+
+    validateAssetTransfer(UAL, newOwner, blockchain) {
+        this.validateUAL(UAL);
+        this.validateNewOwner(newOwner);
+        this.validateBlockchain(blockchain);
+    }
+
+    validateAssetGetOwner(UAL, blockchain) {
+        this.validateUAL(UAL);
+        this.validateBlockchain(blockchain);
+    }
+
+    validateAssetBurn(UAL, blockchain) {
+        this.validateUAL(UAL);
+        this.validateBlockchain(blockchain);
+    }
+
+    validateExtendAssetStoringPeriod(UAL, epochsNum, tokenAmount, blockchain) {
+        this.validateUAL(UAL);
+        this.validateEpochsNum(epochsNum);
+        this.validateTokenAmount(tokenAmount);
+        this.validateBlockchain(blockchain);
+    }
+
+    validateAddTokens(UAL, tokenAmount, blockchain) {
+        this.validateUAL(UAL);
+        this.validateTokenAmount(tokenAmount);
+        this.validateBlockchain(blockchain);
+    }
+
+    validateRequiredParam(paramName, param) {
+        if (param == null) throw Error(`${paramName} is missing.`);
+    }
+
+    validateParamType(paramName, param, type) {
+        let parameter = param;
+        if (type === 'number') {
+            parameter = parseInt(param, 10);
+        }
+        // eslint-disable-next-line valid-typeof
+        if (typeof parameter !== type) throw Error(`${paramName} must be of type ${type}.`);
+    }
+
+    validateQueryString(queryString) {
+        this.validateRequiredParam('queryString', queryString);
+        this.validateParamType('queryString', queryString, 'string');
+    }
+
+    validateQueryType(queryType) {
+        this.validateRequiredParam('queryType', queryType);
+        const validQueryTypes = Object.values(QUERY_TYPES);
+        if (!validQueryTypes.includes(queryType))
+            throw Error(`Invalid query Type: available query types: ${validQueryTypes}`);
+    }
+
+    validateGraphLocation(graphLocation) {
+        this.validateRequiredParam('graphLocation', graphLocation);
+        const validGraphLocations = Object.keys(GRAPH_LOCATIONS);
+        if (!validGraphLocations.includes(graphLocation))
+            throw Error(`Invalid graph location: available locations: ${validGraphLocations}`);
+    }
+
+    validateGraphState(graphState) {
+        this.validateRequiredParam('graphState', graphState);
+        const validGraphStates = Object.keys(GRAPH_STATES);
+        if (!validGraphStates.includes(graphState))
+            throw Error(`Invalid graph state: available states: ${validGraphStates}`);
+    }
+
+    validateUAL(ual) {
+        this.validateRequiredParam('UAL', ual);
+        this.validateParamType('UAL', ual, 'string');
+
+        const segments = ual.split(':');
+        const argsString = segments.length === 3 ? segments[2] : segments[2] + segments[3];
+        const args = argsString.split('/');
+
+        if (!(args?.length === 3)) throw Error('Invalid UAL.');
+    }
+
+    validateObjectType(obj) {
+        if (!(!!obj && typeof obj === 'object')) throw Error('Content must be an object');
+    }
+
+    validateContent(content) {
+        this.validateRequiredParam('content', content);
+
         const keys = Object.keys(content);
 
         if (
@@ -11,79 +214,113 @@ class ValidationService {
         )
             throw Error('content keys can only be "public", "private" or both.');
 
-        if(!content.public && !content.private) {
+        if (!content.public && !content.private) {
             throw Error('Public or private content must be defined');
         }
 
-        if (content.public) {
-            this.validateSize(content.public);
-        }
-        if (content.private) {
-            this.validateSize(content.private);
-        }
-        this.validateBlockchain(options.blockchain);
+        if (Buffer.byteLength(JSON.stringify(content), 'utf-8') > MAX_FILE_SIZE)
+            throw Error(`File size limit is ${MAX_FILE_SIZE / (1024 * 1024)}MB.`);
     }
 
-    validateGetRequest(UAL, options) {
-        if (!UAL) throw Error('UAL is missing.');
-        this.validateValidate(options?.validate);
-        this.validateOutputFormat(options?.outputFormat);
+    validateEndpoint(endpoint) {
+        this.validateRequiredParam('endpoint', endpoint);
+        this.validateParamType('endpoint', endpoint, 'string');
+        if (!endpoint.startsWith('http') && !endpoint.startsWith('ws'))
+            throw Error('Endpoint should start with either "http" or "ws"');
     }
 
-    validateAssetTransferRequest(UAL, newOwner, options) {
-        if (!UAL || !newOwner) throw Error('Wrong parameters for the transfer.');
-        this.validateBlockchain(options.blockchain);
+    validatePort(port) {
+        this.validateRequiredParam('port', port);
+        this.validateParamType('port', port, 'number');
     }
 
-    validateContentType(obj) {
-        if (!(!!obj && typeof obj === 'object')) throw Error('Content must be an object'); 
+    validateMaxNumberOfRetries(maxNumberOfRetries) {
+        this.validateRequiredParam('maxNumberOfRetries', maxNumberOfRetries);
+        this.validateParamType('maxNumberOfRetries', maxNumberOfRetries, 'number');
     }
 
-    validateSize(content) {
-        if (!content) throw Error('No content provided');
-        if (Buffer.byteLength(JSON.stringify(content), 'utf-8') > MAX_FILE_SIZE)
-            throw Error(`File size limit is ${MAX_FILE_SIZE / (1024 * 1024)}MB.`);
+    validateFrequency(frequency) {
+        this.validateRequiredParam('frequency', frequency);
+        this.validateParamType('frequency', frequency, 'number');
+    }
+
+    validateState(state) {
+        this.validateRequiredParam('state', state);
+        this.validateParamType('state', state, 'string');
+        const validStates = Object.values(ASSET_STATES);
+        if (!validStates.includes(state.toUpperCase()))
+            throw Error(`Invalid state, available states: ${validStates}`);
+    }
+
+    validateContentType(contentType) {
+        this.validateRequiredParam('contentType', contentType);
+
+        const validContentTypes = Object.values(CONTENT_TYPES);
+        if (!validContentTypes.includes(contentType))
+          throw Error(`Invalid content visibility! Available parameters: ${validContentTypes}`)
+    }
+
+    validateEpochsNum(epochsNum) {
+        this.validateRequiredParam('epochsNum', epochsNum);
+        this.validateParamType('epochsNum', epochsNum, 'number');
+    }
+
+    validateHashFunctionId(hashFunctionId) {
+        this.validateRequiredParam('hashFunctionId', hashFunctionId);
+        this.validateParamType('hashFunctionId', hashFunctionId, 'number');
+    }
+
+    validateScoreFunctionId(scoreFunctionId) {
+        this.validateRequiredParam('scoreFunctionId', scoreFunctionId);
+        this.validateParamType('scoreFunctionId', scoreFunctionId, 'number');
+    }
+
+    validateImmutable(immutable) {
+        this.validateRequiredParam('immutable', immutable);
+        this.validateParamType('immutable', immutable, 'boolean');
+    }
+
+    validateTokenAmount(tokenAmount) {
+        if (tokenAmount == null) return;
+
+        this.validateParamType('tokenAmount', tokenAmount, 'number');
+    }
+
+    validateAuthToken(authToken) {
+        if (authToken == null) return;
+
+        this.validateParamType('authToken', authToken, 'string');
     }
 
     validateValidate(validate) {
-        if (validate && typeof validate !== 'boolean') throw Error('Valid option must be boolean');
+        this.validateRequiredParam('validate', validate);
+        this.validateParamType('validate', validate, 'boolean');
     }
 
     validateOutputFormat(outputFormat) {
-        if (
-            outputFormat &&
-            GET_OUTPUT_FORMATS.JSON_LD !== outputFormat &&
-            GET_OUTPUT_FORMATS.N_QUADS !== outputFormat
-        )
-            throw Error('Unknown output format');
+        this.validateRequiredParam('outputFormat', outputFormat);
+        const validOutputFormats = Object.values(GET_OUTPUT_FORMATS);
+        if (!validOutputFormats.includes(outputFormat))
+            throw Error(`Invalid query Type: available query types: ${validOutputFormats}`);
     }
 
     validateBlockchain(blockchain, operation) {
-        if (!blockchain) throw Error('Blockchain configuration missing');
-        if (!blockchain.name) throw Error('Blockchain name missing');
-        if (nodeSupported() && !blockchain.rpc && !BLOCKCHAINS[blockchain.name].rpc)
-            throw Error('Blockchain rpc missing');
-        if (!blockchain.hubContract && !BLOCKCHAINS[blockchain.name].hubContract)
-            throw Error('Blockchain hub contract missing');
-        if (operation !== OPERATIONS.GET) {
-            if (!blockchain.publicKey && nodeSupported())
-                throw Error('Blockchain public key missing');
-            if (!blockchain.privateKey && nodeSupported())
-                throw Error('Blockchain private key missing');
-        }
-    }
+        this.validateRequiredParam('blockchain', blockchain);
+        this.validateRequiredParam('blockchain name', blockchain.name);
+        this.validateRequiredParam('blockchain hub contract', blockchain.hubContract);
+        if (nodeSupported()) {
+            this.validateRequiredParam('blockchain rpc', blockchain.rpc);
 
-    validateKeywords(keywords) {
-        if (!keywords) throw Error('No keywords provided');
-        if (!Array.isArray(keywords)) throw Error('Keywords must be an array');
-        if (keywords.length <= 0) throw Error('Keywords array must be non empty');
-        if (keywords.length > 10) throw Error('Too many keywords provided, limit is 10.');
-        if (!keywords.every((i) => typeof i === 'string' && i !== ''))
-            throw Error('all keywords must be non empty strings');
+            if (operation !== OPERATIONS.GET) {
+                this.validateRequiredParam('blockchain public key', blockchain.publicKey);
+                this.validateRequiredParam('blockchain private key', blockchain.privateKey);
+            }
+        }
     }
 
-    validateGetOwnerRequest(UAL) {
-        if (!UAL) throw Error('UAL is missing.');
+    validateNewOwner(newOwner) {
+        this.validateRequiredParam('newOwner', newOwner);
+        this.validateParamType('newOwner', newOwner, 'string');
     }
 }
 module.exports = ValidationService;

package/webpack.config.js

@@ -1,9 +1,9 @@
 const path = require('path');
-const TerserPlugin = require('terser-webpack-plugin');
 const webpack = require('webpack');
+const TerserPlugin = require('terser-webpack-plugin');
 
 module.exports = {
-    mode: 'development',
+    mode: 'production',
     entry: './index.js',
     output: {
         path: path.resolve(__dirname, 'dist'),
@@ -23,6 +23,12 @@ module.exports = {
     resolve: {
         fallback: {
             fs: false,
+            zlib: false,
+            url: false,
+            os: false,
+            path: false,
+            net: false,
+            tls: false,
             stream: require.resolve('stream-browserify'),
             http: require.resolve('stream-http/'),
             https: require.resolve('https-browserify/'),