Add native .env file support #418

Author: Huachao

README.md

@@ -27,7 +27,15 @@ REST Client allows you to send HTTP request and view the response in Visual Stud
     - Diagnostic support for __request__ and __file__ custom variables
     - Go to definition support for __request__ and __file__ custom variables
     - Find all references support _ONLY_ for __file__ custom variables
-    - Provide system dynamic variables `{{$guid}}`, `{{$randomInt min max}}`, `{{$timestamp [offset option]}}`, `{{$datetime rfc1123|iso8601 [offset option]}}`, `{{$processEnv [%]envVarName}}`, `{{$localDatetime rfc1123|iso8601 [offset option]}}`, `{{$processEnv [%]envVarName}}`, and `{{$aadToken [new] [public|cn|de|us|ppe] [<domain|tenantId>] [aud:<domain|tenantId>]}}`
+    - Provide system dynamic variables
+      + `{{$guid}}`
+      + `{{$randomInt min max}}`
+      + `{{$timestamp [offset option]}}`
+      + `{{$datetime rfc1123|iso8601 [offset option]}}`
+      + `{{$localDatetime rfc1123|iso8601 [offset option]}}`
+      + `{{$processEnv [%]envVarName}}`
+      + `{{$dotenv variableName}}`
+      + `{{$aadToken [new] [public|cn|de|us|ppe] [<domain|tenantId>] [aud:<domain|tenantId>]}}`
     - Easily create/update/delete environments and environment variables in setting file
     - File variables can reference both custom and system variables
     - Support environment switch
@@ -537,6 +545,7 @@ For example: Define a shell environment variable in `.bashrc` or similar on wind
   `%`: Optional. If specified, treats envVarName as an extension setting environment variable, and uses the value of that for the lookup.
 
 
