datagrok-tools 6.1.9 → 6.1.11

package/bin/__tests__/server.test.js

@@ -0,0 +1,277 @@
+"use strict";
+
+var _vitest = require("vitest");
+var os = _interopRequireWildcard(require("os"));
+var fs = _interopRequireWildcard(require("fs"));
+var path = _interopRequireWildcard(require("path"));
+var _server = require("../commands/server");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+(0, _vitest.describe)('parseFuncCall', () => {
+  (0, _vitest.it)('parses a single string argument', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Chem:smilesToMw("ccc")')).toEqual({
+      name: 'Chem:smilesToMw',
+      params: {
+        '0': 'ccc'
+      }
+    });
+  });
+  (0, _vitest.it)('parses a single-quoted string argument', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)("Pkg:fn('hello')")).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        '0': 'hello'
+      }
+    });
+  });
+  (0, _vitest.it)('parses a numeric argument', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn(42)')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        '0': 42
+      }
+    });
+  });
+  (0, _vitest.it)('parses multiple positional arguments', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn(1, "hello", 3.14)')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        '0': 1,
+        '1': 'hello',
+        '2': 3.14
+      }
+    });
+  });
+  (0, _vitest.it)('parses an object argument with quoted keys', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn({"a":5,"b":22})')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        a: 5,
+        b: 22
+      }
+    });
+  });
+  (0, _vitest.it)('parses an object argument with unquoted keys', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn({a:5,b:22})')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        a: 5,
+        b: 22
+      }
+    });
+  });
+  (0, _vitest.it)('parses an object argument with a boolean value', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn({unquoted:true})')).toEqual({
+      name: 'Pkg:fn',
+      params: {
+        unquoted: true
+      }
+    });
+  });
+  (0, _vitest.it)('returns empty params for a no-argument call', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn()')).toEqual({
+      name: 'Pkg:fn',
+      params: {}
+    });
+  });
+  (0, _vitest.it)('returns empty params when there are no parentheses', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('Pkg:fn')).toEqual({
+      name: 'Pkg:fn',
+      params: {}
+    });
+  });
+  (0, _vitest.it)('handles a package-less function name', () => {
+    (0, _vitest.expect)((0, _server.parseFuncCall)('myFunc("arg")')).toEqual({
+      name: 'myFunc',
+      params: {
+        '0': 'arg'
+      }
+    });
+  });
+});
+(0, _vitest.describe)('buildInlineManifest', () => {
+  (0, _vitest.it)('sets action to entity.verb', () => {
+    const result = (0, _server.buildInlineManifest)('users', 'delete', ['abc']);
+    (0, _vitest.expect)(result.operations[0].action).toBe('users.delete');
+  });
+  (0, _vitest.it)('maps string args to {id} param for non-file entities', () => {
+    const result = (0, _server.buildInlineManifest)('users', 'delete', ['id1', 'id2']);
+    (0, _vitest.expect)(result.operations).toEqual([{
+      id: 'op0',
+      action: 'users.delete',
+      params: {
+        id: 'id1'
+      }
+    }, {
+      id: 'op1',
+      action: 'users.delete',
+      params: {
+        id: 'id2'
+      }
+    }]);
+  });
+  (0, _vitest.it)('maps string args to {path} param for the files entity', () => {
+    const result = (0, _server.buildInlineManifest)('files', 'delete', ['System:AppData/a.txt', 'System:AppData/b.txt']);
+    (0, _vitest.expect)(result.operations).toEqual([{
+      id: 'op0',
+      action: 'files.delete',
+      params: {
+        path: 'System:AppData/a.txt'
+      }
+    }, {
+      id: 'op1',
+      action: 'files.delete',
+      params: {
+        path: 'System:AppData/b.txt'
+      }
+    }]);
+  });
+  (0, _vitest.it)('passes object array args through as params directly', () => {
+    const objs = [{
+      name: 'Alice',
+      email: 'a@x.com'
+    }, {
+      name: 'Bob',
+      email: 'b@x.com'
+    }];
+    const result = (0, _server.buildInlineManifest)('users', 'create', objs);
+    (0, _vitest.expect)(result.operations).toEqual([{
+      id: 'op0',
+      action: 'users.create',
+      params: {
+        name: 'Alice',
+        email: 'a@x.com'
+      }
+    }, {
+      id: 'op1',
+      action: 'users.create',
+      params: {
+        name: 'Bob',
+        email: 'b@x.com'
+      }
+    }]);
+  });
+  (0, _vitest.it)('assigns sequential op ids starting at op0', () => {
+    const result = (0, _server.buildInlineManifest)('groups', 'delete', ['x', 'y', 'z']);
+    (0, _vitest.expect)(result.operations.map(o => o.id)).toEqual(['op0', 'op1', 'op2']);
+  });
+  (0, _vitest.it)('returns a single operation for a single arg', () => {
+    const result = (0, _server.buildInlineManifest)('connections', 'delete', ['conn-id']);
+    (0, _vitest.expect)(result.operations).toHaveLength(1);
+  });
+});
+(0, _vitest.describe)('resolveManifestSources', () => {
+  let tmpFile;
+  (0, _vitest.beforeEach)(() => {
+    tmpFile = path.join(os.tmpdir(), `grok-batch-test-${Date.now()}.bin`);
+  });
+  (0, _vitest.afterEach)(() => {
+    if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile);
+  });
+  (0, _vitest.it)('passes through a manifest with no files.put operations unchanged', () => {
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'users.delete',
+        params: {
+          id: 'abc'
+        }
+      }]
+    };
+    (0, _vitest.expect)((0, _server.resolveManifestSources)(manifest)).toEqual(manifest);
+  });
+  (0, _vitest.it)('passes through a files.put operation that has no source field', () => {
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.txt',
+          content: 'aGk='
+        }
+      }]
+    };
+    (0, _vitest.expect)((0, _server.resolveManifestSources)(manifest)).toEqual(manifest);
+  });
+  (0, _vitest.it)('reads the source file, base64-encodes its contents, and removes the source key', () => {
+    const data = 'hello world';
+    fs.writeFileSync(tmpFile, data);
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.txt',
+          source: tmpFile
+        }
+      }]
+    };
+    const result = (0, _server.resolveManifestSources)(manifest);
+    const params = result.operations[0].params;
+    (0, _vitest.expect)(params.content).toBe(Buffer.from(data).toString('base64'));
+    (0, _vitest.expect)(params.source).toBeUndefined();
+  });
+  (0, _vitest.it)('preserves other params alongside the injected content', () => {
+    fs.writeFileSync(tmpFile, 'data');
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.txt',
+          source: tmpFile,
+          extra: 'val'
+        }
+      }]
+    };
+    const result = (0, _server.resolveManifestSources)(manifest);
+    const params = result.operations[0].params;
+    (0, _vitest.expect)(params.path).toBe('System:AppData/f.txt');
+    (0, _vitest.expect)(params.extra).toBe('val');
+  });
+  (0, _vitest.it)('leaves non-files.put operations untouched in a mixed manifest', () => {
+    fs.writeFileSync(tmpFile, 'x');
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'users.delete',
+        params: {
+          id: 'u1'
+        }
+      }, {
+        id: 'op1',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.txt',
+          source: tmpFile
+        }
+      }]
+    };
+    const result = (0, _server.resolveManifestSources)(manifest);
+    (0, _vitest.expect)(result.operations[0]).toEqual({
+      id: 'op0',
+      action: 'users.delete',
+      params: {
+        id: 'u1'
+      }
+    });
+    (0, _vitest.expect)(result.operations[1].params.source).toBeUndefined();
+    (0, _vitest.expect)(result.operations[1].params.content).toBeDefined();
+  });
+  (0, _vitest.it)('correctly encodes binary file contents', () => {
+    const bytes = Buffer.from([0x00, 0xff, 0x10, 0xab]);
+    fs.writeFileSync(tmpFile, bytes);
+    const manifest = {
+      operations: [{
+        id: 'op0',
+        action: 'files.put',
+        params: {
+          path: 'System:AppData/f.bin',
+          source: tmpFile
+        }
+      }]
+    };
+    const result = (0, _server.resolveManifestSources)(manifest);
+    const decoded = Buffer.from(result.operations[0].params.content, 'base64');
+    (0, _vitest.expect)(decoded).toEqual(bytes);
+  });
+});

