@digitalspaces/cli/lib/ApiInterface.js

/*
 * Copyright (C) 2019 Forward Thinking, Inc. - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 */
'use strict';

process.env.DIGITALSPACES_DEBUG_RUNTIME_ID;
process.env.DIGITALSPACES_CLI_BASE_URL;

const _ = require('lodash');
const __ = require('@digitalspaces/utils');
const Debug = require('debug');
const Config = require('./Config.js');

class ApiInterface {

	/**
	 *
	 * @param config {Config|object=}
	 * @returns {ApiInterface}
	 */
	constructor(config) {

		/** @type Config */
		this.config = ( config instanceof Config ) ? config : new Config(( __.type(config) === 'object' ) ? config : undefined);

		this.debug = Debug('ApiInterface');

		return this;
	}

	/**
	 *
	 * @param blueprintRepo
	 * @param blueprintName
	 * @returns {Promise<boolean>}
	 */
	async '/blueprints/exists'(blueprintRepo, blueprintName) {

		if( __.type(blueprintRepo) !== 'string' || blueprintRepo === '' )
			throw __.error('expect (blueprintRepo) to be a non-empty string.', {blueprintRepo});

		if( __.type(blueprintName) !== 'string' || blueprintName === '' )
			throw __.error('expect (blueprintName) to be a non-empty string.', {blueprintName});

		return await this._request(`${blueprintRepo}/exists`, {args: [blueprintName], auth: true});

	}

	async '/blueprints/init'(blueprintRepo, blueprintName) {

		if( __.type(blueprintRepo) !== 'string' || blueprintRepo === '' )
			throw __.error('expect (blueprintRepo) to be a non-empty string.', {blueprintRepo});

		if( __.type(blueprintName) !== 'string' || blueprintName === '' )
			throw __.error('expect (blueprintName) to be a non-empty string.', {blueprintName});

		return await this._request(`${blueprintRepo}/create`, {args: [blueprintName], auth: true});

	}

	/**
	 *
	 * @param blueprintRepo {string}
	 * @returns {Promise<array>}
	 */
	async '/blueprints/list'(blueprintRepo) {

		if( __.type(blueprintRepo) !== 'string' || blueprintRepo === '' )
			throw __.error('expect (blueprintRepo) to be a non-empty string.', {blueprintRepo});

		return await this._request(`${blueprintRepo}/list`, {auth: true});

	}

	async '/blueprints/repos/init'(options) {

		const userId = await this.config.get('userId');

		if( __.type(userId) !== 'string' || userId === '' )
			throw __.error('expect (userId) to be a non-empty string.', {userId});

		return this._request(`${userId}/repos/init`, {auth: true});

	}

	/**
	 *
	 * @returns {Promise<array>}
	 */
	async '/blueprints/repos/list'() {

		const userId = await this.config.get('userId');

		if( __.type(userId) !== 'string' || userId === '' )
			throw __.error('expect (userId) to be a non-empty string.', {userId});

		return await this._request(`${userId}/repos/list`, {auth: true});
	}

	async '/blueprints/versions/exists'(blueprintRepo, blueprintName, blueprintVersion) {

		if( __.type(blueprintRepo) !== 'string' || blueprintRepo === '' )
			throw __.error('expect (blueprintRepo) to be a non-empty string.', {blueprintRepo});

		if( __.type(blueprintName) !== 'string' || blueprintName === '' )
			throw __.error('expect (blueprintName) to be a non-empty string.', {blueprintName});

		if( __.type(blueprintVersion) !== 'string' || blueprintVersion === '' )
			throw __.error('expect (blueprintVersion) to be a non-empty string.', {blueprintVersion});

		return await this._request(`${blueprintRepo}/versions/exists`, {
			args: [blueprintName, blueprintVersion],
			auth: true
		});
	}

	async '/blueprints/versions/list'(blueprintRepo, blueprintName) {

		if( __.type(blueprintRepo) !== 'string' || blueprintRepo === '' )
			throw __.error('expect (blueprintRepo) to be a non-empty string.', {blueprintRepo});

		if( __.type(blueprintName) !== 'string' || blueprintName === '' )
			throw __.error('expect (blueprintName) to be a non-empty string.', {blueprintName});

		return await this._request(`${blueprintRepo}/versions/list`, {args: [blueprintName], auth: true});
	}

