@tolgee/cli 1.0.0-prerelease.1

package/dist/commands/push.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const commander_1 = require("commander");
+const errors_1 = require("../client/errors");
+const ask_1 = require("../utils/ask");
+const logger_1 = require("../utils/logger");
+async function readDirectory(directory, base = '') {
+    const files = [];
+    const dir = await (0, promises_1.readdir)(directory);
+    for (const file of dir) {
+        const filePath = (0, path_1.join)(directory, file);
+        const fileStat = await (0, promises_1.stat)(filePath);
+        if (fileStat.isDirectory()) {
+            const dirFiles = await readDirectory(filePath, `${file}/`);
+            files.push(...dirFiles);
+        }
+        else {
+            const blob = await (0, promises_1.readFile)(filePath);
+            files.push({ name: base + file, data: blob });
+        }
+    }
+    return files;
+}
+function getConflictingLanguages(result) {
+    const conflicts = [];
+    const languages = result.result?._embedded?.languages;
+    if (languages) {
+        for (const l of languages) {
+            if (l.conflictCount) {
+                conflicts.push(l.id);
+            }
+        }
+    }
+    return conflicts;
+}
+async function promptConflicts(opts) {
+    const projectId = opts.client.getProjectId();
+    const resolveUrl = new URL(`/projects/${projectId}/import`, opts.apiUrl).href;
+    if (opts.forceMode === 'NO') {
+        (0, logger_1.error)(`There are conflicts in the import. You can resolve them and complete the import here: ${resolveUrl}.`);
+        process.exit(1);
+    }
+    if (opts.forceMode) {
+        return opts.forceMode;
+    }
+    if (!process.stdout.isTTY) {
+        (0, logger_1.error)(`There are conflicts in the import. Please specify a --force-mode, or resolve them in your browser at ${resolveUrl}.`);
+        process.exit(1);
+    }
+    (0, logger_1.warn)('There are conflicts in the import. What do you want to do?');
+    const resp = await (0, ask_1.askString)('Type "KEEP" to preserve the version on the server, "OVERRIDE" to use the version from the import, and nothing to abort: ');
+    if (resp !== 'KEEP' && resp !== 'OVERRIDE') {
+        (0, logger_1.error)(`Aborting. You can resolve the conflicts and complete the import here: ${resolveUrl}`);
+        process.exit(1);
+    }
+    return resp;
+}
+async function prepareImport(client, files) {
+    return (0, logger_1.loading)('Deleting import...', client.import.deleteImportIfExists()).then(() => (0, logger_1.loading)('Uploading files...', client.import.addFiles({ files: files })));
+}
+async function resolveConflicts(client, locales, method) {
+    for (const locale of locales) {
+        if (method === 'KEEP') {
+            await client.import.conflictsKeepExistingAll(locale);
+        }
+        else {
+            await client.import.conflictsOverrideAll(locale);
+        }
+    }
+}
+async function applyImport(client) {
+    try {
+        await (0, logger_1.loading)('Applying changes...', client.import.applyImport());
+    }
+    catch (e) {
+        if (e instanceof errors_1.HttpError && e.response.status === 400) {
+            (0, logger_1.error)("Some of the imported languages weren't recognized. Please create a language with corresponding tag in the Tolgee Platform.");
+            return;
+        }
+        throw e;
+    }
+}
+async function pushHandler(path) {
+    const opts = this.optsWithGlobals();
+    try {
+        const stats = await (0, promises_1.stat)(path);
+        if (!stats.isDirectory()) {
+            (0, logger_1.error)('The specified path is not a directory.');
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            (0, logger_1.error)('The specified path does not exist.');
+            process.exit(1);
+        }
+        throw e;
+    }
+    const files = await (0, logger_1.loading)('Reading files...', readDirectory(path));
+    if (files.length === 0) {
+        (0, logger_1.error)('Nothing to import.');
+        return;
+    }
+    const result = await prepareImport(opts.client, files);
+    const conflicts = getConflictingLanguages(result);
+    if (conflicts.length) {
+        const resolveMethod = await promptConflicts(opts);
+        await (0, logger_1.loading)('Resolving conflicts...', resolveConflicts(opts.client, conflicts, resolveMethod));
+    }
+    await applyImport(opts.client);
+    (0, logger_1.success)('Done!');
+}
+exports.default = new commander_1.Command()
+    .name('push')
+    .description('Pushes translations to Tolgee')
+    .argument('<path>', 'Path to the files to push to Tolgee')
+    .addOption(new commander_1.Option('-f, --force-mode <mode>', 'What should we do with possible conflicts? If unspecified, the user will be prompted interactively, or the command will fail when in non-interactive')
+    .choices(['OVERRIDE', 'KEEP', 'NO'])
+    .argParser((v) => v.toUpperCase()))
+    .action(pushHandler);

