inject-srcpush-config.js

#!/usr/bin/env node
'use strict';

const fs = require('fs');
const path = require('path');

const usage = () => {
  console.error(`Usage:
  node scripts/inject-srcpush-config.js \\
    --android-strings <path> \\
    --ios-plist <path> \\
    --deployment-key-android <value> \\
    --deployment-key-ios <value> \\
    [--server-url <value>] \\
    [--public-key <value> | --public-key-file <path>]`);
};

const parseArgs = (argv) => {
  const args = {};
  for (let index = 0; index < argv.length; index += 1) {
    const token = argv[index];
    if (!token.startsWith('--')) {
      throw new Error(`Unexpected argument: ${token}`);
    }
    const key = token.slice(2);
    const value = argv[index + 1];
    if (!value || value.startsWith('--')) {
      throw new Error(`Missing value for --${key}`);
    }
    args[key] = value;
    index += 1;
  }
  return args;
};

const required = (args, keys) => {
  for (const key of keys) {
    if (!args[key]) {
      throw new Error(`Missing required argument --${key}`);
    }
  }
};

const readFile = (filePath) => fs.readFileSync(filePath, 'utf8');
const writeFile = (filePath, content) => fs.writeFileSync(filePath, content, 'utf8');

const xmlEscape = (value) =>
  value
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;');

const upsertAndroidString = (content, name, value) => {
  const escapedValue = xmlEscape(value);
  const pattern = new RegExp(
    `(<string\\s+name="${name}">)([\\s\\S]*?)(</string>)`,
    'm',
  );

  if (pattern.test(content)) {
    return content.replace(pattern, `$1${escapedValue}$3`);
  }

  if (!content.includes('</resources>')) {
    throw new Error('Invalid Android strings.xml: missing </resources>');
  }

  return content.replace(
    '</resources>',
    `    <string name="${name}">${escapedValue}</string>\n</resources>`,
  );
};

const upsertPlistString = (content, key, value) => {
  const escapedValue = xmlEscape(value);
  const pattern = new RegExp(
    `(<key>${key}</key>\\s*<string>)([\\s\\S]*?)(</string>)`,
    'm',
  );

  if (pattern.test(content)) {
    return content.replace(pattern, `$1${escapedValue}$3`);
  }

  if (!content.includes('</dict>')) {
    throw new Error('Invalid Info.plist: missing </dict>');
  }

  return content.replace(
    '</dict>',
    `\t<key>${key}</key>\n\t<string>${escapedValue}</string>\n</dict>`,
  );
};

const resolvePublicKey = (args) => {
  if (args['public-key']) {
    return args['public-key'];
  }

  if (args['public-key-file']) {
    const publicKeyPath = path.resolve(args['public-key-file']);
    return readFile(publicKeyPath).trim();
  }

  return null;
};

const main = () => {
  const args = parseArgs(process.argv.slice(2));
  required(args, [
    'android-strings',
    'ios-plist',
    'deployment-key-android',
    'deployment-key-ios',
  ]);

  const publicKey = resolvePublicKey(args);
  const androidStringsPath = path.resolve(args['android-strings']);
  const iosPlistPath = path.resolve(args['ios-plist']);

  let androidStrings = readFile(androidStringsPath);
  androidStrings = upsertAndroidString(
    androidStrings,
    'CodePushDeploymentKey',
    args['deployment-key-android'],
  );

  if (args['server-url']) {
    androidStrings = upsertAndroidString(
      androidStrings,
      'CodePushServerUrl',
      args['server-url'],
    );
  }

  if (publicKey) {
    androidStrings = upsertAndroidString(
      androidStrings,
      'CodePushPublicKey',
      publicKey,
    );
  }

  let iosPlist = readFile(iosPlistPath);
  iosPlist = upsertPlistString(
    iosPlist,
    'CodePushDeploymentKey',
    args['deployment-key-ios'],
  );

  if (args['server-url']) {
    iosPlist = upsertPlistString(iosPlist, 'CodePushServerURL', args['server-url']);
  }

  if (publicKey) {
    iosPlist = upsertPlistString(iosPlist, 'CodePushPublicKey', publicKey);
  }

  writeFile(androidStringsPath, androidStrings);
  writeFile(iosPlistPath, iosPlist);

  console.info(`Updated ${androidStringsPath}`);
  console.info(`Updated ${iosPlistPath}`);
};

try {
  main();
} catch (error) {
  console.error(error.message);
  usage();
  process.exit(1);
}