	async '/blueprints/versions/pull'(blueprintRepo, blueprintName, blueprintVersion) {

		if( __.type(blueprintRepo) !== 'string' || blueprintRepo === '' )
			throw __.error('expect (blueprintRepo) to be a non-empty string.', {blueprintRepo});

		if( __.type(blueprintName) !== 'string' || blueprintName === '' )
			throw __.error('expect (blueprintName) to be a non-empty string.', {blueprintName});

		if( __.type(blueprintVersion) !== 'string' || blueprintVersion === '' )
			throw __.error('expect (blueprintVersion) to be a non-empty string.', {blueprintVersion});

		return await this._request(`${blueprintRepo}/versions/read`, {
			args: [blueprintName, blueprintVersion],
			auth: true
		});
	}

	async '/blueprints/versions/push'(blueprintRepo, blueprintName, blueprintVersion, blueprintFileString) {

		const BlueprintUtils = require('@digitalspaces/blueprint-utils');

		if( __.type(blueprintRepo) !== 'string' || ! BlueprintUtils.isValidRepo(blueprintRepo) )
			throw __.error('expect (blueprintRepo) to be a valid Blueprint Repository.', {blueprintRepo});

		if( __.type(blueprintName) !== 'string' || ! BlueprintUtils.isValidName(blueprintName) )
			throw __.error('expect (blueprintName) to be a valid Blueprint Name.', {blueprintName});

		if( __.type(blueprintVersion) !== 'string' || ! BlueprintUtils.isValidVersion(blueprintVersion) )
			throw __.error('expect (blueprintVersion) to be a valid Blueprint Version.', {blueprintVersion})

		if( __.type(blueprintFileString) !== 'string' || blueprintFileString === '' )
			throw __.error('expect (blueprintFileString) to be a non-empty string.', {blueprintFileString});

		return await this._request(`${blueprintRepo}/versions/create`, {
			args: [blueprintName, blueprintFileString, {blueprintVersion}],
			auth: true
		});
	}

	async '/blueprints/versions/push/dev'(blueprintRepo, blueprintName, blueprintFileString, {forceNewVersion} = {}) {

		const BlueprintUtils = require('@digitalspaces/blueprint-utils');

		if( __.type(blueprintRepo) !== 'string' || ! BlueprintUtils.isValidRepo(blueprintRepo) )
			throw __.error('expect (blueprintRepo) to be a valid Blueprint Repository.', {blueprintRepo});

		if( __.type(blueprintName) !== 'string' || ! BlueprintUtils.isValidName(blueprintName) )
			throw __.error('expect (blueprintName) to be a valid Blueprint Name.', {blueprintName});

		if( __.type(blueprintFileString) !== 'string' || blueprintFileString === '' )
			throw __.error('expect (blueprintFileString) to be a non-empty string.', {blueprintFileString});

		if( ! __.isUndef(forceNewVersion) && ! __.isBool(forceNewVersion) )
			throw __.error('expect (forceNewVersion) to be a boolean if provided.', {'forceNewVersion': forceNewVersion});

		return await this._request(`${blueprintRepo}/versions/create/dev`, {
			args: [blueprintName, blueprintFileString, {forceNewVersion}],
			auth: true
		});
	}

	async '/objects/init'(spaceId, blueprintRepo, blueprintName, blueprintVersion, {initParams} = {}) {

		if( __.type(spaceId) !== 'string' || ! __.regexps.uuid.test(spaceId) )
			throw __.error('expect (spaceId) to be a uuid.', {spaceId});

		if( initParams !== undefined ){

			if(__.type(initParams) !== 'string' || initParams === '')
				throw __.error('expect (initParams) to be a non-empty string<json> if provided.', {initParams});

			try{
				const json = JSON.parse(initParams);
			}
			catch(err){
				throw __.error('expect (initParams) to be a valid JSON string if provided.', err)
			}

		}

		return await this._request(`${spaceId}/$objects/init`, {args: [blueprintRepo, blueprintName, blueprintVersion, {initParams}], auth: true})
	}

	async '/objects/list'(spaceId) {

		if( __.type(spaceId) !== 'string' || ! __.regexps.uuid.test(spaceId) )
			throw __.error('expect (spaceId) to be a uuid.', {spaceId});

		return await this._request(`${spaceId}/$objects/list`, {auth: true})

	}

	async '/objects/spaces/init'() {

		const userId = await this.config.get('userId');

		if( __.type(userId) !== 'string' || userId === '' )
			throw __.error('expect (userId) to be a non-empty string.', {userId});

		return await this._request(`${userId}/spaces/init`, {auth: true});
	}

