@zohodesk/react-cli 1.1.16-exp.3 → 1.1.16-exp.4

package/packages/client_build_tool/lib/commands/template/commandExecutor.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commandExecutor = commandExecutor;
+
+var _child_process = require("child_process");
+
+var _constants = require("../../shared/constants");
+
+var _logger = require("../../logger");
+
+const supportedTemplates = ['app'];
+
+function commandExecutor(options) {
+  const {
+    extraArgs = []
+  } = options;
+  const [templateName, ...args] = extraArgs;
+
+  if (!supportedTemplates.includes(templateName)) {
+    (0, _logger.messageLogger)(`template not supported "${templateName}" only these \n${supportedTemplates.join('\n ')}`);
+    return;
+  }
+
+  const result = (0, _child_process.spawnSync)( // TODO this will (cp command) not work on Windows needs to recheck 
+  'cp', ['-r', (0, _constants.getTemplatePath)(templateName)].concat(args), {
+    stdio: 'inherit'
+  });
+  process.exit(result.status);
+}

package/packages/client_build_tool/lib/commands/template/config.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  name: 'template',
+  alias: ['template', 'templates'],
+  dirname: __dirname
+};
+exports.default = _default;

package/packages/client_build_tool/lib/commands/version/commandExecutor.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.commandExecutor = commandExecutor;
+
+var _logger = require("../../logger");
+
+var _versionPrint = require("../../shared/utils/versionPrint");
+
+function commandExecutor() {
+  (0, _versionPrint.versionPrint)(_logger.messageLogger);
+}

package/packages/client_build_tool/lib/commands/version/config.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  name: 'version',
+  alias: ['v', '-v', '--v', '-version', '--version'],
+  dirname: __dirname
+};
+exports.default = _default;

package/packages/client_build_tool/lib/commands/version/errorHander.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.errorHander = errorHander;
+
+function errorHander(e) {
+  console.error(e);
+}

package/packages/client_build_tool/lib/commandsRouter.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.route = route;
+exports.runCommand = runCommand;
+
+var _fs = require("fs");
+
+var _path = require("path");
+
+var _allCommandsConfigs = _interopRequireDefault(require("./allCommandsConfigs"));
+
+var _logger = require("./logger");
+
+var _readOptions = require("./schemas/readOptions");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function runCommand(commandConfig, options) {
+  const {
+    dirname
+  } = commandConfig;
+
+  function runRespectiveFile(name, data) {
+    const commandExecutorPath = (0, _path.join)(dirname, `${name}.js`);
+
+    if ((0, _fs.existsSync)(commandExecutorPath)) {
+      // eslint-disable-next-line import/no-dynamic-require, global-require
+      const commandExecutor = require(commandExecutorPath);
+
+      return (commandExecutor[name] || commandExecutor.default)(data);
+    }
+
+    (0, _logger.verboseLogger)('file not found', commandExecutorPath);
+    return null;
+  }
+
+  const processedOption = runRespectiveFile('optionsProcessor', options) || options;
+  runRespectiveFile('deprecationHandler', processedOption); // runRespectiveFile("errorHandler", () => {
+
+  runRespectiveFile('preProcessor', processedOption);
+  runRespectiveFile('commandExecutor', processedOption);
+  runRespectiveFile('postProcessor', processedOption); // });
+}
+
+function route(option, args) {
+  // TODO:  need to modify this log
+  (0, _logger.verboseLogger)(`the command was ${option}`, args); // eslint-disable-next-line no-use-before-define
+
+  const commandConfig = findCommandConfig(option);
+
+  if (commandConfig) {
+    try {
+      const options = (0, _readOptions.getOptions)();
+      runCommand(commandConfig, options);
+    } catch (error) {
+      (0, _logger.errorLogger)(error);
+    }
+  } else {
+    // TODO: need to  write proper error message
+    (0, _logger.warnLogger)('Un known command', option, 'please check the document');
+  }
+}
+
+function findCommandConfig(option) {
+  // eslint-disable-next-line no-restricted-syntax
+  for (const commandConfig of _allCommandsConfigs.default) {
+    if (commandConfig.name === option || commandConfig.alias.includes(option)) {
+      return commandConfig;
+    }
+  }
+
+  return null;
+}

package/packages/client_build_tool/lib/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.run = run;
+
+var _commandsRouter = require("./commandsRouter");
+
+function run(commandName, options) {
+  return (0, _commandsRouter.runCommand)(commandName, options);
+}

package/packages/client_build_tool/lib/logger.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debugLogger = debugLogger;
+exports.errorLogger = errorLogger;
+exports.messageLogger = messageLogger;
+exports.verboseLogger = verboseLogger;
+exports.warnLogger = warnLogger;
+
+/* eslint-disable no-console */
+function verboseLogger(...args) {
+  // TODO: need to be remove when publish happens
+  process.env.VERBOSE === 'true' && console.log('\x1b[33m [verbose] \x1b[0m', ...args);
+}
+
+function warnLogger(...args) {
+  console.warn(...args);
+}
+
+function messageLogger(...args) {
+  console.log(...args);
+}
+
+function debugLogger(...args) {
+  // TODO: need to be remove when publish happens
+  console.trace();
+  console.log(...args);
+}
+
+function errorLogger(...args) {
+  console.error(...args);
+}