package/bin/__tests__/server.test.ts

@@ -0,0 +1,197 @@
+import {describe, it, expect, beforeEach, afterEach} from 'vitest';
+import * as os from 'os';
+import * as fs from 'fs';
+import * as path from 'path';
+import {parseFuncCall, buildInlineManifest, resolveManifestSources} from '../commands/server';
+
+describe('parseFuncCall', () => {
+  it('parses a single string argument', () => {
+    expect(parseFuncCall('Chem:smilesToMw("ccc")')).toEqual({
+      name: 'Chem:smilesToMw',
+      params: {'0': 'ccc'},
+    });
+  });
+
+  it('parses a single-quoted string argument', () => {
+    expect(parseFuncCall("Pkg:fn('hello')")).toEqual({
+      name: 'Pkg:fn',
+      params: {'0': 'hello'},
+    });
+  });
+
+  it('parses a numeric argument', () => {
+    expect(parseFuncCall('Pkg:fn(42)')).toEqual({
+      name: 'Pkg:fn',
+      params: {'0': 42},
+    });
+  });
+
+  it('parses multiple positional arguments', () => {
+    expect(parseFuncCall('Pkg:fn(1, "hello", 3.14)')).toEqual({
+      name: 'Pkg:fn',
+      params: {'0': 1, '1': 'hello', '2': 3.14},
+    });
+  });
+
+  it('parses an object argument with quoted keys', () => {
+    expect(parseFuncCall('Pkg:fn({"a":5,"b":22})')).toEqual({
+      name: 'Pkg:fn',
+      params: {a: 5, b: 22},
+    });
+  });
+
+  it('parses an object argument with unquoted keys', () => {
+    expect(parseFuncCall('Pkg:fn({a:5,b:22})')).toEqual({
+      name: 'Pkg:fn',
+      params: {a: 5, b: 22},
+    });
+  });
+
+  it('parses an object argument with a boolean value', () => {
+    expect(parseFuncCall('Pkg:fn({unquoted:true})')).toEqual({
+      name: 'Pkg:fn',
+      params: {unquoted: true},
+    });
+  });
+
+  it('returns empty params for a no-argument call', () => {
+    expect(parseFuncCall('Pkg:fn()')).toEqual({
+      name: 'Pkg:fn',
+      params: {},
+    });
+  });
+
+  it('returns empty params when there are no parentheses', () => {
+    expect(parseFuncCall('Pkg:fn')).toEqual({
+      name: 'Pkg:fn',
+      params: {},
+    });
+  });
+
+  it('handles a package-less function name', () => {
+    expect(parseFuncCall('myFunc("arg")')).toEqual({
+      name: 'myFunc',
+      params: {'0': 'arg'},
+    });
+  });
+});
+
+describe('buildInlineManifest', () => {
+  it('sets action to entity.verb', () => {
+    const result = buildInlineManifest('users', 'delete', ['abc']);
+    expect(result.operations[0].action).toBe('users.delete');
+  });
+
+  it('maps string args to {id} param for non-file entities', () => {
+    const result = buildInlineManifest('users', 'delete', ['id1', 'id2']);
+    expect(result.operations).toEqual([
+      {id: 'op0', action: 'users.delete', params: {id: 'id1'}},
+      {id: 'op1', action: 'users.delete', params: {id: 'id2'}},
+    ]);
+  });
+
+  it('maps string args to {path} param for the files entity', () => {
+    const result = buildInlineManifest('files', 'delete', ['System:AppData/a.txt', 'System:AppData/b.txt']);
+    expect(result.operations).toEqual([
+      {id: 'op0', action: 'files.delete', params: {path: 'System:AppData/a.txt'}},
+      {id: 'op1', action: 'files.delete', params: {path: 'System:AppData/b.txt'}},
+    ]);
+  });
+
+  it('passes object array args through as params directly', () => {
+    const objs = [{name: 'Alice', email: 'a@x.com'}, {name: 'Bob', email: 'b@x.com'}];
+    const result = buildInlineManifest('users', 'create', objs);
+    expect(result.operations).toEqual([
+      {id: 'op0', action: 'users.create', params: {name: 'Alice', email: 'a@x.com'}},
+      {id: 'op1', action: 'users.create', params: {name: 'Bob', email: 'b@x.com'}},
+    ]);
+  });
+
+  it('assigns sequential op ids starting at op0', () => {
+    const result = buildInlineManifest('groups', 'delete', ['x', 'y', 'z']);
+    expect(result.operations.map((o) => o.id)).toEqual(['op0', 'op1', 'op2']);
+  });
+
+  it('returns a single operation for a single arg', () => {
+    const result = buildInlineManifest('connections', 'delete', ['conn-id']);
+    expect(result.operations).toHaveLength(1);
+  });
+});
+
+describe('resolveManifestSources', () => {
+  let tmpFile: string;
+
+  beforeEach(() => {
+    tmpFile = path.join(os.tmpdir(), `grok-batch-test-${Date.now()}.bin`);
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile);
+  });
+
+  it('passes through a manifest with no files.put operations unchanged', () => {
+    const manifest = {
+      operations: [{id: 'op0', action: 'users.delete', params: {id: 'abc'}}],
+    };
+    expect(resolveManifestSources(manifest)).toEqual(manifest);
+  });
+
+  it('passes through a files.put operation that has no source field', () => {
+    const manifest = {
+      operations: [{id: 'op0', action: 'files.put', params: {path: 'System:AppData/f.txt', content: 'aGk='}}],
+    };
+    expect(resolveManifestSources(manifest)).toEqual(manifest);
+  });
+
+  it('reads the source file, base64-encodes its contents, and removes the source key', () => {
+    const data = 'hello world';
+    fs.writeFileSync(tmpFile, data);
+
+    const manifest = {
+      operations: [{id: 'op0', action: 'files.put', params: {path: 'System:AppData/f.txt', source: tmpFile}}],
+    };
+    const result = resolveManifestSources(manifest);
+    const params = result.operations[0].params as any;
+    expect(params.content).toBe(Buffer.from(data).toString('base64'));
+    expect(params.source).toBeUndefined();
+  });
+
+  it('preserves other params alongside the injected content', () => {
+    fs.writeFileSync(tmpFile, 'data');
+
+    const manifest = {
+      operations: [{id: 'op0', action: 'files.put', params: {path: 'System:AppData/f.txt', source: tmpFile, extra: 'val'}}],
+    };
+    const result = resolveManifestSources(manifest);
+    const params = result.operations[0].params as any;
+    expect(params.path).toBe('System:AppData/f.txt');
+    expect(params.extra).toBe('val');
+  });
+
+  it('leaves non-files.put operations untouched in a mixed manifest', () => {
+    fs.writeFileSync(tmpFile, 'x');
+
+    const manifest = {
+      operations: [
+        {id: 'op0', action: 'users.delete', params: {id: 'u1'}},
+        {id: 'op1', action: 'files.put', params: {path: 'System:AppData/f.txt', source: tmpFile}},
+      ],
+    };
+    const result = resolveManifestSources(manifest);
+    expect(result.operations[0]).toEqual({id: 'op0', action: 'users.delete', params: {id: 'u1'}});
+    expect((result.operations[1].params as any).source).toBeUndefined();
+    expect((result.operations[1].params as any).content).toBeDefined();
+  });
+
+  it('correctly encodes binary file contents', () => {
+    const bytes = Buffer.from([0x00, 0xff, 0x10, 0xab]);
+    fs.writeFileSync(tmpFile, bytes);
+
+    const manifest = {
+      operations: [{id: 'op0', action: 'files.put', params: {path: 'System:AppData/f.bin', source: tmpFile}}],
+    };
+    const result = resolveManifestSources(manifest);
+    const decoded = Buffer.from((result.operations[0].params as any).content, 'base64');
+    expect(decoded).toEqual(bytes);
+  });
+});

