Merge pull request #1303 from opencomponents/env

add ability to retreieve environment variables from an env file

Author: ricardo-devis-agullo

.github/workflows/node.js.yml

@@ -5,13 +5,12 @@ name: Node.js CI
 
 on:
   push:
-    branches: [ master ]
+    branches: [master]
   pull_request:
-    branches: [ master ]
+    branches: [master]
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
 
     strategy:
@@ -20,11 +19,11 @@ jobs:
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
 
     steps:
-    - uses: actions/checkout@v2
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v2
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: npm install
-    - run: npm test
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+      - run: npm install
+      - run: npm test

package.json

@@ -92,6 +92,7 @@
     "colors": "1.4.0",
     "cross-spawn": "7.0.3",
     "dependency-graph": "0.11.0",
+    "dotenv": "16.0.1",
     "errorhandler": "1.5.1",
     "express": "4.18.2",
     "form-data": "4.0.0",

src/registry/domain/repository.ts

@@ -1,6 +1,7 @@
 import fs from 'fs-extra';
 import getUnixUtcTimestamp from 'oc-get-unix-utc-timestamp';
 import path from 'path';
+import dotenv from 'dotenv';
 
 import ComponentsCache from './components-cache';
 import getComponentsDetails from './components-details';
@@ -114,6 +115,14 @@ export default function repository(conf: Config) {
         content: fs.readFileSync(filePath).toString(),
         filePath
       };
+    },
+    getEnv(componentName: string): Record<string, string> {
+      const pkg: Component = fs.readJsonSync(
+        path.join(conf.path, `${componentName}/package.json`)
+      );
+      const filePath = path.join(conf.path, componentName, pkg.oc.files.env!);
+
+      return dotenv.parse(fs.readFileSync(filePath).toString());
     }
   };
 
@@ -249,6 +258,19 @@ export default function repository(conf: Config) {
 
       return { content, filePath };
     },