	async '/objects/spaces/list'() {

		const userId = await this.config.get('userId');

		if( __.type(userId) !== 'string' || userId === '' )
			throw __.error('expect (userId) to be a non-empty string.', {userId});

		return await this._request(`${userId}/spaces/list`, {auth: true});
	}

	/**
	 *
	 * @returns {Promise<{debugRuntimeToken: string}>}
	 */
	async '/objects/spaces/debug/authorize'(){

		const userId = await this.config.get('userId');

		if( __.type(userId) !== 'string' || userId === '' )
			throw __.error('expect (userId) to be a non-empty string.', {userId});

		const {debugRuntimeToken} = await this._request(`${userId}/spaces/debug/authorize`, {args: [userId], auth: true});

		if( ! __.isStringNonEmpty(debugRuntimeToken) || ! __.regexps.authToken.test(debugRuntimeToken) )
			throw __.error('expect (debugRuntimeToken) to be a non-empty string.', {debugRuntimeToken});

		return {debugRuntimeToken};

	}

	async '/users/login'(email, password) {

		if( ! __.regexps.email.test(email) )
			throw __.error('expect (email) to be a valid email address.', {email});

		if( ! __.regexps.password.test(password) )
			throw __.error('expect (password) to be a valid complex password [0-9a-zA-Z ~!@#$%^&*()_+{}|:"<>?`\\-=[\\]\\\\;\',./]{8,}.');

		return await this._request('g/users/login', {args: [email, password]});

	}

	async '/users/refreshToken'() {

		const {userId, authToken} = await this.config.get();

		if( __.type(userId) !== 'string' || userId === '' )
			throw __.error('expect (userId) to be a non-empty string.', {userId});

		if( __.type(authToken) !== 'string' || authToken === '' )
			throw __.error('expect (authToken) to be a non-empty string.', {authToken});

		return await this._request(`${userId}/tokens/refresh`, {args: [authToken]});
	}

	/**
	 *
	 * @param email
	 * @param password
	 * @param firstName
	 * @param lastName
	 * @returns {Promise<{authToken: string, userId: string}>}
	 */
	async '/users/register'(email, password, {firstName, lastName} = {}) {

		if( ! __.regexps.email.test(email) )
			throw __.error('expect (email) to be a valid email address.', {email});

		if( ! __.regexps.password.test(password) )
			throw __.error('expect (password) to be a valid complex password [0-9a-zA-Z ~!@#$%^&*()_+{}|:"<>?`\\-=[\\]\\\\;\',./]{8,}.');

		if( __.type(firstName) !== 'string' || firstName === '' )
			throw __.error('expect (firstName) to be a non-empty string.', {firstName});

		if( __.type(lastName) !== 'string' || lastName === '' )
			throw __.error('expect (lastName) to be a non-empty string.', {lastName});

		const response = await this._request('g/users/register', {args: [email, password, {firstName, lastName}]});

		if( ! response )
			throw __.error(['UnexpectedResponse'], {response});

		if( ! _.isString(response.authToken) || ! __.regexps.authToken.test(response.authToken) )
			throw __.error(['UnexpectedResponse'], {response});

		if( ! _.isString(response.userId) || ! __.regexps.uuid.test(response.userId) )
			throw __.error(['UnexpectedResponse'], {response});

		return response;

	}

	async '/users/update'({firstName, lastName, email, password}, existingPassword) {

		const details = {};

		if( __.type(existingPassword) !== 'string' || existingPassword === '' )
			throw __.error('expect (existingPassword) to be a non-empty string.', {existingPassword});

		if( firstName !== undefined ) {
			if( __.type(firstName) !== 'string' || firstName === '' )
				throw __.error('expect (firstName) to be a non-empty string.', {firstName});
			details.firstName = firstName;
		}

		if( lastName !== undefined ) {
			if( __.type(lastName) !== 'string' || lastName === '' )
				throw __.error('expect (lastName) to be a non-empty string.', {lastName});
			details.lastName = lastName;
		}

		if( email !== undefined ) {
			if( ! __.regexps.email.test(email) )
				throw __.error('expect (email) to be a valid email address.', {email});
			details.email = email;
		}

		if( password !== undefined ) {
			if( ! __.regexps.password.test(password) )
				throw __.error('expect (password) to be a valid password.', {password});
			details.password = password;
		}

		if( _.isEmpty(details) )
			throw __.error('expect (details) to not be empty.');

		const userId = await this.config.get('userId');

		if( __.type(userId) !== 'string' || userId === '' )
			throw __.error('expect (userId) to be a non-empty string.', {userId});

		return this._request(`${userId}/details/update`, {args: [details, existingPassword], auth: true});

	}