package/dist/commands/sync/compare.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const ansi_colors_1 = __importDefault(require("ansi-colors"));
+const syncUtils_1 = require("./syncUtils");
+const runner_1 = require("../../extractor/runner");
+const warnings_1 = require("../../extractor/warnings");
+const options_1 = require("../../options");
+const logger_1 = require("../../utils/logger");
+async function compareHandler(pattern) {
+    const opts = this.optsWithGlobals();
+    const rawKeys = await (0, logger_1.loading)('Analyzing code...', (0, runner_1.extractKeysOfFiles)(pattern, opts.extractor));
+    (0, warnings_1.dumpWarnings)(rawKeys);
+    const localKeys = (0, runner_1.filterExtractionResult)(rawKeys);
+    const remoteKeys = await opts.client.project.fetchAllKeys();
+    const diff = (0, syncUtils_1.compareKeys)(localKeys, remoteKeys);
+    if (!diff.added.length && !diff.removed.length) {
+        console.log(ansi_colors_1.default.green('Your code project is in sync with the associated Tolgee project!'));
+        process.exit(0);
+    }
+    console.log('Your code project and Tolgee project are out of sync.');
+    if (diff.added.length) {
+        console.log(ansi_colors_1.default.green.bold(`${diff.added.length} new strings`));
+        for (const key of diff.added) {
+            (0, syncUtils_1.printKey)(key, 'added');
+        }
+        // Line break
+        console.log('');
+    }
+    if (diff.removed.length) {
+        console.log(ansi_colors_1.default.red.bold(`${diff.removed.length} removed strings`));
+        for (const key of diff.removed) {
+            (0, syncUtils_1.printKey)(key, 'removed');
+        }
+        // Line break
+        console.log('');
+    }
+    console.log('Run `tolgee sync` to synchronize the projects.');
+}
+exports.default = new commander_1.Command()
+    .name('compare')
+    .description('Compares the keys in your code project and in the Tolgee project.')
+    .argument('<pattern>', 'File pattern to include (hint: make sure to escape it in quotes, or your shell might attempt to unroll some tokens like *)')
+    .addOption(options_1.EXTRACTOR)
+    .action(compareHandler);

