Support new API key authentication context (#57)

Author: ziv-codefresh

examples/cfconfig

@@ -1,14 +1,7 @@
 contexts:
-  testcontext1:
-    type: JWT
-    name: testcontext1
+  default:
+    type: APIKey
+    name: blabla
     url: 'https://g.codefresh.io'
-    token: >-
-      eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJfaWQiOiI1NTJlOTQyMjM4MjQ4MzFkMDBiMWNhM2UiLCJhY2NvdW50SWQiOiI1NjgwZjEzMDM0Y2RiMzE3N2M4MmFjYjIiLCJpYXQiOjE1MTIyMzA5MDcsImV4cCI6MTUxNDgyMjkwN30.-OUq7kVLVghCjV4tp7swSzCyzPn-GR3ZF0A-aZo1ic0
-    acl-type: account
-    user-id: 552e94223824831d00b1ca3e
-    account-id: 5680f13034cdb3177c82acb2
-    expires: 1514822907
-    user-name: verchol
-    account-name: verchol_github
-current-context: testcontext1
+    token: 5a4e0b118f2eba0100b538c8.d732aaae8b55fc99a359735644399cdc
+current-context: default

lib/interface/cli/codefresh

@@ -39,7 +39,7 @@ recursive(path.resolve(__dirname, 'commands'), (err, files) => {
         })
         .config('cfconfig', 'Custom path for authentication contexts config file', (configFilePath) => {
             try {
-                authManager.loadContexts(configFilePath, process.env.CF_TOKEN, process.env.CF_URL || DEFAULTS.URL);
+                authManager.loadContexts(configFilePath, process.env.CF_API_KEY, process.env.CF_URL || DEFAULTS.URL);
             } catch (err) {
                 printError(err);
                 process.exit(1);

lib/interface/cli/commands/auth/create-context.cmd.js

@@ -4,49 +4,52 @@ const _ = require('lodash');
 const CFError = require('cf-errors');
 const DEFAULTS = require('../../defaults');
 const { auth } = require('../../../../logic');
-const { JWTContext } = auth.contexts;
+const { JWTContext, APIKeyContext } = auth.contexts;
 const authManager = auth.manager;
 const authRoot = require('../root/auth.cmd');
 
 const _loginWithToken = async (url, token) => {
+    let authContext;
     try {
-        const authContext = JWTContext.createFromToken(token, url);
+        authContext = JWTContext.createFromToken(token, url);
         return authContext;
 
     } catch (err) {
-        const error = new CFError({
-            cause: err,
-            message: 'Failed to login with token',
-        });
-        throw error;
+        try {
+            authContext = APIKeyContext.createFromToken(token, url);
+            return authContext;
+
+        } catch (err) {
+            const error = new CFError({
+                cause: err,
+                message: 'Failed to login with api key',
+            });
+            throw error;
+        }
     }
 };
 
 const command = new Command({
-    command: 'create-context <name>',
+    command: 'create-context [name]',
     description: 'create-context',
     builder: (yargs) => {
         return yargs
-            .usage('Create a new context from a given token')
+            .usage('Create a new authentication context using an API key')
             .option('url', {
                 describe: 'Codefresh system custom url',
                 default: DEFAULTS.URL,
             })
             .positional('name', {
                 describe: 'Context name',
+                default: 'default',
             })
-            .option('token', {
-                describe: 'Access token',
+            .option('api-key', {
+                describe: 'API key',
                 required: true,
-            })
-            .option('type', {
-                describe: 'Token type',
-                choices: [JWTContext.TYPE],
-                default: JWTContext.TYPE,
             });
     },
     handler: async (argv) => {
-        const authContext = await _loginWithToken(argv.url, argv.token);
+        const authContext = await _loginWithToken(argv.url, argv['api-key']);
 
         await authContext.validate();
 

lib/interface/cli/commands/root/auth.cmd.js

@@ -14,11 +14,11 @@ const auth = new Command({
                 'place.\n' +
                 '  2. If $CFCONFIG environment variable is set, then it is used as the cfconfig file path.\n' +
                 '  3. Otherwise, ${HOME}/.cfconfig is used.\n' +
-                '  4. If $CF_TOKEN environment variable is set, then it will be used as the current-context ($CF_URL can be used for custom Codefresh systems).')
+                '  4. If $CF_API_KEY environment variable is set, then it will be used as the current-context ($CF_URL can be used for custom Codefresh systems).')
             .example('$0 auth login username password', '# Login using USER and PASSWORD')
             .example('$0 auth login username password --url http://custom-domain.com',
                 '# Login using USER and PASSWORD to a CUSTOM on-premise codefresh instance')
-            .example('$0 auth create-context name --token token', '# Create authentication context NAME using TOKEN')
+            .example('$0 auth create-context name --api-key key', '# Create authentication context NAME using KEY')
             .example('$0 auth get-contexts', '# List all existing authentication contexts')
             .example('$0 auth use-context name', '# Set active authentication context using NAME context')
             .example('$0 auth current-context', '# Show active authentication context')

lib/logic/api/helper.js

@@ -19,7 +19,7 @@ const sendHttpRequest = async (httpOptions, authContext) => {
         response = await rp(finalOptions);
     } catch (err) {
         if (_.isEqual(err.statusCode, 401)) {
-            printError('Unauthorized error: Please update your authentication context');
+            printError('Unauthorized error: Please create or update your authentication context');
             process.exit(1);
         }
         if (_.isEqual(err.statusCode, 403)) {

lib/logic/auth/contexts/APIKeyContext.js

@@ -0,0 +1,68 @@
+const _ = require('lodash');
+const CFError = require('cf-errors');
+const Context = require('./Context');
+const api = require('../../api');
+
+const TYPE = 'APIKey';
+
+class APIKeyContext extends Context {
+    constructor(options) {
+        super(options);
+        this.type = TYPE;
+        this.token = options.token;
+        this.name = options.name || this.name;
+        this.defaultColumns = ['current', 'name', 'url'];
+    }
+
+    prepareHttpOptions() {
+        return {
+            baseUrl: this.url,
+            headers: {
+                Authorization: this.token,
+            },
+        };
+    }
+
+    async validate() {
+        try {
+            await api.user.getByAuthContext(this);
+        } catch (err) {
+            // TODO catch 401 errors, etc...
+            throw new CFError({
+                cause: err,
+                message: 'API Key is not valid',
+            });
+        }
+    }
+
+    toString() {
+        return `name: ${this.name}, url: ${this.url}`;
+    }
+
+    serialize() {
+        const data = {
+            token: this.token,
+        };
+
+        return _.assignIn(super.serialize(), data);
+    }
+
+    static createFromSerialized(rawContext) {
+        return new APIKeyContext({
+            name: rawContext.name,
+            url: rawContext.url,
+            token: rawContext.token,
+        });
+    }
+
+    static createFromToken(token, url) {
+        return new APIKeyContext({
+            token,
+            url,
+        });
+    }
+}
+
+APIKeyContext.TYPE = TYPE;
+
+module.exports = APIKeyContext;

lib/logic/auth/contexts/index.js

@@ -1,5 +1,7 @@
 const JWTContext = require('./JWTContext');
+const APIKeyContext = require('./APIKeyContext');
 
 module.exports = {
     JWTContext,
+    APIKeyContext,
 };

lib/logic/auth/manager.js

@@ -4,7 +4,7 @@ const CFError = require('cf-errors');
 const yaml = require('js-yaml');
 
 // context classes
-const { JWTContext } = require('./contexts');
+const { JWTContext, APIKeyContext } = require('./contexts');
 
 /**
  * A singelton that is in charge of providing an easy interface to the authentication configuration file on the file system
@@ -84,6 +84,11 @@ class Manager {
                         this.addContext(context);
                         break;
                     }
+                    case APIKeyContext.TYPE: {
+                        const context = APIKeyContext.createFromSerialized(rawContext);
+                        this.addContext(context);
+                        break;
+                    }
                     default: {
                         throw new CFError(`Failed to parse context of type: ${rawContext.type}`);
                     }
@@ -111,17 +116,23 @@ class Manager {
 
         // Supports the ability to use the cli with a JWT token
         // TODO in the future when we support more than 1 type of token (Currently only JWT) we need to refactor this
-        try {
-            if (cfToken && cfUrl) {
+        if (cfToken && cfUrl) {
+            try {
                 const context = JWTContext.createFromToken(cfToken, cfUrl);
                 this.addContext(context);
                 this.setCurrentContext(context);
+            } catch (err) {
+                try {
+                    const context = APIKeyContext.createFromToken(cfToken, cfUrl);
+                    this.addContext(context);
+                    this.setCurrentContext(context);
+                } catch (error) {
+                    throw new CFError({
+                        cause: error,
+                        message: 'Failed to parse CF_API_KEY environment variable',
+                    });
+                }
             }
-        } catch (err) {
-            throw new CFError({
-                cause: err,
-                message: 'Failed to handle CF_TOKEN',
-            });
         }
     }
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "codefresh",
-  "version": "0.4.9",
+  "version": "0.5.0",
   "description": "Codefresh command line utility",
   "main": "index.js",
   "preferGlobal": true,