	/**
	 *
	 * @param url
	 * @param options
	 * @param options.method {string}
	 * @param options.args {array}
	 * @param options.auth {boolean|string} This means different things depending on whether we are using object/call or not. If we are using objects/call it will ask the user object to include auth information. If we are not it will include our own local token in the request header.
	 * @param options.returnRaw {boolean}
	 * @param options.refreshAuthToken {boolean}
	 * @returns {*}
	 * @private
	 */
	async _request(url, options) {

		const Superagent = require('superagent');

		url = _.trimStart(_.trim(url), '/');

		const baseUrl = await this.config.get('baseUrl');

		if( ! baseUrl || ! _.isString(baseUrl) )
			throw new Error();

		let targetUrl = `${baseUrl}/${url}`;

		let optMethod = 'get', optArgs, optAuth, optReturnRaw, optRefreshAuthToken;

		if( options ) {

			if( options.method !== undefined )
				if( ! options.method || ! _.isString(options.method) )
					throw new Error();
				else
					optMethod = _.toLower(options.method);

			if( options.args !== undefined )
				if( ! _.isArray(options.args) )
					throw new Error();
				else
					optMethod = 'post', optArgs = options.args;

			if( options.auth !== undefined )
				if( ! _.isBoolean(options.auth) && ! _.isString(options.auth) )
					throw new Error;
				else
					optAuth = options.auth;

			if( options.returnRaw !== undefined )
				if( ! _.isBoolean(options.returnRaw) )
					throw new Error();
				else
					optReturnRaw = options.returnRaw;

			if( options.refreshAuthToken !== undefined )
				if( ! _.isBoolean(options.refreshAuthToken) )
					throw new Error();
				else
					optRefreshAuthToken = options.refreshAuthToken;

		}

		let request, userId;

		if( /^g\//.test(url) || (__.regexps.uuid.test(userId = await this.config.get('userId')) && (new RegExp(`^${userId}\/`)).test(url) ) ){

			request = Superagent[optMethod](targetUrl);

			if( optAuth ) {

				const authToken = await this.config.get('authToken');

				if( ! authToken || ! _.isString(authToken) )
					throw __.error(['AuthError', 'AuthToken required. Trying logging in.'])

				request.set('Authorization', `JWT ${authToken}`);
			}

			if( optArgs !== undefined )
				request.send(optArgs);

		}
		else{ //If the url is going to anything other than global try to proxy the request through the user (making sure to only read the userId if the request is not to global

			if( ! __.regexps.uuid.test(userId) )
				throw __.error('expect (userId) to be a uuid.', {userId});

			const authToken = await this.config.get('authToken');

			if( ! authToken )
				throw __.error(['AuthError', 'AuthToken required. Trying logging in.'])

			const [, objectId, actionName] = url.match(/^([^/]+)\/(.+)/) || __.throw('expect (url) to be "${objectPath}/${objectAction}".', {url})

			targetUrl = `${baseUrl}/${userId}/objects/call`;

			if( optArgs !== undefined )
				optArgs = [objectId, actionName, optArgs];
			else
				optMethod = 'post', optArgs = [objectId, actionName];

			if( ! __.regexps.authToken.test(authToken) )
				throw new Error();

			if( optAuth === true )
				optArgs[3] = {useAuthToken: true};

			request = Superagent[optMethod](targetUrl);

			request.set('Authorization', `JWT ${authToken}`);

			request.send(optArgs);

		}

		//this.debug('_request():', {request});

		let response;

		try {

			response = await request;

		}
		catch( err ) {

			this.debug('_request(): response error', {response: err.response});

			if( optReturnRaw )
				return err.response;

			if( err.response ){

				if( err.response.status === 555 )
					throw __.error(__.errorFromJSON(err.response.body));

				throw __.error(`HTTP call returned status != 200. (status: ${err.response.status}) (name: ${err.response.body.error && err.response.body.error.name}) (message: ${err.response.body.error && err.response.body.error.message})`, {
					status: err.response.status,
					headers: err.response.headers,
					body: err.response.body
				});
			}
			else
				throw __.error('HTTP call did not receive a response.', err);
		}

		if( optReturnRaw )
			return response;

		return response.body;
	}

}

module.exports = ApiInterface;

module.exports.ApiInterface = ApiInterface;