+* `{{$dotenv variableName}}`: Returns the environment value stored in the [`.env`](https://github.com/motdotla/dotenv) file which exists in the same directory of your `.http` file.
 * `{{$randomInt min max}}`: Returns a random integer between min (included) and max (excluded)
 * `{{$timestamp [offset option]}}`: Add UTC timestamp of now. You can even specify any date time based on current time in the format `{{$timestamp number option}}`, e.g., to represent 3 hours ago, simply `{{$timestamp -3 h}}`; to represent the day after tomorrow, simply `{{$timestamp 2 d}}`.
 * `{{$datetime rfc1123|iso8601|"custom format"|'custom format' [offset option]}}`: Add a datetime string in either _ISO8601_, _RFC1123_ or a custom display format. You can even specify a date time relative to the current date similar to `timestamp` like: `{{$datetime iso8601 1 y}}` to represent a year later in _ISO8601_ format. If specifying a custom format, wrap it in single or double quotes like: `{{$datetime "DD-MM-YYYY" 1 y}}`. The date is formatted using moment.js, read [here](https://momentjs.com/docs/#/parsing/string-format/) for information on format strings.
@@ -563,6 +572,7 @@ Content-Type: application/xml
 Date: {{$datetime rfc1123}}
 
 {
+    "user_name": "{{$dotenv USERNAME}}",
     "request_id": "{{$guid}}",
     "updated_at": "{{$timestamp}}",
     "created_at": "{{$timestamp -1 d}}",

package-lock.json

@@ -633,6 +633,7 @@
     "applicationinsights": "^1.0.5",
     "code-highlight-linenums": "^0.2.1",
     "combined-stream": "^1.0.5",
+    "dotenv": "^8.2.0",
     "encodeurl": "^1.0.1",
     "filesize": "^3.3.0",
     "fs-extra": "^5.0.0",

package.json

@@ -31,7 +31,8 @@ export const RandomIntVariableName = "$randomInt";
 export const RandomIntDescription = "Returns a random integer between min (included) and max (excluded)";
 export const ProcessEnvVariableName = "$processEnv";
 export const ProcessEnvDescription = "Returns the value of process environment variable or '' if not found ";
-
+export const DotenvVariableName = "$dotenv";
+export const DotenvDescription = "Returns the environment value stored in a .env file";
 export const AzureActiveDirectoryVariableName = "$aadToken";
 export const AzureActiveDirectoryDescription = "Prompts to sign in to Azure AD and adds the token to the request";
 /**

src/common/constants.ts

@@ -29,13 +29,16 @@ export const enum ResolveWarningMessage {
     ResponseBodyNotExist = "Response body of given request doesn't exist",
     IncorrectDateTimeVariableFormat = 'Datetime system variable should follow format "{{$datetime rfc1123|iso8601 [integer y|Q|M|w|d|h|m|s|ms]}}"',
     IncorrectLocalDateTimeVariableFormat = 'Local datetime system variable should follow format "{{$localDatetime rfc1123|iso8601 [integer y|Q|M|w|d|h|m|s|ms]}}"',
+    DotenvFileNotFound = '.env file is not found in the directory where current .http file exists',
+    DotenvVariableNotFound = 'Given variable name is not found in .env file',
     IncorrectHeaderName = 'No value is resolved for given header name',
     IncorrectJSONPath = 'No value is resolved for given JSONPath',
     IncorrectRandomIntegerVariableFormat = 'RandomInt system variable should follow format "{{$randomInt minInteger maxInteger}}"',
     IncorrectProcessEnvVariableFormat = 'ProcessEnv system variable should follow format "{{$processEnv envVarName}}"',
     IncorrectTimestampVariableFormat = 'Timestamp system variable should follow format "{{$timestamp [integer y|Q|M|w|d|h|m|s|ms]}}"',
+    IncorrectDotenvVariableFormat = 'Dotenv variable should follow format "{{$dotenv variableName}}"',
     IncorrectXPath = 'No value is resolved for given XPath',
-    UnsupportedBodyContentType = 'Only JSON response/request body is supported to query the result',
+    UnsupportedBodyContentType = 'Only JSON and XML response/request body is supported to query the result',
     InvalidJSONPath = 'Invalid JSONPath query',
     InvalidXPath = 'Invalid XPath query',
 }

src/models/httpVariableResolveResult.ts

@@ -124,6 +124,13 @@ export class HttpElementFactory {
             Constants.ProcessEnvDescription,
             new SnippetString(`{{$\${name:${Constants.ProcessEnvVariableName.slice(1)}} \${2:process environment variable name}}}`)
         ));
+        originalElements.push(new HttpElement(
+            Constants.DotenvVariableName,
+            ElementType.SystemVariable,
+            null,
+            Constants.DotenvDescription,
+            new SnippetString(`{{$\${name:${Constants.DotenvVariableName.slice(1)}} \${2:.env variable name}}}`)
+        ));
         originalElements.push(new HttpElement(
             Constants.AzureActiveDirectoryVariableName,
             ElementType.SystemVariable,

src/utils/httpElementFactory.ts

@@ -1,8 +1,11 @@
 'use strict';
 
 import * as adal from 'adal-node';
+import * as dotenv from 'dotenv';
+import * as fs from 'fs-extra';
 import { DurationInputArg2, Moment, utc } from 'moment';
-import { Clipboard, commands, env, QuickPickItem, QuickPickOptions, Uri, window } from 'vscode';
+import * as path from 'path';
+import { Clipboard, commands, env, QuickPickItem, QuickPickOptions, TextDocument, Uri, window } from 'vscode';
 import * as Constants from '../../common/constants';
 import { HttpRequest } from '../../models/httpRequest';
 import { ResolveErrorMessage, ResolveWarningMessage } from '../../models/httpVariableResolveResult';
@@ -15,7 +18,7 @@ import { HttpVariable, HttpVariableContext, HttpVariableProvider } from './httpV
 const uuidv4 = require('uuid/v4');
 
 type SystemVariableValue = Pick<HttpVariable, Exclude<keyof HttpVariable, 'name'>>;
-type ResolveSystemVariableFunc = (name: string, context: HttpVariableContext) => Promise<SystemVariableValue>;
+type ResolveSystemVariableFunc = (name: string, document: TextDocument, context: HttpVariableContext) => Promise<SystemVariableValue>;
 
 export class SystemVariableProvider implements HttpVariableProvider {
 
@@ -27,6 +30,8 @@ export class SystemVariableProvider implements HttpVariableProvider {
     private readonly randomIntegerRegex: RegExp = new RegExp(`\\${Constants.RandomIntVariableName}\\s(\\-?\\d+)\\s(\\-?\\d+)`);
     private readonly processEnvRegex: RegExp = new RegExp(`\\${Constants.ProcessEnvVariableName}\\s(\\%)?(\\w+)`);
 
+    private readonly dotenvRegex: RegExp = new RegExp(`\\${Constants.DotenvVariableName}\\s([\\w-.]+)`);
+
     private readonly requestUrlRegex: RegExp = /^(?:[^\s]+\s+)([^:]*:\/\/\/?[^/\s]*\/?)/;
 
     private readonly aadRegex: RegExp = new RegExp(`\\s*\\${Constants.AzureActiveDirectoryVariableName}(\\s+(${Constants.AzureActiveDirectoryForceNewOption}))?(\\s+(ppe|public|cn|de|us))?(\\s+([^\\.]+\\.[^\\}\\s]+|[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}))?(\\s+aud:([^\\.]+\\.[^\\}\\s]+|[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}))?\\s*`);
@@ -50,23 +55,24 @@ export class SystemVariableProvider implements HttpVariableProvider {
         this.registerGuidVariable();
         this.registerRandomIntVariable();
         this.registerProcessEnvVariable();
+        this.registerDotenvVariable();
         this.registerAadTokenVariable();
     }
 
     public readonly type: VariableType = VariableType.System;
 
-    public async has(name: string): Promise<boolean> {
+    public async has(name: string, document: TextDocument): Promise<boolean> {
         const [variableName] = name.split(' ').filter(Boolean);
         return this.resolveFuncs.has(variableName);
     }
 
-    public async get(name: string, document: undefined, context: HttpVariableContext): Promise<HttpVariable> {
+    public async get(name: string, document: TextDocument, context: HttpVariableContext): Promise<HttpVariable> {
         const [variableName] = name.split(' ').filter(Boolean);
         if (!this.resolveFuncs.has(variableName)) {
             return { name: variableName, error: ResolveErrorMessage.SystemVariableNotExist };
         }
 
-        const result = await this.resolveFuncs.get(variableName)!(name, context);
+        const result = await this.resolveFuncs.get(variableName)!(name, document, context);
         return { name: variableName, ...result };
     }
 
@@ -138,7 +144,7 @@ export class SystemVariableProvider implements HttpVariableProvider {
     }
 
     private registerGuidVariable() {
-        this.resolveFuncs.set(Constants.GuidVariableName, async name => ({ value: uuidv4() }));
+        this.resolveFuncs.set(Constants.GuidVariableName, async () => ({ value: uuidv4() }));
     }
 
     private registerRandomIntVariable() {
@@ -181,17 +187,38 @@ export class SystemVariableProvider implements HttpVariableProvider {
                 }
                 const envValue = process.env[processEnvName];
                 if (envValue !== undefined) {
-                    return { value: envValue.toString()};
+                    return { value: envValue.toString() };
                 } else {
-                    return { value: ''};
+                    return { value: '' };
                 }
             }
             return { warning: ResolveWarningMessage.IncorrectProcessEnvVariableFormat };
         });
     }
 
+    private registerDotenvVariable() {
+        this.resolveFuncs.set(Constants.DotenvVariableName, async (name, document) => {
+            const absolutePath = path.join(path.dirname(document.fileName), '.env');
+            if (!await fs.pathExists(absolutePath)) {
+                return { warning: ResolveWarningMessage.DotenvFileNotFound };
+            }
+            const parsed = dotenv.parse(fs.readFileSync(absolutePath));
+            const groups = this.dotenvRegex.exec(name);
+            if (groups !== null && groups.length === 2) {
+                const [, key] = groups;
+                if (!(key in parsed)) {
+                    return { warning: ResolveWarningMessage.DotenvVariableNotFound };
+                }
+
+                return { value: parsed[key] };
+            }
+
+            return { warning: ResolveWarningMessage.IncorrectDotenvVariableFormat };
+        });
+    }
+
     private registerAadTokenVariable() {
-        this.resolveFuncs.set(Constants.AzureActiveDirectoryVariableName, (name, context) => {
+        this.resolveFuncs.set(Constants.AzureActiveDirectoryVariableName, (name, document, context) => {
             // get target app from URL
             const match = this.requestUrlRegex.exec(context.parsedRequest);
             const url = (match && match[1]) || context.parsedRequest;