package/dist/commands/sync/sync.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const ansi_colors_1 = __importDefault(require("ansi-colors"));
+const runner_1 = require("../../extractor/runner");
+const warnings_1 = require("../../extractor/warnings");
+const syncUtils_1 = require("./syncUtils");
+const overwriteDir_1 = require("../../utils/overwriteDir");
+const zip_1 = require("../../utils/zip");
+const ask_1 = require("../../utils/ask");
+const logger_1 = require("../../utils/logger");
+const options_1 = require("../../options");
+async function backup(client, dest) {
+    const blob = await client.export.export({
+        format: 'JSON',
+        filterState: ['UNTRANSLATED', 'TRANSLATED', 'REVIEWED'],
+        structureDelimiter: '',
+    });
+    await (0, zip_1.unzipBuffer)(blob, dest);
+}
+async function askForConfirmation(keys, operation) {
+    if (!process.stdout.isTTY) {
+        (0, logger_1.error)('You must run this command interactively, or specify --yes to proceed.');
+        process.exit(1);
+    }
+    const str = `The following keys will be ${operation}:`;
+    console.log(operation === 'added' ? ansi_colors_1.default.bold.green(str) : ansi_colors_1.default.bold.red(str));
+    keys.forEach((k) => (0, syncUtils_1.printKey)(k, operation));
+    const shouldContinue = await (0, ask_1.askBoolean)('Does this look correct?', true);
+    if (!shouldContinue) {
+        (0, logger_1.error)('Aborting.');
+        process.exit(1);
+    }
+}
+async function syncHandler(pattern) {
+    const opts = this.optsWithGlobals();
+    const rawKeys = await (0, logger_1.loading)('Analyzing code...', (0, runner_1.extractKeysOfFiles)(pattern, opts.extractor));
+    const warnCount = (0, warnings_1.dumpWarnings)(rawKeys);
+    if (!opts.continueOnWarning && warnCount) {
+        console.log(ansi_colors_1.default.bold.red('Aborting as warnings have been emitted.'));
+        process.exit(1);
+    }
+    const localKeys = (0, runner_1.filterExtractionResult)(rawKeys);
+    const remoteKeys = await opts.client.project.fetchAllKeys();
+    const diff = (0, syncUtils_1.compareKeys)(localKeys, remoteKeys);
+    if (!diff.added.length && !diff.removed.length) {
+        console.log(ansi_colors_1.default.green('Your code project is in sync with the associated Tolgee project!'));
+        process.exit(0);
+    }
+    // Load project settings. We're interested in the default locale here.
+    const { baseLanguage } = await opts.client.project.fetchProjectInformation();
+    if (!baseLanguage) {
+        // I'm highly unsure how we could reach this state, but this is what the OAI spec tells me ¯\_(ツ)_/¯
+        (0, logger_1.error)('Your project does not have a base language!');
+        process.exit(1);
+    }
+    // Prepare backup
+    if (opts.backup) {
+        await (0, overwriteDir_1.overwriteDir)(opts.backup, opts.yes);
+        await (0, logger_1.loading)('Backing up Tolgee project', backup(opts.client, opts.backup));
+    }
+    // Create new keys
+    if (diff.added.length) {
+        if (!opts.yes) {
+            await askForConfirmation(diff.added, 'added');
+        }
+        const keys = diff.added.map((key) => ({
+            name: key.keyName,
+            namespace: key.namespace,
+            translations: key.defaultValue
+                ? { [baseLanguage.tag]: key.defaultValue }
+                : {},
+        }));
+        await (0, logger_1.loading)('Creating missing keys...', opts.client.project.createBulkKey(keys));
+    }
+    if (opts.removeUnused) {
+        // Delete unused keys.
+        if (diff.removed.length) {
+            if (!opts.yes) {
+                await askForConfirmation(diff.removed, 'removed');
+            }
+            const ids = await diff.removed.map((k) => k.id);
+            await (0, logger_1.loading)('Deleting unused keys...', opts.client.project.deleteBulkKeys(ids));
+        }
+    }
+    console.log(ansi_colors_1.default.bold.green('Sync complete!'));
+    console.log(ansi_colors_1.default.green(`+ ${diff.added.length} string${diff.added.length === 1 ? '' : 's'}`));
+    if (opts.removeUnused) {
+        console.log(ansi_colors_1.default.red(`- ${diff.removed.length} string${diff.removed.length === 1 ? '' : 's'}`));
+    }
+    else {
+        console.log(ansi_colors_1.default.italic(`${diff.removed.length} unused key${diff.removed.length === 1 ? '' : 's'} could be deleted.`));
+    }
+    if (opts.backup) {
+        console.log(ansi_colors_1.default.blueBright(`A backup of the project prior to the synchronization has been dumped in ${opts.backup}.`));
+    }
+}
+exports.default = new commander_1.Command()
+    .name('sync')
+    .description('Synchronizes the keys in your code project and in the Tolgee project, by creating missing keys and optionally deleting unused ones. For a dry-run, use `tolgee compare`.')
+    .argument('<pattern>', 'File pattern to include (hint: make sure to escape it in quotes, or your shell might attempt to unroll some tokens like *)')
+    .addOption(options_1.EXTRACTOR)
+    .option('-B, --backup <path>', 'Path where a backup should be downloaded before performing the sync. If something goes wrong, the backup can be used to restore the project to its previous state.')
+    .option('--continue-on-warning', 'Set this flag to continue the sync if warnings are detected during string extraction. By default, as warnings may indicate an invalid extraction, the CLI will abort the sync.')
+    .option('-Y, --yes', 'Skip prompts and automatically say yes to them. You will not be asked for confirmation before creating/deleting keys.')
+    .option('--remove-unused', 'Also delete unused keys from the Tolgee project.')
+    .action(syncHandler);

