New: Add option to place values of env vars or static values to the package.json

Author: doteric

README.md

@@ -65,6 +65,21 @@ For example you can use ESM with the following setup:
 }
 ```
 
+Example of using custom package.json values:
+
+```json
+{
+  "settings": {
+    "customPackageFields": {
+      "repository": {
+        "type": "git",
+        "url": "${YOUR_ENV_VARIABLE}"
+      }
+    }
+  }
+}
+```
+
 ## Recommendations
 
 When used together with TypeScript, [esbuild will not perform type checking](https://esbuild.github.io/content-types/#typescript), so it's recommended to run `tsc --noEmit` before using `funpack`.

package.json

@@ -15,10 +15,10 @@
   "scripts": {
     "precompile": "rimraf ./dist",
     "compile": "tsc",
-    "test": "yarn jest --coverage && yarn lint && yarn prettier",
-    "fix": "yarn lint --fix && yarn prettier-fix",
+    "test": "npm run jest --coverage && npm run lint && npm run prettier",
+    "fix": "npm run lint --fix && npm run prettier-fix",
     "jest": "jest",
-    "lint": "eslint .",
+    "lint": "eslint ./src",
     "prettier": "prettier --check ./src",
     "prettier-fix": "prettier --write ./src"
   },

src/index.test.ts

@@ -2,6 +2,8 @@ import { join } from 'path';
 
 import funpack from './index';
 
+process.env.GIT_REPO_URL = 'https://example.com/test/repo.git';
+
 jest.mock('./utils/getPackageJsonObject', () =>
   jest.fn().mockReturnValue({
     name: 'my-lambdas',
@@ -14,6 +16,12 @@ jest.mock('./utils/getPackageJsonObject', () =>
         cleanupOutputDir: true,
         zip: true,
         removeDirAfterZip: true,
+        customPackageFields: {
+          repository: {
+            type: 'git',
+            url: '${GIT_REPO_URL}',
+          },
+        },
       },
       functions: {
         testfunc: './example/test.ts',
@@ -31,13 +39,13 @@ describe('funpack', () => {
     expect(console.log).toBeCalledWith(
       join('example', 'dist', 'testfunc.zip'),
       '-',
-      20728,
+      20771,
       'total bytes'
     );
     expect(console.log).toBeCalledWith(
       join('example', 'dist', 'second.zip'),
       '-',
-      20725,
+      20768,
       'total bytes'
     );
   });

src/parts/parseConfig.ts

@@ -19,6 +19,8 @@ const configSchema = z.object(
       zip: z.boolean().default(false),
       // Remove directories of functions, leaving only the zip files
       removeDirAfterZip: z.boolean().default(false),
+      // Custom values to append to the packge.json
+      customPackageFields: z.record(z.string(), z.any()).default({}),
     }),
   },
   { required_error: 'Missing funpack config inside package.json!' }

src/utils/envVarReplace.test.ts

@@ -0,0 +1,20 @@
+import envVarReplace from './envVarReplace';
+
+describe('envVarStringReplace', () => {
+  process.env.TEST_EXAMPLE = 'test';
+  process.env.SECOND_EXAMPLE = 'example1';
+  it('returns correctly for a string with just a variable', () => {
+    const value = envVarReplace('${TEST_EXAMPLE}');
+    expect(value).toBe('test');
+  });
+
+  it('returns correctly for a string with a variable and custom text', () => {
+    const value = envVarReplace('${TEST_EXAMPLE}-example');
+    expect(value).toBe('test-example');
+  });
+
+  it('returns correctly for a string with two variables', () => {
+    const value = envVarReplace('${TEST_EXAMPLE}-${SECOND_EXAMPLE}');
+    expect(value).toBe('test-example1');
+  });
+});

src/utils/envVarReplace.ts

@@ -0,0 +1,17 @@
+const envVarReplace = (value: string) => {
+  let newValue = value;
+  for (let i = 0; i < value.length; i++) {
+    if (value.substring(i, i + 2) === '${') {
+      const stopIndex = value.indexOf('}', i);
+      if (stopIndex !== -1) {
+        const envVarName = value.substring(i + 2, stopIndex);
+        const envVarValue = process.env[envVarName];
+        const regex = new RegExp(`\\\${${envVarName}}`, 'g');
+        newValue = newValue.replace(regex, envVarValue || '');
+      }
+    }
+  }
+  return newValue;
+};
+
+export default envVarReplace;

src/utils/prepareFunctionPackageJson.ts

@@ -2,6 +2,8 @@ import { readFileSync } from 'fs';
 import { join } from 'path';
 
 import type { PackageObjectType } from '../types';
+import traverseAndAction from './traverseAndAction';
+import envVarReplace from './envVarReplace';
 
 interface ParamsType {
   packages: string[];
@@ -14,6 +16,7 @@ const prepareFunctionPackageJson = ({
   packageObject,
   mainPath,
 }: ParamsType): Record<string, unknown> => {
+  // Get used dependencies and their versions
   const dependencies: Record<string, string> = {};
   for (const packageName of packages) {
     const packageJsonPath = join('node_modules', packageName, 'package.json');
@@ -24,14 +27,24 @@ const prepareFunctionPackageJson = ({
     dependencies[packageName] = version;
   }
 
+  // Copy fields from root package.json
   const fieldsToCopy = packageObject.funpack.settings.packageFieldsToCopy;
   const copiedFromMainPackage: Record<string, unknown> = {};
   for (const fieldName of fieldsToCopy) {
     copiedFromMainPackage[fieldName] = packageObject[fieldName];
   }
 
+  // Set specific vars or static strings to specified package.json fields
+  const customPackageFields =
+    packageObject.funpack.settings.customPackageFields;
+  const customObject = traverseAndAction(
+    customPackageFields,
+    envVarReplace
+  ) as typeof customPackageFields;
+
   return {
     ...copiedFromMainPackage,
+    ...customObject,
     main: mainPath,
     dependencies,
   };

src/utils/traverseAndAction.test.ts

@@ -0,0 +1,61 @@
+import traverseAndAction from './traverseAndAction';
+import envVarReplace from './envVarReplace';
+
+describe('traverseAndAction', () => {
+  it('returns correctly updated object', () => {
+    const action = (value: string) => value.replace('a', 'e');
+    const newObject = traverseAndAction(
+      {
+        test: {
+          example: 'aaaa',
+        },
+        test2: 'bba',
+      },
+      action
+    );
+    expect(newObject).toEqual({
+      test: {
+        example: 'eaaa',
+      },
+      test2: 'bbe',
+    });
+  });
+
+  it('returns correcly when using env var replace', () => {
+    process.env.EXAMPLE = 'test1';
+    const newObject = traverseAndAction(
+      {
+        test: {
+          example: '${EXAMPLE}',
+        },
+        test2: 'test:${EXAMPLE}',
+      },
+      envVarReplace
+    );
+    expect(newObject).toEqual({
+      test: {
+        example: 'test1',
+      },
+      test2: 'test:test1',
+    });
+  });
+
+  it('returns correcly when using arrays and numbers', () => {
+    process.env.EXAMPLE = 'test1';
+    const newObject = traverseAndAction(
+      {
+        number: 1,
+        array: ['test', '${EXAMPLE}'],
+        arrayWithObjects: [{ test1: 'example', test2: '${EXAMPLE}' }],
+        arrayWithArray: [[{ test: 'test' }, '${EXAMPLE}'], 'test'],
+      },
+      envVarReplace
+    );
+    expect(newObject).toEqual({
+      number: 1,
+      array: ['test', 'test1'],
+      arrayWithObjects: [{ test1: 'example', test2: 'test1' }],
+      arrayWithArray: [[{ test: 'test' }, 'test1'], 'test'],
+    });
+  });
+});

src/utils/traverseAndAction.ts

@@ -0,0 +1,37 @@
+type ValueType = string | object | number | any[] | null;
+type ObjectType = Record<string, ValueType>;
+
+const isObject = (value: unknown): boolean => {
+  if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+    return true;
+  }
+  return false;
+};
+
+const traverseAndAction = (
+  input: ValueType,
+  actionOnString: (value: string) => string
+): ValueType => {
+  if (typeof input === 'string') {
+    return actionOnString(input);
+  } else if (typeof input === 'number') {
+    return input;
+  } else if (Array.isArray(input)) {
+    return input.map((arrayValue) =>
+      traverseAndAction(arrayValue, actionOnString)
+    );
+  } else if (isObject(input)) {
+    const newObject: ObjectType = {};
+    for (const key in input) {
+      if (Object.prototype.hasOwnProperty.call(input, key)) {
+        const element = (input as ObjectType)[key];
+        newObject[key] = traverseAndAction(element, actionOnString);
+      }
+    }
+    return newObject;
+  }
+
+  return null;
+};
+
+export default traverseAndAction;