package/bin/commands/api.js

@@ -46,7 +46,11 @@ function generateQueryWrappers() {
       const description = utils.getScriptDescription(q, utils.commentMap[utils.queryExtension]);
       const inputs = utils.getScriptInputs(q, utils.commentMap[utils.queryExtension]);
       const outputType = utils.getScriptOutputType(q, utils.commentMap[utils.queryExtension]);
-      tb.replace('PARAMS_OBJECT', inputs).replace('TYPED_PARAMS', inputs).replace('FUNC_DESCRIPTION', description).replace('OUTPUT_TYPE', outputType === 'void' ? utils.dgToTsTypeMap['dataframe'] : outputType);
+      const resolvedOutputType = outputType === 'void' ? utils.dgToTsTypeMap['dataframe'] : outputType;
+      tb.replace('PARAMS_OBJECT', inputs).replace('TYPED_PARAMS', inputs).replace('FUNC_JSDOC', {
+        description,
+        inputs
+      }).replace('OUTPUT_TYPE', resolvedOutputType);
       wrappers.push(tb.build(1));
     }
   }
@@ -76,7 +80,10 @@ function generateScriptWrappers() {
       const tb = new utils.TemplateBuilder(utils.scriptWrapperTemplate).replace('FUNC_NAME', name).replace('FUNC_NAME_LOWERCASE', name).replace('PACKAGE_NAMESPACE', _package?.friendlyName ?? '');
       const inputs = utils.getScriptInputs(script);
       const outputType = utils.getScriptOutputType(script);
-      tb.replace('PARAMS_OBJECT', inputs).replace('TYPED_PARAMS', inputs).replace('FUNC_DESCRIPTION', description).replace('OUTPUT_TYPE', outputType);
+      tb.replace('PARAMS_OBJECT', inputs).replace('TYPED_PARAMS', inputs).replace('FUNC_JSDOC', {
+        description,
+        inputs
+      }).replace('OUTPUT_TYPE', outputType);
       wrappers.push(tb.build(1));
     }
   }