package/dist/commands/sync/syncUtils.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareKeys = exports.printKey = void 0;
+const runner_1 = require("../../extractor/runner");
+const ansi_colors_1 = __importDefault(require("ansi-colors"));
+/**
+ * Prints information about a key, with coloring and formatting.
+ *
+ * @param key The key to print.
+ * @param type Whether this is an addition or a removal.
+ */
+function printKey(key, type) {
+    const namespace = key.namespace
+        ? ` ${ansi_colors_1.default.italic(`(namespace: ${key.namespace})`)}`
+        : '';
+    if (type === 'added') {
+        console.log(`${ansi_colors_1.default.green(`+ ${key.keyName}`)}${namespace}`);
+    }
+    else {
+        console.log(`${ansi_colors_1.default.red(`- ${key.keyName}`)}${namespace}`);
+    }
+}
+exports.printKey = printKey;
+/**
+ * Compares local and remote keys to detect added and deleted keys.
+ * **Warning**: `local` will be modified as a side-effect!
+ *
+ * @param local Local keys.
+ * @param remote Remote keys.
+ * @returns A list of added and removed keys.
+ */
+function compareKeys(local, remote) {
+    const result = { added: [], removed: [] };
+    // Deleted keys
+    for (const remoteKey of remote) {
+        const namespace = remoteKey.namespace || runner_1.NullNamespace;
+        const keyExists = local[namespace]?.delete(remoteKey.name);
+        if (!keyExists) {
+            result.removed.push({
+                id: remoteKey.id,
+                keyName: remoteKey.name,
+                namespace: remoteKey.namespace || undefined,
+            });
+        }
+    }
+    // Added keys
+    const namespaces = [...Object.keys(local), runner_1.NullNamespace];
+    for (const namespace of namespaces) {
+        if (local[namespace].size) {
+            for (const [keyName, defaultValue] of local[namespace].entries()) {
+                result.added.push({
+                    keyName: keyName,
+                    namespace: namespace === runner_1.NullNamespace ? undefined : namespace,
+                    defaultValue: defaultValue || undefined,
+                });
+            }
+        }
+    }
+    return result;
+}
+exports.compareKeys = compareKeys;

package/dist/config/credentials.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAuthStore = exports.removeApiKeys = exports.saveApiKey = exports.getApiKey = exports.savePak = exports.savePat = exports.API_TOKENS_FILE = void 0;
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const logger_1 = require("../utils/logger");
+const constants_1 = require("../constants");
+exports.API_TOKENS_FILE = (0, path_1.join)(constants_1.CONFIG_PATH, 'authentication.json');
+async function ensureConfigPath() {
+    try {
+        await (0, promises_1.mkdir)((0, path_1.dirname)(exports.API_TOKENS_FILE));
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST') {
+            throw e;
+        }
+    }
+}
+async function loadStore() {
+    try {
+        await ensureConfigPath();
+        const storeData = await (0, promises_1.readFile)(exports.API_TOKENS_FILE, 'utf8');
+        return JSON.parse(storeData);
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT') {
+            throw e;
+        }
+    }
+    return {};
+}
+async function saveStore(store) {
+    const blob = JSON.stringify(store);
+    await (0, promises_1.writeFile)(exports.API_TOKENS_FILE, blob, {
+        mode: 0o600,
+        encoding: 'utf8',
+    });
+}
+async function storePat(store, instance, pat) {
+    return saveStore({
+        ...store,
+        [instance.hostname]: {
+            ...(store[instance.hostname] || {}),
+            user: pat,
+        },
+    });
+}
+async function storePak(store, instance, projectId, pak) {
+    return saveStore({
+        ...store,
+        [instance.hostname]: {
+            ...(store[instance.hostname] || {}),
+            projects: {
+                ...(store[instance.hostname]?.projects || {}),
+                [projectId.toString(10)]: pak,
+            },
+        },
+    });
+}
+async function savePat(instance, pat) {
+    const store = await loadStore();
+    return storePat(store, instance, pat);
+}
+exports.savePat = savePat;
+async function savePak(instance, projectId, pak) {
+    const store = await loadStore();
+    return storePak(store, instance, projectId, pak);
+}
+exports.savePak = savePak;
+async function getApiKey(instance, projectId) {
+    const store = await loadStore();
+    if (!store[instance.hostname]) {
+        return null;
+    }
+    const scopedStore = store[instance.hostname];
+    if (scopedStore.user) {
+        if (scopedStore.user.expires !== 0 &&
+            Date.now() > scopedStore.user.expires) {
+            (0, logger_1.warn)(`Your personal access token for ${instance.hostname} expired.`);
+            await storePat(store, instance, undefined);
+            return null;
+        }
+        return scopedStore.user.token;
+    }
+    if (projectId <= 0) {
+        return null;
+    }
+    const pak = scopedStore.projects?.[projectId.toString(10)];
+    if (pak) {
+        if (pak.expires !== 0 && Date.now() > pak.expires) {
+            (0, logger_1.warn)(`Your project API key for project #${projectId} on ${instance.hostname} expired.`);
+            await storePak(store, instance, projectId, undefined);
+            return null;
+        }
+        return pak.token;
+    }
+    return null;
+}
+exports.getApiKey = getApiKey;
+async function saveApiKey(instance, token) {
+    const store = await loadStore();
+    if (token.type === 'PAT') {
+        return storePat(store, instance, {
+            token: token.key,
+            expires: token.expires,
+        });
+    }
+    return storePak(store, instance, token.project.id, {
+        token: token.key,
+        expires: token.expires,
+    });
+}
+exports.saveApiKey = saveApiKey;
+async function removeApiKeys(api) {
+    const store = await loadStore();
+    return saveStore({
+        ...store,
+        [api.hostname]: {},
+    });
+}
+exports.removeApiKeys = removeApiKeys;
+async function clearAuthStore() {
+    return saveStore({});
+}
+exports.clearAuthStore = clearAuthStore;