package/packages/client_build_tool/lib/schemas/applyValuesToSchema/__test__/otherTestCases.test.js

@@ -0,0 +1,234 @@
+"use strict";
+
+var _index = require("../index");
+
+/* eslint-disable max-lines */
+test('schema value not containing cli key is replaced by processEnv', () => {
+  const schema = {
+    firstData: {
+      hi: 'hi'
+    }
+  };
+  const customOptions = {};
+  const processEnv = {
+    hi: 'hello'
+  };
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({
+    firstData: {
+      hi: 'hi'
+    }
+  });
+}); // NOTE : if schema value type is not an object ,it is not changed by processEnv
+// NOTE : if schema is a object but not containing the cli key then also it cannot be changed by processEnv
+
+test('replacing schema value by processEnv', () => {
+  const schema = {
+    firstData: {
+      cli: 'first',
+      value: 1
+    },
+    secondData: {
+      cli: 'buddy',
+      value: 'hello Buddy'
+    }
+  };
+  const customOptions = {};
+  const processEnv = {
+    first: 'numberOne',
+    buddy: 'hi buddy'
+  };
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({
+    firstData: 'numberOne',
+    secondData: 'hi buddy'
+  });
+});
+test('assigning value to an object by processEnv', () => {
+  const schema = {
+    firstData: {
+      cli: 'first',
+      value: 1
+    },
+    secondData: {
+      cli: 'buddy',
+      hello: 'hello Buddy',
+      hi: 'hi Buddy'
+    }
+  };
+  const customOptions = {};
+  const processEnv = {
+    first: 'numberOne',
+    buddy: 'helloBuddy'
+  };
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({
+    firstData: 'numberOne',
+    secondData: 'helloBuddy'
+  });
+});
+test('if process env value  == undefined , it takes schemas value as output', () => {
+  const schema = {
+    firstData: {
+      cli: 'first',
+      value: 1
+    }
+  };
+  const customOptions = {};
+  const processEnv = {
+    first: undefined
+  };
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({
+    firstData: 1
+  });
+});
+test('process env value  == null , it takes schemas value as output', () => {
+  const schema = {
+    firstData: {
+      cli: 'first',
+      value: 1
+    }
+  };
+  const customOptions = {};
+  const processEnv = {
+    first: null
+  };
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({
+    firstData: 1
+  });
+});
+test('if we change the schema value by customOptions and by processEnv , then process Env value is updated because it has more priority', () => {
+  const schema = {
+    firstData: {
+      cli: 'first',
+      value: 1
+    }
+  };
+  const customOptions = {
+    firstData: 1
+  };
+  const processEnv = {
+    first: 'one'
+  };
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({
+    firstData: 'one'
+  });
+});
+test('object cannot be changed', () => {
+  const schema = {
+    second: {
+      change: 'notdone'
+    },
+    first: {
+      nestedObject1: {
+        nestedObject2: {
+          nestedObject3: {
+            nestedObject4: 'five'
+          }
+        }
+      }
+    }
+  };
+  const customOptions = {
+    second: 'done'
+  };
+  const processEnv = {};
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({
+    second: {
+      change: 'notdone'
+    },
+    first: {
+      nestedObject1: {
+        nestedObject2: {
+          nestedObject3: {
+            nestedObject4: 'five'
+          }
+        }
+      }
+    }
+  });
+});
+test('replacing nested object it is the proper way', () => {
+  const schema = {
+    second: {
+      change: 'notdone'
+    },
+    first: {
+      nestedObject1: {
+        nestedObject2: {
+          nestedObject3: {
+            nestedObject4: 'five'
+          }
+        }
+      }
+    }
+  };
+  const customOptions = {
+    second: {
+      change: 'done'
+    }
+  };
+  const processEnv = {};
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({
+    second: {
+      change: 'done'
+    },
+    first: {
+      nestedObject1: {
+        nestedObject2: {
+          nestedObject3: {
+            nestedObject4: 'five'
+          }
+        }
+      }
+    }
+  });
+});
+test('object cannot be changed (nested Object)', () => {
+  const schema = {
+    second: {
+      change: 'notdone'
+    },
+    first: {
+      nestedObject1: {
+        nestedObject2: {
+          nestedObject3: {
+            nestedObject4: 'five'
+          }
+        }
+      }
+    }
+  };
+  const customOptions = {
+    first: {
+      nestedObject1: {
+        nestedObject2: {
+          nestedObject3: {
+            nestedObject4: 'changed'
+          }
+        }
+      }
+    }
+  };
+  const processEnv = {};
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({
+    second: {
+      change: 'notdone'
+    },
+    first: {
+      nestedObject1: {
+        nestedObject2: {
+          nestedObject3: {
+            nestedObject4: 'changed'
+          }
+        }
+      }
+    }
+  });
+});

package/packages/client_build_tool/lib/schemas/applyValuesToSchema/__test__/passingDifferentDataTypesToSchema.test.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _index = require("../index");
+
+describe('passing different datatypes to schema', () => {
+  const customOptions = {};
+  const processEnv = {};
+  it('Passing string to schema', () => {
+    const schema = '';
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({});
+  });
+  it('Passing number to schema', () => {
+    const schema = 28;
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({});
+  });
+  it('Passing Number array to schema', () => {
+    const schema = [1, 3, 4];
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      0: 1,
+      1: 3,
+      2: 4
+    });
+  });
+  it('Passing String array to schema', () => {
+    const schema = ['Testing', 'the', 'code'];
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      0: 'Testing',
+      1: 'the',
+      2: 'code'
+    });
+  });
+  it('Passing 2D array to schema', () => {
+    const schema = ['Testing', 'the', 'code', [1, 2], ['hi', 'buddy'], {
+      firstData: 'one'
+    }];
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      0: 'Testing',
+      1: 'the',
+      2: 'code',
+      3: [1, 2],
+      4: ['hi', 'buddy'],
+      5: {
+        firstData: 'one'
+      }
+    });
+  });
+  it('Passing object to schema', () => {
+    const schema = {
+      firstData: 1,
+      secondData: 2
+    };
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      firstData: 1,
+      secondData: 2
+    });
+  });
+  it('Passing Nested object to schema', () => {
+    const schema = {
+      firstData: 1,
+      secondData: 2,
+      nestedObject: {
+        nestedObject1: 'hello',
+        nestedObject2: 'hi'
+      },
+      secondObject: {
+        thirdData: 3,
+        fourthData: 'fourthData'
+      }
+    };
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      firstData: 1,
+      secondData: 2,
+      nestedObject: {
+        nestedObject1: 'hello',
+        nestedObject2: 'hi'
+      },
+      secondObject: {
+        thirdData: 3,
+        fourthData: 'fourthData'
+      }
+    });
+  });
+  it('Passing null value to schema', () => {
+    const schema = null;
+    expect(() => (0, _index.applyValuesToSchema)(schema, customOptions, processEnv)).toThrow(Error);
+  });
+  it('Passing undefined value to schema', () => {
+    const schema = undefined;
+    expect(() => (0, _index.applyValuesToSchema)(schema, customOptions, processEnv)).toThrow(Error);
+  });
+  it('Passing NaN value to schema', () => {
+    const schema = NaN;
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({});
+  });
+});

package/packages/client_build_tool/lib/schemas/applyValuesToSchema/__test__/passingEmptyObjects.test.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _index = require("../index");
+
+test('Passing empty object to all arguments', () => {
+  const schema = {};
+  const customOptions = {};
+  const processEnv = {};
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({});
+}); // if sc9hema is a empty object all the output also empty object
+
+test('Passing empty object to scheme', () => {
+  const schema = {};
+  const customOptions = {
+    firstData: 'hi'
+  };
+  const processEnv = {
+    hello: 'hi'
+  };
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({});
+});
+test('Passing empty object to scheme and processEnv', () => {
+  const schema = {};
+  const customOptions = {
+    firstData: 'hi'
+  };
+  const processEnv = {};
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({});
+});
+test('Passing empty object to scheme and  customOptions', () => {
+  const schema = {};
+  const customOptions = {};
+  const processEnv = {
+    hello: 'hi'
+  };
+  const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+  expect(output).toStrictEqual({});
+});

package/packages/client_build_tool/lib/schemas/applyValuesToSchema/__test__/replacingSchemaValueByCustomOptions/convertArray.test.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _index = require("../../index");
+
+describe('replacing schema value by customOptions from array to other data types', () => {
+  const schema = {
+    firstData: [1, 2, 3, 'hi']
+  };
+  const processEnv = {};
+  it('to number', () => {
+    const customOptions = {
+      firstData: 28
+    };
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      firstData: 28
+    });
+  });
+  it('to string', () => {
+    const customOptions = {
+      firstData: 'hi'
+    };
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      firstData: 'hi'
+    });
+  });
+  it('to object', () => {
+    const customOptions = {
+      firstData: {
+        Good: 'Morning'
+      }
+    };
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      firstData: {
+        Good: 'Morning'
+      }
+    });
+  });
+  it('to  null', () => {
+    const customOptions = {
+      firstData: null
+    };
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      firstData: [1, 2, 3, 'hi']
+    });
+  });
+  it('to  undefined', () => {
+    const customOptions = {
+      firstData: undefined
+    };
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      firstData: [1, 2, 3, 'hi']
+    });
+  });
+  it('to NaN', () => {
+    const customOptions = {
+      firstData: NaN
+    };
+    const output = (0, _index.applyValuesToSchema)(schema, customOptions, processEnv);
+    expect(output).toStrictEqual({
+      firstData: [1, 2, 3, 'hi']
+    });
+  });
+});