@@ -100,7 +107,10 @@ function generateFunctionWrappers() {
       let outputType = '';
       outputType = annotationOutputDir ?? 'any';
       checkNameColision(name);
-      const tb = new utils.TemplateBuilder(utils.scriptWrapperTemplate).replace('FUNC_NAME', name).replace('FUNC_NAME_LOWERCASE', name).replace('PACKAGE_NAMESPACE', _package?.friendlyName ?? '').replace('PARAMS_OBJECT', annotationInputs).replace('FUNC_DESCRIPTION', description).replace('TYPED_PARAMS', annotationInputs).replace('OUTPUT_TYPE', outputType);
+      const tb = new utils.TemplateBuilder(utils.scriptWrapperTemplate).replace('FUNC_NAME', name).replace('FUNC_NAME_LOWERCASE', name).replace('PACKAGE_NAMESPACE', _package?.friendlyName ?? '').replace('PARAMS_OBJECT', annotationInputs).replace('FUNC_JSDOC', {
+        description,
+        inputs: annotationInputs
+      }).replace('TYPED_PARAMS', annotationInputs).replace('OUTPUT_TYPE', outputType);
       wrappers.push(tb.build(1));
     }
   }

package/bin/commands/build.js

@@ -54,7 +54,7 @@ async function buildRecursive(baseDir, args, buildCmd) {
     return false;
   }
   console.log(`Found ${filtered.length} package(s): ${filtered.map(p => p.friendlyName).join(', ')}`);