package/dist/config/tolgeerc.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cosmiconfig_1 = require("cosmiconfig");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const constants_1 = require("../constants");
+const explorer = (0, cosmiconfig_1.cosmiconfig)('tolgee', {
+    loaders: {
+        noExt: cosmiconfig_1.defaultLoaders['.json'],
+    },
+});
+function parseConfig(rc) {
+    if (typeof rc !== 'object' || Array.isArray(rc)) {
+        throw new Error('Invalid config: config is not an object.');
+    }
+    const cfg = {};
+    if ('apiUrl' in rc) {
+        if (typeof rc.apiUrl !== 'string') {
+            throw new Error('Invalid config: apiUrl is not a string');
+        }
+        try {
+            cfg.apiUrl = new URL(rc.apiUrl);
+        }
+        catch (e) {
+            throw new Error('Invalid config: apiUrl is an invalid URL');
+        }
+    }
+    if ('projectId' in rc) {
+        if (typeof rc.projectId !== 'number') {
+            throw new Error('Invalid config: projectId is not a number');
+        }
+        cfg.projectId = rc.projectId;
+    }
+    if ('sdk' in rc) {
+        if (!constants_1.SDKS.includes(rc.sdk)) {
+            throw new Error(`Invalid config: invalid sdk. Must be one of: ${constants_1.SDKS.join(' ')}`);
+        }
+        cfg.sdk = rc.sdk;
+    }
+    if ('extractor' in rc) {
+        if (typeof rc.extractor !== 'string') {
+            throw new Error('Invalid config: extractor is not a string');
+        }
+        const extractorPath = (0, path_1.resolve)(rc.extractor);
+        if (!(0, fs_1.existsSync)(extractorPath)) {
+            throw new Error(`Invalid config: extractor points to a file that does not exists (${extractorPath})`);
+        }
+        cfg.extractor = extractorPath;
+    }
+    if ('delimiter' in rc) {
+        if (typeof rc.delimiter !== 'string' && rc.delimiter !== null) {
+            throw new Error('Invalid config: delimiter is not a string');
+        }
+        cfg.delimiter = rc.delimiter || void 0;
+    }
+    return cfg;
+}
+async function loadTolgeeRc() {
+    const res = await explorer.search();
+    if (!res || res.isEmpty)
+        return null;
+    return parseConfig(res.config);
+}
+exports.default = loadTolgeeRc;

package/dist/constants.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKS = exports.API_KEY_PAK_PREFIX = exports.API_KEY_PAT_PREFIX = exports.DEFAULT_API_URL = exports.USER_AGENT = exports.VERSION = exports.CONFIG_PATH = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const configPath_1 = __importDefault(require("./utils/configPath"));
+const packageJson = (0, path_1.join)(__dirname, '..', 'package.json');
+const pkg = (0, fs_1.readFileSync)(packageJson, 'utf8');
+exports.CONFIG_PATH = (0, configPath_1.default)();
+exports.VERSION = JSON.parse(pkg).version;
+exports.USER_AGENT = `Tolgee-CLI/${exports.VERSION} (+https://github.com/tolgee/tolgee-cli)`;
+exports.DEFAULT_API_URL = new URL('https://app.tolgee.io');
+exports.API_KEY_PAT_PREFIX = 'tgpat_';
+exports.API_KEY_PAK_PREFIX = 'tgpak_';
+exports.SDKS = ['react'];

package/dist/extractor/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });