@logto/cli 1.0.3 → 1.2.0

package/lib/commands/database/system.js

@@ -3,13 +3,13 @@ import { noop } from '@silverhand/essentials';
 import chalk from 'chalk';
 import { createPoolFromConfig } from '../../database.js';
 import { getRowByKey, updateValueByKey } from '../../queries/system.js';
-import { log } from '../../utils.js';
+import { consoleLog } from '../../utils.js';
 const validKeysDisplay = chalk.green(systemKeys.join(', '));
 const validateKey = (key) => {
     // Using `.includes()` will result a type error
     // eslint-disable-next-line unicorn/prefer-includes
     if (!systemKeys.some((element) => element === key)) {
-        log.error(`Invalid config key ${chalk.red(key)} found, expected one of ${validKeysDisplay}`);
+        consoleLog.fatal(`Invalid config key ${chalk.red(key)} found, expected one of ${validKeysDisplay}`);
     }
 };
 const getConfig = {
@@ -26,7 +26,7 @@ const getConfig = {
         const row = await getRowByKey(pool, key);
         await pool.end();
         const value = row?.value;
-        console.log(chalk.magenta(key) +
+        consoleLog.plain(chalk.magenta(key) +
             '=' +
             (value === undefined ? chalk.gray(value) : chalk.green(JSON.stringify(value))));
     },
@@ -41,7 +41,7 @@ const setConfig = {
         demandOption: true,
     })
         .positional('value', {
-        describe: 'The value to set, should be a valid JSON string',
+        describe: 'The value to set, should be a valid JSON string.',
         type: 'string',
         demandOption: true,
     }),
@@ -51,7 +51,7 @@ const setConfig = {
         const pool = await createPoolFromConfig();
         await updateValueByKey(pool, key, guarded);
         await pool.end();
-        log.info(`Update ${chalk.green(key)} succeeded`);
+        consoleLog.info(`Update ${chalk.green(key)} succeeded`);
     },
 };
 const system = {

package/lib/commands/database/utils.js

@@ -1,6 +1,6 @@
-import { generateKeyPair } from 'crypto';
-import { promisify } from 'util';
-import { generateStandardId } from '@logto/core-kit';
+import { generateKeyPair } from 'node:crypto';
+import { promisify } from 'node:util';
+import { generateStandardId } from '@logto/shared';
 export const generateOidcPrivateKey = async (type = 'ec') => {
     if (type === 'rsa') {
         const { privateKey } = await promisify(generateKeyPair)('rsa', {

package/lib/commands/install/index.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { getDatabaseUrlFromConfig } from '../../database.js';
-import { log } from '../../utils.js';
+import { consoleLog } from '../../utils.js';
 import { validateNodeVersion, inquireInstancePath, validateDatabase, downloadRelease, seedDatabase, createEnv, logFinale, decompress, isUrl, } from './utils.js';
 const installLogto = async ({ path, skipSeed, downloadUrl, cloud }) => {
     validateNodeVersion();
@@ -13,7 +13,7 @@ const installLogto = async ({ path, skipSeed, downloadUrl, cloud }) => {
     await decompress(instancePath, tarPath);
     // Seed database
     if (skipSeed) {
-        log.info(`Skipped database seeding.\n\n' + '  You can use the ${chalk.green('db seed')} command to seed database when ready.\n`);
+        consoleLog.info(`Skipped database seeding.\n\n' + '  You can use the ${chalk.green('db seed')} command to seed database when ready.\n`);
     }
     else {
         await seedDatabase(instancePath, cloud);
@@ -46,7 +46,7 @@ const install = {
         },
         du: {
             alias: 'download-url',
-            describe: 'URL for downloading Logto, can be a local path to tar',
+            describe: 'URL for downloading Logto, can be a local path to tar.',
             type: 'string',
             hidden: true,
         },

package/lib/commands/install/utils.js

@@ -1,8 +1,8 @@
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import fs from 'fs/promises';
-import os from 'os';
-import path from 'path';
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
 import { assert } from '@silverhand/essentials';
 import chalk from 'chalk';
 import inquirer from 'inquirer';
@@ -10,7 +10,7 @@ import * as semver from 'semver';
 import tar from 'tar';
 import { createPoolAndDatabaseIfNeeded } from '../../database.js';
 import { packageJson } from '../../package-json.js';
-import { cliConfig, ConfigKey, downloadFile, isTty, log, oraPromise, safeExecSync, } from '../../utils.js';
+import { cliConfig, ConfigKey, consoleLog, downloadFile, isTty, oraPromise, safeExecSync, } from '../../utils.js';
 import { seedByPool } from '../database/seed/index.js';
 export const defaultPath = path.join(os.homedir(), 'logto');
 const pgRequired = new semver.SemVer('14.0.0');
@@ -19,10 +19,10 @@ export const validateNodeVersion = () => {
     const requiredVersionString = required.map((version) => '^' + version.version).join(' || ');
     const current = new semver.SemVer(execSync('node -v', { encoding: 'utf8', stdio: 'pipe' }));
     if (required.every((version) => version.major !== current.major)) {
-        log.error(`Logto requires NodeJS ${requiredVersionString}, but ${current.version} found.`);
+        consoleLog.fatal(`Logto requires NodeJS ${requiredVersionString}, but ${current.version} found.`);
     }
     if (required.some((version) => version.major === current.major && version.compare(current) > 0)) {
-        log.warn(`Logto is tested under NodeJS ${requiredVersionString}, but version ${current.version} found.`);
+        consoleLog.warn(`Logto is tested under NodeJS ${requiredVersionString}, but version ${current.version} found.`);
     }
 };
 const validatePath = (value) => existsSync(path.resolve(value))
@@ -44,7 +44,7 @@ export const inquireInstancePath = async (initialPath) => {
     // Validate for initialPath
     const validated = validatePath(instancePath);
     if (validated !== true) {
-        log.error(validated);
+        consoleLog.fatal(validated);
     }
     return instancePath;
 };
@@ -65,15 +65,15 @@ export const validateDatabase = async () => {
         },
     });
     if (hasPostgresUrl === false) {
-        log.error('Logto requires a Postgres instance to run.');
+        consoleLog.fatal('Logto requires a Postgres instance to run.');
     }
 };
 export const downloadRelease = async (url) => {
     const tarFilePath = path.resolve(os.tmpdir(), './logto.tar.gz');
     const from = url ??
         `https://github.com/logto-io/logto/releases/download/v${packageJson.version}/logto.tar.gz`;
-    log.info(`Download Logto from ${from}`);
-    log.info(`Target ${tarFilePath}`);
+    consoleLog.info(`Download Logto from ${from}`);
+    consoleLog.info(`Target ${tarFilePath}`);
     await downloadFile(from, tarFilePath);
     return tarFilePath;
 };
@@ -84,7 +84,7 @@ export const decompress = async (toPath, tarPath) => {
             await tar.extract({ file: tarPath, cwd: toPath, strip: 1 });
         }
         catch (error) {
-            log.error(error);
+            consoleLog.fatal(error);
         }
     };
     return oraPromise(run(), {
@@ -99,23 +99,23 @@ export const seedDatabase = async (instancePath, cloud) => {
         await pool.end();
     }
     catch (error) {
-        console.error(error);
+        consoleLog.error(error);
         await oraPromise(fs.rm(instancePath, { force: true, recursive: true }), {
             text: 'Clean up',
             prefixText: chalk.blue('[info]'),
         });
-        log.error('Error occurred during seeding your Logto database. Nothing has changed since the seeding process was in a transaction.\n\n' +
+        consoleLog.fatal('Error occurred during seeding your Logto database. Nothing has changed since the seeding process was in a transaction.\n\n' +
             `  To skip the database seeding, append ${chalk.green('--skip-seed')} to the command options.`);
     }
 };
 export const createEnv = async (instancePath, databaseUrl) => {
     const dotEnvPath = path.resolve(instancePath, '.env');
     await fs.writeFile(dotEnvPath, `DB_URL=${databaseUrl}`, 'utf8');
-    log.info(`Saved database URL to ${chalk.blue(dotEnvPath)}`);
+    consoleLog.info(`Saved database URL to ${chalk.blue(dotEnvPath)}`);
 };
 export const logFinale = (instancePath) => {
     const startCommand = `cd ${instancePath} && npm start`;
-    log.info(`Use the command below to start Logto. Happy hacking!\n\n  ${chalk.green(startCommand)}`);
+    consoleLog.info(`Use the command below to start Logto. Happy hacking!\n\n  ${chalk.green(startCommand)}`);
 };
 export const isUrl = (string) => {
     try {

package/lib/commands/translate/create.d.ts

@@ -0,0 +1,8 @@
+import type { CommandModule } from 'yargs';
+declare const create: CommandModule<{
+    path?: string;
+}, {
+    path?: string;
+    'language-tag': string;
+}>;
+export default create;

package/lib/commands/translate/create.js

@@ -0,0 +1,38 @@
+import { isLanguageTag } from '@logto/language-kit';
+import { isBuiltInLanguageTag as isPhrasesBuiltInLanguageTag } from '@logto/phrases';
+import { isBuiltInLanguageTag as isPhrasesUiBuiltInLanguageTag } from '@logto/phrases-ui';
+import { consoleLog } from '../../utils.js';
+import { inquireInstancePath } from '../connector/utils.js';
+import { createFullTranslation } from './utils.js';
+const create = {
+    command: ['create <language-tag>', 'c'],
+    describe: 'Create a new language translation using ChatGPT. Note the environment variable `OPENAI_API_KEY` is required to work.',
+    builder: (yargs) => yargs.positional('language-tag', {
+        describe: 'The language tag to create, e.g. `af-ZA`.',
+        type: 'string',
+        demandOption: true,
+    }),
+    handler: async ({ path: inputPath, languageTag }) => {
+        if (!isLanguageTag(languageTag)) {
+            consoleLog.fatal('Invalid language tag. Run `logto translate list-tags` to see available list.');
+        }
+        const instancePath = await inquireInstancePath(inputPath);
+        if (isPhrasesBuiltInLanguageTag(languageTag)) {
+            consoleLog.info(languageTag + ' is a built-in tag of phrases, updating untranslated phrases');
+        }
+        await createFullTranslation({
+            instancePath,
+            packageName: 'phrases',
+            languageTag,
+        });
+        if (isPhrasesUiBuiltInLanguageTag(languageTag)) {
+            consoleLog.info(languageTag + ' is a built-in tag of phrases-ui, updating untranslated phrases');
+        }
+        await createFullTranslation({
+            instancePath,
+            packageName: 'phrases-ui',
+            languageTag,
+        });
+    },
+};
+export default create;

package/lib/commands/translate/index.d.ts

@@ -0,0 +1,3 @@
+import type { CommandModule } from 'yargs';
+declare const translate: CommandModule;
+export default translate;

package/lib/commands/translate/index.js

@@ -0,0 +1,20 @@
+import { noop } from '@silverhand/essentials';
+import create from './create.js';
+import listTags from './list-tags.js';
+import sync from './sync.js';
+const translate = {
+    command: ['translate', 't'],
+    describe: 'Commands for Logto translation',
+    builder: (yargs) => yargs
+        .option('path', {
+        alias: 'p',
+        type: 'string',
+        describe: 'The path to your Logto instance directory',
+    })
+        .command(create)
+        .command(listTags)
+        .command(sync)
+        .demandCommand(1),
+    handler: noop,
+};
+export default translate;

package/lib/commands/translate/list-tags.d.ts

@@ -0,0 +1,3 @@
+import type { CommandModule } from 'yargs';
+declare const listTags: CommandModule<Record<string, unknown>>;
+export default listTags;

package/lib/commands/translate/list-tags.js

@@ -0,0 +1,19 @@
+import { languages } from '@logto/language-kit';
+import { isBuiltInLanguageTag as isPhrasesBuiltInLanguageTag } from '@logto/phrases';
+import { isBuiltInLanguageTag as isPhrasesUiBuiltInLanguageTag } from '@logto/phrases-ui';
+import chalk from 'chalk';
+import { consoleLog } from '../../utils.js';
+const listTags = {
+    command: ['list-tags', 'list'],
+    describe: 'List all available language tags',
+    handler: async () => {
+        for (const tag of Object.keys(languages)) {
+            consoleLog.plain(...[
+                tag,
+                isPhrasesBuiltInLanguageTag(tag) && chalk.blue('phrases'),
+                isPhrasesUiBuiltInLanguageTag(tag) && chalk.blue('phrases-ui'),
+            ].filter(Boolean));
+        }
+    },
+};
+export default listTags;

package/lib/commands/translate/openai.d.ts

@@ -0,0 +1,11 @@
+import { type LanguageTag } from '@logto/language-kit';
+import { type Got } from 'got';
+export declare const createOpenaiApi: () => Got;
+type TranslateConfig = {
+    api: Got;
+    sourceFilePath: string;
+    targetLanguage: LanguageTag;
+    extraPrompt?: string;
+};
+export declare const translate: ({ api, targetLanguage, sourceFilePath, extraPrompt, }: TranslateConfig) => Promise<string | undefined>;
+export {};

package/lib/commands/translate/openai.js

@@ -0,0 +1,77 @@
+import fs from 'node:fs/promises';
+import { trySafe } from '@silverhand/essentials';
+import { got, HTTPError } from 'got';
+import { HttpsProxyAgent } from 'hpagent';
+import { z } from 'zod';
+import { consoleLog, getProxy } from '../../utils.js';
+import { getTranslationPrompt } from './prompts.js';
+export const createOpenaiApi = () => {
+    const proxy = getProxy();
+    return got.extend({
+        prefixUrl: 'https://api.openai.com/v1',
+        headers: {
+            Authorization: `Bearer ${process.env.OPENAI_API_KEY ?? ''}`,
+        },
+        timeout: { request: 300_000 },
+        ...(proxy && { agent: { https: new HttpsProxyAgent({ proxy, timeout: 300_000 }) } }),
+    });
+};
+const gptResponseGuard = z.object({
+    choices: z
+        .object({
+        message: z.object({ role: z.string(), content: z.string() }),
+        finish_reason: z.string(),
+    })
+        .array(),
+});
+export const translate = async ({ api, targetLanguage, sourceFilePath, extraPrompt, }) => {
+    const sourceFileContent = await fs.readFile(sourceFilePath, 'utf8');
+    const response = await trySafe(api
+        .post('chat/completions', {
+        json: {
+            model: 'gpt-3.5-turbo',
+            messages: [
+                {
+                    role: 'user',
+                    content: getTranslationPrompt({
+                        sourceFileContent,
+                        targetLanguage,
+                        extraPrompt,
+                    }),
+                },
+            ],
+        },
+    })
+        .json(), (error) => {
+        consoleLog.warn(`Error while translating ${sourceFilePath}:`, String(error));
+        if (error instanceof HTTPError) {
+            consoleLog.warn(error.response.body);
+        }
+    });
+    if (!response) {
+        return;
+    }
+    const guarded = gptResponseGuard.safeParse(response);
+    if (!guarded.success) {
+        consoleLog.warn(`Error while guarding response for ${sourceFilePath}:`, response);
+        return;
+    }
+    const [entity] = guarded.data.choices;
+    if (!entity) {
+        consoleLog.warn(`No choice found in response when translating ${sourceFilePath}`);
+        return;
+    }
+    if (entity.finish_reason !== 'stop') {
+        consoleLog.warn(`Unexpected finish reason ${entity.finish_reason} for ${sourceFilePath}`);
+    }
+    const { content } = entity.message;
+    const matched = /```(?:ts)?\n(.*)```/s.exec(content)?.[1];
+    if (!matched) {
+        // Treat as pure code
+        if (['const ', 'import '].some((prefix) => content.startsWith(prefix))) {
+            return content;
+        }
+        consoleLog.warn('No matching code snippet from response:', content);
+    }
+    return matched;
+};

package/lib/commands/translate/prompts.d.ts

@@ -0,0 +1,14 @@
+import { type LanguageTag } from '@logto/language-kit';
+type GetTranslationPromptProperties = {
+    sourceFileContent: string;
+    targetLanguage: LanguageTag;
+    extraPrompt?: string;
+};
+/**
+ * Note:
+ * The input token limit of GPT 3.5 is 2048, the following prompt tokens with sourceFileContent is about 1200.
+ * Remember to check the token limit before adding more prompt.
+ * Tokens can be counted in https://platform.openai.com/tokenizer
+ */
+export declare const getTranslationPrompt: ({ sourceFileContent, targetLanguage, extraPrompt, }: GetTranslationPromptProperties) => string;
+export {};

package/lib/commands/translate/prompts.js

@@ -0,0 +1,39 @@
+import { languages } from '@logto/language-kit';
+import { conditionalString } from '@silverhand/essentials';
+/**
+ * Note:
+ * The input token limit of GPT 3.5 is 2048, the following prompt tokens with sourceFileContent is about 1200.
+ * Remember to check the token limit before adding more prompt.
+ * Tokens can be counted in https://platform.openai.com/tokenizer
+ */
+export const getTranslationPrompt = ({ sourceFileContent, targetLanguage, extraPrompt, }) => `Given the following code snippet:
+\`\`\`ts
+${sourceFileContent}
+\`\`\`
+only translate object values to ${languages[targetLanguage]}, keep all object keys original, output ts code only, the code format should be strictly consistent, and should not contains the given code snippet.
+
+Take zh-cn as an example, if the input is:
+\`\`\`ts
+import others from './others.js';
+
+const translation = {
+  hello: '你好',
+  world: 'world', // UNTRANSLATED
+  others,
+};
+
+export default translation;
+\`\`\`
+the output should be:
+\`\`\`ts
+import others from './others.js';
+
+const translation = {
+  hello: '你好',
+  world: '世界',
+  others,
+};
+
+export default translation;
+\`\`\`
+${conditionalString(extraPrompt)}`;

package/lib/commands/translate/sync.d.ts

@@ -0,0 +1,7 @@
+import type { CommandModule } from 'yargs';
+declare const sync: CommandModule<{
+    path?: string;
+}, {
+    path?: string;
+}>;
+export default sync;

package/lib/commands/translate/sync.js

@@ -0,0 +1,40 @@
+import { languages } from '@logto/language-kit';
+import { isBuiltInLanguageTag as isPhrasesBuiltInLanguageTag } from '@logto/phrases';
+import { isBuiltInLanguageTag as isPhrasesUiBuiltInLanguageTag } from '@logto/phrases-ui';
+import PQueue from 'p-queue';
+import { inquireInstancePath } from '../connector/utils.js';
+import { baseLanguage, syncTranslation } from './utils.js';
+const sync = {
+    command: ['sync'],
+    describe: 'Translate all untranslated phrases using ChatGPT. Note the environment variable `OPENAI_API_KEY` is required to work.',
+    handler: async ({ path: inputPath }) => {
+        const queue = new PQueue({ concurrency: 5 });
+        const instancePath = await inquireInstancePath(inputPath);
+        for (const languageTag of Object.keys(languages)) {
+            if (languageTag === baseLanguage) {
+                continue;
+            }
+            const baseOptions = {
+                instancePath,
+                verbose: false,
+                queue,
+            };
+            if (isPhrasesBuiltInLanguageTag(languageTag)) {
+                void syncTranslation({
+                    ...baseOptions,
+                    packageName: 'phrases',
+                    languageTag,
+                });
+            }
+            if (isPhrasesUiBuiltInLanguageTag(languageTag)) {
+                void syncTranslation({
+                    ...baseOptions,
+                    packageName: 'phrases-ui',
+                    languageTag,
+                });
+            }
+        }
+        await queue.onIdle();
+    },
+};
+export default sync;

package/lib/commands/translate/utils.d.ts

@@ -0,0 +1,14 @@
+import { type LanguageTag } from '@logto/language-kit';
+import PQueue from 'p-queue';
+export declare const baseLanguage = "en";
+export declare const readLocaleFiles: (directory: string) => Promise<string[]>;
+export declare const readBaseLocaleFiles: (directory: string) => Promise<string[]>;
+export type TranslationOptions = {
+    instancePath: string;
+    packageName: 'phrases' | 'phrases-ui';
+    languageTag: LanguageTag;
+    verbose?: boolean;
+    queue?: PQueue;
+};
+export declare const createFullTranslation: ({ instancePath, packageName, languageTag, verbose, queue, }: TranslationOptions) => Promise<void>;
+export declare const syncTranslation: ({ instancePath, packageName, languageTag, verbose, queue, }: TranslationOptions) => Promise<void>;

package/lib/commands/translate/utils.js

@@ -0,0 +1,131 @@
+import { existsSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { conditionalString } from '@silverhand/essentials';
+import PQueue from 'p-queue';
+import { consoleLog } from '../../utils.js';
+import { createOpenaiApi, translate } from './openai.js';
+export const baseLanguage = 'en';
+const untranslatedMark = '// UNTRANSLATED';
+export const readLocaleFiles = async (directory) => {
+    const entities = await fs.readdir(directory, { withFileTypes: true });
+    const result = await Promise.all(entities.map(async (entity) => {
+        if (entity.isDirectory()) {
+            return readLocaleFiles(path.join(directory, entity.name));
+        }
+        return entity.name.endsWith('.ts') ? path.join(directory, entity.name) : [];
+    }));
+    return result.flat();
+};
+export const readBaseLocaleFiles = async (directory) => {
+    const enDirectory = path.join(directory, baseLanguage.toLowerCase());
+    const stat = await fs.stat(enDirectory);
+    if (!stat.isDirectory()) {
+        consoleLog.fatal(directory, 'has no `' + baseLanguage.toLowerCase() + '` directory');
+    }
+    return readLocaleFiles(enDirectory);
+};
+export const createFullTranslation = async ({ instancePath, packageName, languageTag, verbose = true, queue = new PQueue({ concurrency: 5 }), }) => {
+    const localeFiles = await getBaseAndTargetLocaleFiles(instancePath, packageName, languageTag);
+    if (verbose) {
+        consoleLog.info('Found ' +
+            String(localeFiles.length) +
+            ' file' +
+            conditionalString(localeFiles.length !== 1 && 's') +
+            ' in ' +
+            packageName +
+            ' to create');
+    }
+    const openai = createOpenaiApi();
+    for (const { baseLocaleFile, targetLocaleFile } of localeFiles) {
+        if (existsSync(targetLocaleFile)) {
+            if (verbose) {
+                consoleLog.info(`Target locale file ${targetLocaleFile} exists, skipping`);
+            }
+            continue;
+        }
+        void createLocaleFile({
+            api: openai,
+            baseLocaleFile,
+            targetPath: targetLocaleFile,
+            targetLanguage: languageTag,
+            queue,
+        });
+    }
+    return queue.onIdle();
+};
+export const syncTranslation = async ({ instancePath, packageName, languageTag, verbose = true, queue = new PQueue({ concurrency: 5 }), }) => {
+    const localeFiles = await getBaseAndTargetLocaleFiles(instancePath, packageName, languageTag);
+    if (verbose) {
+        consoleLog.info('Found ' +
+            String(localeFiles.length) +
+            ' file' +
+            conditionalString(localeFiles.length !== 1 && 's') +
+            ' in ' +
+            packageName +
+            ' to translate');
+    }
+    const openai = createOpenaiApi();
+    /* eslint-disable no-await-in-loop */
+    for (const { baseLocaleFile, targetLocaleFile } of localeFiles) {
+        if (!existsSync(targetLocaleFile)) {
+            void createLocaleFile({
+                api: openai,
+                baseLocaleFile,
+                targetPath: targetLocaleFile,
+                targetLanguage: languageTag,
+                queue,
+            });
+            continue;
+        }
+        const currentContent = await fs.readFile(targetLocaleFile, 'utf8');
+        if (!currentContent.includes(untranslatedMark)) {
+            if (verbose) {
+                consoleLog.info(`Target path ${targetLocaleFile} exists and has no untranslated mark, skipping`);
+            }
+            continue;
+        }
+        void queue.add(async () => {
+            consoleLog.info(`Translating ${targetLocaleFile}`);
+            const result = await translate({
+                api: openai,
+                sourceFilePath: targetLocaleFile,
+                targetLanguage: languageTag,
+                extraPrompt: `Object values without an "${untranslatedMark}" mark should be skipped and keep its original value. Remember to remove the "${untranslatedMark}" mark with the spaces before and after it in the output content.`,
+            });
+            if (!result) {
+                consoleLog.fatal(`Unable to translate ${targetLocaleFile}`);
+            }
+            await fs.unlink(targetLocaleFile);
+            await fs.writeFile(targetLocaleFile, result);
+            consoleLog.succeed(`Translated ${targetLocaleFile}`);
+        });
+    }
+    /* eslint-enable no-await-in-loop */
+    return queue.onIdle();
+};
+const getBaseAndTargetLocaleFiles = async (instancePath, packageName, languageTag) => {
+    const directory = path.join(instancePath, 'packages', packageName, 'src/locales');
+    const baseLocaleFiles = await readBaseLocaleFiles(directory);
+    return baseLocaleFiles.map((baseLocaleFile) => {
+        const basePath = path.relative(path.join(directory, baseLanguage.toLowerCase()), baseLocaleFile);
+        return {
+            baseLocaleFile,
+            targetLocaleFile: path.join(directory, languageTag.toLowerCase(), basePath),
+        };
+    });
+};
+const createLocaleFile = async ({ api, baseLocaleFile, targetPath, targetLanguage, queue, }) => queue.add(async () => {
+    consoleLog.info(`Creating the translation for ${targetPath}`);
+    const result = await translate({
+        api,
+        sourceFilePath: baseLocaleFile,
+        targetLanguage,
+    });
+    if (!result) {
+        consoleLog.fatal(`Unable to create the translation for ${targetPath}`);
+    }
+    await fs.mkdir(path.parse(targetPath).dir, { recursive: true });
+    await fs.writeFile(targetPath, result);
+    consoleLog.succeed(`The translation for ${targetPath} created`);
+});

package/lib/connector/factories.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { consoleLog } from '../utils.js';
 import { notImplemented } from './consts.js';
 import { loadConnector } from './loader.js';
 import { parseMetadata, validateConnectorModule } from './utils.js';
@@ -22,7 +23,7 @@ export const loadConnectorFactories = async (connectorPackages, ignoreVersionMis
         }
         catch (error) {
             if (error instanceof Error) {
-                console.log(`${chalk.red(`[load-connector] skip ${chalk.bold(name)} due to error: ${error.message}`)}`);
+                consoleLog.error(`[load-connector] skip ${chalk.bold(name)} due to error: ${error.message}`);
                 return;
             }
             throw error;