-  if (!args.silent) {
+  if (!args.silent && !args.s) {
     const confirmed = await confirm(`\nBuild ${filtered.length} package(s)?`);
     if (!confirmed) {
       console.log('Aborted.');

package/bin/commands/create.js

@@ -26,7 +26,7 @@ const confTemplate = _jsYaml.default.load(_fs.default.readFileSync(confTemplateD
   encoding: 'utf-8'
 }));
 const dependencies = [];
-function createDirectoryContents(name, config, templateDir, packageDir, ide = '', ts = true, eslint = false, test = false) {
+function createDirectoryContents(name, friendlyName, config, templateDir, packageDir, ide = '', ts = true, eslint = false, test = false) {
   const filesToCreate = _fs.default.readdirSync(templateDir);
   filesToCreate.forEach(file => {
     const origFilePath = _path.default.join(templateDir, file);
@@ -38,6 +38,7 @@ function createDirectoryContents(name, config, templateDir, packageDir, ide = ''
         return false;
       }
       let contents = _fs.default.readFileSync(file === 'webpack.config.js' && ts ? _path.default.join(templateDir, 'ts.webpack.config.js') : origFilePath, 'utf8');
+      contents = contents.replace(/#{PACKAGE_FRIENDLY_NAME}/g, friendlyName);
       contents = contents.replace(/#{PACKAGE_NAME}/g, name);
       contents = contents.replace(/#{PACKAGE_DETECTORS_NAME}/g, utils.kebabToCamelCase(name));
       contents = contents.replace(/#{PACKAGE_NAME_LOWERCASE}/g, name.toLowerCase());
@@ -114,7 +115,7 @@ function createDirectoryContents(name, config, templateDir, packageDir, ide = ''
       _fs.default.mkdirSync(copyFilePath);
       // recursive call
       if (_path.default.basename(origFilePath) === 'node_modules') return;
-      createDirectoryContents(name, config, origFilePath, copyFilePath, ide, ts, eslint, test);
+      createDirectoryContents(name, friendlyName, config, origFilePath, copyFilePath, ide, ts, eslint, test);
     }
   });
 }
@@ -138,8 +139,10 @@ function create(args) {
     color.error(confTest.message);
     return false;
   }
-  const name = nArgs === 2 ? args['_'][1] : curFolder;
-  const validName = /^([A-Za-z\-_\d])+$/.test(name);
+  const rawName = nArgs === 2 ? args['_'][1] : curFolder;
+  const validName = /^([A-Za-z\-_\d])+$/.test(rawName);
+  const friendlyName = rawName;
+  const name = rawName.charAt(0).toUpperCase() + rawName.slice(1).toLowerCase();
   if (validName) {
     let packageDir = curDir;
     let repositoryInfo = null;
@@ -183,7 +186,7 @@ function create(args) {
       }
       process.exit();
     });
-    createDirectoryContents(name, config, templateDir, packageDir, args.ide, ts, !!args.eslint, !!args.test);
+    createDirectoryContents(name, friendlyName, config, templateDir, packageDir, args.ide, ts, !!args.eslint, !!args.test);
     color.success('Successfully created package ' + name);
     console.log(_entHelpers.help.package(ts));
     console.log(`\nThe package has the following dependencies:\n${dependencies.join(' ')}\n`);