+    async getEnv(
+      componentName: string,
+      componentVersion: string
+    ): Promise<Record<string, string>> {
+      if (conf.local) {
+        return local.getEnv(componentName);
+      }
+
+      const filePath = getFilePath(componentName, componentVersion, '.env');
+      const file = await cdn.getFile(filePath);
+
+      return dotenv.parse(file);
+    },
     getStaticClientPath: (): string =>
       `${options!['path']}${getFilePath(
         'oc-client',

src/registry/routes/helpers/get-component.ts

@@ -19,7 +19,7 @@ import strings from '../../../resources';
 import * as urlBuilder from '../../domain/url-builder';
 import * as validator from '../../domain/validators';
 import type { Repository } from '../../domain/repository';
-import { Config } from '../../../types';
+import { Component, Config } from '../../../types';
 import { IncomingHttpHeaders } from 'http';
 import { fromPromise } from 'universalify';
 
@@ -54,13 +54,33 @@ export interface GetComponentResult {
   };
 }
 
+const noopConsole = Object.fromEntries(
+  Object.keys(console).map(key => [key, _.noop])
+);
+
 export default function getComponent(conf: Config, repository: Repository) {
   const client = Client({ templates: conf.templates });
   const cache = new Cache({
     verbose: !!conf.verbosity,
     refreshInterval: conf.refreshInterval
   });
 
+  const getEnv = async (
+    component: Component
+  ): Promise<Record<string, string>> => {
+    const cacheKey = `${component.name}/${component.version}/.env`;
+    const cached = cache.get('file-contents', cacheKey);
+
+    if (cached) return cached;
+
+    const env = component.oc.files.env
+      ? await repository.getEnv(component.name, component.version)
+      : {};
+    cache.set('file-contents', cacheKey, env);
+
+    return env;
+  };
+
   const renderer = function (
     options: RendererOptions,
     cb: (result: GetComponentResult) => void
@@ -411,136 +431,149 @@ export default function getComponent(conf: Config, repository: Repository) {
         if (!component.oc.files.dataProvider) {
           returnComponent(null, {});
         } else {
-          const cacheKey = `${component.name}/${component.version}/server.js`;
-          const cached = cache.get('file-contents', cacheKey);
-          const domain = Domain.create();
-          const setEmptyResponse =
-            emptyResponseHandler.contextDecorator(returnComponent);
-          const contextObj = {
-            acceptLanguage: acceptLanguageParser.parse(acceptLanguage!),
-            baseUrl: conf.baseUrl,
-            env: conf.env,
-            params,
-            plugins: conf.plugins,
-            renderComponent: fromPromise(nestedRenderer.renderComponent),
-            renderComponents: fromPromise(nestedRenderer.renderComponents),
-            requestHeaders: options.headers,
-            requestIp: options.ip,
-            setEmptyResponse,
-            staticPath: repository
-              .getStaticFilePath(component.name, component.version, '')
-              .replace('https:', ''),
-            setHeader: (header?: string, value?: string) => {
-              if (!(typeof header === 'string' && typeof value === 'string')) {
-                throw strings.errors.registry
-                  .COMPONENT_SET_HEADER_PARAMETERS_NOT_VALID;
-              }
-
-              if (header && value) {
-                responseHeaders = responseHeaders || {};
-                responseHeaders[header.toLowerCase()] = value;
-              }
-            },
-            templates: repository.getTemplatesInfo()
-          };
-
-          const setCallbackTimeout = () => {
-            const executionTimeout = conf.executionTimeout;
-            if (executionTimeout) {
-              setTimeout(() => {
-                const message = `timeout (${executionTimeout * 1000}ms)`;
-                returnComponent({ message }, undefined);
-                domain.exit();
-              }, executionTimeout * 1000);
+          fromPromise(getEnv)(component, (err, env) => {
+            if (err) {
+              componentCallbackDone = true;
+
+              return callback({
+                status: 502,
+                response: {
+                  code: 'ENV_RESOLVING_ERROR',
+                  error: strings.errors.registry.RESOLVING_ERROR
+                }
+              });
             }
-          };
 
-          if (!!cached && !conf.hotReloading) {
-            domain.on('error', returnComponent);
+            const cacheKey = `${component.name}/${component.version}/server.js`;
+            const cached = cache.get('file-contents', cacheKey);
+            const domain = Domain.create();
+            const setEmptyResponse =
+              emptyResponseHandler.contextDecorator(returnComponent);
+            const contextObj = {
+              acceptLanguage: acceptLanguageParser.parse(acceptLanguage!),
+              baseUrl: conf.baseUrl,
+              env: { ...conf.env, ...env },
+              params,
+              plugins: conf.plugins,
+              renderComponent: fromPromise(nestedRenderer.renderComponent),
+              renderComponents: fromPromise(nestedRenderer.renderComponents),
+              requestHeaders: options.headers,
+              requestIp: options.ip,
+              setEmptyResponse,
+              staticPath: repository
+                .getStaticFilePath(component.name, component.version, '')
+                .replace('https:', ''),
+              setHeader: (header?: string, value?: string) => {
+                if (
+                  !(typeof header === 'string' && typeof value === 'string')
+                ) {
+                  throw strings.errors.registry
+                    .COMPONENT_SET_HEADER_PARAMETERS_NOT_VALID;
+                }
 
-            try {
-              domain.run(() => {
-                cached(contextObj, returnComponent);
-                setCallbackTimeout();
-              });
-            } catch (e) {
-              return returnComponent(e, undefined);
-            }
-          } else {
-            fromPromise(repository.getDataProvider)(
-              component.name,
-              component.version,
-              (err, dataProvider) => {
-                if (err) {
-                  componentCallbackDone = true;
-
-                  return callback({
-                    status: 502,
-                    response: {
-                      code: 'DATA_RESOLVING_ERROR',
-                      error: strings.errors.registry.RESOLVING_ERROR
-                    }
-                  });
+                if (header && value) {
+                  responseHeaders = responseHeaders || {};
+                  responseHeaders[header.toLowerCase()] = value;
                 }
+              },
+              templates: repository.getTemplatesInfo()
+            };
 
-                const context = {
-                  require: RequireWrapper(conf.dependencies),
-                  module: {
-                    exports: {} as Record<
-                      string,
-                      (...args: unknown[]) => unknown
-                    >
-                  },
-                  console: conf.local ? console : Object.fromEntries(Object.keys(console).map(key => [key, _.noop])),
-                  setTimeout,
-                  Buffer
-                };
-
-                const handleError = (err: {
-                  code: string;
-                  missing: string[];
-                }) => {
-                  if (err.code === 'DEPENDENCY_MISSING_FROM_REGISTRY') {
+            const setCallbackTimeout = () => {
+              const executionTimeout = conf.executionTimeout;
+              if (executionTimeout) {
+                setTimeout(() => {
+                  const message = `timeout (${executionTimeout * 1000}ms)`;
+                  returnComponent({ message }, undefined);
+                  domain.exit();
+                }, executionTimeout * 1000);
+              }
+            };
+
+            if (!!cached && !conf.hotReloading) {
+              domain.on('error', returnComponent);
+
+              try {
+                domain.run(() => {
+                  cached(contextObj, returnComponent);
+                  setCallbackTimeout();
+                });
+              } catch (e) {
+                return returnComponent(e, undefined);
+              }
+            } else {
+              fromPromise(repository.getDataProvider)(
+                component.name,
+                component.version,
+                (err, dataProvider) => {
+                  if (err) {
                     componentCallbackDone = true;
 
                     return callback({
-                      status: 501,
+                      status: 502,
                       response: {
-                        code: err.code,
-                        error: strings.errors.registry.DEPENDENCY_NOT_FOUND(
-                          err.missing.join(', ')
-                        ),
-                        missingDependencies: err.missing
+                        code: 'DATA_RESOLVING_ERROR',
+                        error: strings.errors.registry.RESOLVING_ERROR
                       }
                     });
                   }
 
-                  returnComponent(err, undefined);
-                };
-
-                const options = conf.local
-                  ? {
-                      displayErrors: true,
-                      filename: dataProvider.filePath
+                  const context = {
+                    require: RequireWrapper(conf.dependencies),
+                    module: {
+                      exports: {} as Record<string, (...args: any[]) => any>
+                    },
+                    console: conf.local ? console : noopConsole,
+                    setTimeout,
+                    Buffer
+                  };
+
+                  const handleError = (err: {
+                    code: string;
+                    missing: string[];
+                  }) => {
+                    if (err.code === 'DEPENDENCY_MISSING_FROM_REGISTRY') {
+                      componentCallbackDone = true;
+
+                      return callback({
+                        status: 501,
+                        response: {
+                          code: err.code,
+                          error: strings.errors.registry.DEPENDENCY_NOT_FOUND(
+                            err.missing.join(', ')
+                          ),
+                          missingDependencies: err.missing
+                        }
+                      });
                     }
-                  : {};
 
-                try {
-                  vm.runInNewContext(dataProvider.content, context, options);
-                  const processData = context.module.exports['data'];
-                  cache.set('file-contents', cacheKey, processData);
+                    returnComponent(err, undefined);
+                  };
 
-                  domain.on('error', handleError);
-                  domain.run(() => {
-                    processData(contextObj, returnComponent);
-                    setCallbackTimeout();
-                  });
-                } catch (err) {
-                  handleError(err as any);
+                  const options = conf.local
+                    ? {
+                        displayErrors: true,
+                        filename: dataProvider.filePath
+                      }
+                    : {};
+
+                  try {
+                    vm.runInNewContext(dataProvider.content, context, options);
+                    const processData = context.module.exports['data'];
+                    cache.set('file-contents', cacheKey, processData);
+
+                    domain.on('error', handleError);
+                    domain.run(() => {
+                      processData(contextObj, returnComponent);
+                      setCallbackTimeout();
+                    });
+                  } catch (err) {
+                    handleError(err as any);
+                  }
                 }
-              }
-            );
-          }
+              );
+            }
+          });
         }
       }
     );