@logto/cli 1.6.0 → 1.8.0

package/LICENSE

@@ -1,9 +1,3 @@
-Portions of this software are licensed as follows:
-
-* All content that resides under the "packages/cloud" directory of this repository, if that directory exists, is licensed under the license defined in "packages/cloud/LICENSE" (Elastic-2.0).
-* All third party components incorporated into this software are licensed under the original license provided by the owner of the applicable component.
-* Content outside of the above mentioned directories or restrictions above is available under the "MPL-2.0" license as defined below.
-
 Mozilla Public License Version 2.0
 ==================================
 

package/lib/commands/connector/utils.js

@@ -109,9 +109,9 @@ export const addConnectorsToPath = async (cwd, packageNames) => {
                 throw new Error(`Unable to execute ${chalk.green('npm pack')} on package ${chalk.green(packageName)}`);
             }
             const { filename, name, version } = result[0];
-            const escapedFilename = filename.replace(/\//g, '-').replace(/@/g, '');
+            const escapedFilename = filename.replaceAll('/', '-').replaceAll('@', '');
             const tarPath = path.join(cwd, escapedFilename);
-            const packageDirectory = path.join(cwd, name.replace(/\//g, '-'));
+            const packageDirectory = path.join(cwd, name.replaceAll('/', '-'));
             await fs.rm(packageDirectory, { force: true, recursive: true });
             await fs.mkdir(packageDirectory, { recursive: true });
             await tar.extract({ cwd: packageDirectory, file: tarPath, strip: 1 });

package/lib/commands/database/alteration/index.js

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import { createPoolFromConfig } from '../../../database.js';
 import { getCurrentDatabaseAlterationTimestamp, updateDatabaseTimestamp, } from '../../../queries/system.js';
 import { consoleLog } from '../../../utils.js';
-import { getAlterationFiles, getTimestampFromFilename } from './utils.js';
+import { getAlterationFiles, getTimestampFromFilename, chooseRevertAlterationsByTimestamp, } from './utils.js';
 import { chooseAlterationsByVersion, chooseRevertAlterationsByVersion } from './version.js';
 const importAlterationScript = async (filePath) => {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
@@ -13,7 +13,7 @@ const importAlterationScript = async (filePath) => {
 };
 export const getLatestAlterationTimestamp = async () => {
     const files = await getAlterationFiles();
-    const lastFile = files[files.length - 1];
+    const lastFile = files.at(-1);
     if (!lastFile) {
         return 0;
     }
@@ -52,6 +52,15 @@ const deployAlteration = async (pool, { path: filePath, filename }, action = 'up
     }
     consoleLog.info(`Run alteration ${filename} \`${action}()\` function succeeded`);
 };
+const revertAlterations = async (alterations, pool) => {
+    consoleLog.info(`Found ${alterations.length} alteration${conditionalString(alterations.length > 1 && 's')} to revert`);
+    // The await inside the loop is intended, alterations should run in order
+    // eslint-disable-next-line @silverhand/fp/no-mutating-methods
+    for (const alteration of alterations.slice().reverse()) {
+        // eslint-disable-next-line no-await-in-loop
+        await deployAlteration(pool, alteration, 'down');
+    }
+};
 const alteration = {
     command: ['alteration <action> [target]', 'alt', 'alter'],
     describe: 'Perform database alteration',
@@ -66,37 +75,44 @@ const alteration = {
         type: 'string',
     }),
     handler: async ({ action, target }) => {
-        if (action === 'list') {
-            const files = await getAlterationFiles();
-            for (const file of files) {
-                consoleLog.plain(file.filename);
+        switch (action) {
+            case 'list': {
+                const files = await getAlterationFiles();
+                for (const file of files) {
+                    consoleLog.plain(file.filename);
+                }
+                break;
             }
-        }
-        else if (action === 'deploy') {
-            const pool = await createPoolFromConfig();
-            const alterations = await chooseAlterationsByVersion(await getAvailableAlterations(pool), target);
-            consoleLog.info(`Found ${alterations.length} alteration${conditionalString(alterations.length > 1 && 's')} to deploy`);
-            // The await inside the loop is intended, alterations should run in order
-            for (const alteration of alterations) {
-                // eslint-disable-next-line no-await-in-loop
-                await deployAlteration(pool, alteration);
+            case 'deploy': {
+                const pool = await createPoolFromConfig();
+                const alterations = await chooseAlterationsByVersion(await getAvailableAlterations(pool), target);
+                consoleLog.info(`Found ${alterations.length} alteration${conditionalString(alterations.length > 1 && 's')} to deploy`);
+                // The await inside the loop is intended, alterations should run in order
+                for (const alteration of alterations) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await deployAlteration(pool, alteration);
+                }
+                await pool.end();
+                break;
             }
-            await pool.end();
-        }
-        else if (['rollback', 'r'].includes(action)) {
-            const pool = await createPoolFromConfig();
-            const alterations = await chooseRevertAlterationsByVersion(await getAvailableAlterations(pool, 'lte'), target ?? '');
-            consoleLog.info(`Found ${alterations.length} alteration${conditionalString(alterations.length > 1 && 's')} to revert`);
-            // The await inside the loop is intended, alterations should run in order
-            // eslint-disable-next-line @silverhand/fp/no-mutating-methods
-            for (const alteration of alterations.slice().reverse()) {
-                // eslint-disable-next-line no-await-in-loop
-                await deployAlteration(pool, alteration, 'down');
+            case 'rollback':
+            case 'r': {
+                const pool = await createPoolFromConfig();
+                const alterations = await chooseRevertAlterationsByVersion(await getAvailableAlterations(pool, 'lte'), target ?? '');
+                await revertAlterations(alterations, pool);
+                await pool.end();
+                break;
+            }
+            case 'rollback-to-timestamp': {
+                const pool = await createPoolFromConfig();
+                const alterations = await chooseRevertAlterationsByTimestamp(target ?? '');
+                await revertAlterations(alterations, pool);
+                await pool.end();
+                break;
+            }
+            default: {
+                consoleLog.fatal('Unsupported action');
             }
-            await pool.end();
-        }
-        else {
-            consoleLog.fatal('Unsupported action');
         }
     },
 };

package/lib/commands/database/alteration/utils.d.ts

@@ -2,3 +2,4 @@ import type { AlterationFile } from './type.js';
 export declare const getTimestampFromFilename: (filename: string) => number;
 export declare const getAlterationDirectory: () => string;
 export declare const getAlterationFiles: () => Promise<AlterationFile[]>;
+export declare const chooseRevertAlterationsByTimestamp: (target: string) => Promise<AlterationFile[]>;

package/lib/commands/database/alteration/utils.js

@@ -36,3 +36,11 @@ export const getAlterationFiles = async () => {
         .sort((file1, file2) => getTimestampFromFilename(file1) - getTimestampFromFilename(file2))
         .map((filename) => ({ path: path.join(localAlterationDirectory, filename), filename }));
 };
+export const chooseRevertAlterationsByTimestamp = async (target) => {
+    const files = await getAlterationFiles();
+    const targetTimestamp = Number(target);
+    if (Number.isNaN(targetTimestamp)) {
+        return [];
+    }
+    return files.filter(({ filename }) => getTimestampFromFilename(filename) > targetTimestamp);
+};

package/lib/commands/database/config.js

@@ -4,7 +4,7 @@ import chalk from 'chalk';
 import { createPoolFromConfig } from '../../database.js';
 import { getRowsByKeys, updateValueByKey } from '../../queries/logto-config.js';
 import { consoleLog } from '../../utils.js';
-import { generateOidcCookieKey, generateOidcPrivateKey } from './utils.js';
+import { PrivateKeyType, generateOidcCookieKey, generateOidcPrivateKey } from './utils.js';
 const validKeysDisplay = chalk.green(logtoConfigKeys.join(', '));
 const validateKeys = (keys) => {
     const invalidKey = (Array.isArray(keys) ? keys : [keys]).find(
@@ -19,6 +19,7 @@ const validRotateKeys = Object.freeze([
     LogtoOidcConfigKey.PrivateKeys,
     LogtoOidcConfigKey.CookieKeys,
 ]);
+const validPrivateKeyTypes = Object.freeze([PrivateKeyType.RSA, PrivateKeyType.EC]);
 const validateRotateKey = (key) => {
     // Using `.includes()` will result a type error
     // eslint-disable-next-line unicorn/prefer-includes
@@ -26,6 +27,13 @@ const validateRotateKey = (key) => {
         consoleLog.fatal(`Invalid config key ${chalk.red(key)} found, expected one of ${validKeysDisplay}`);
     }
 };
+const validatePrivateKeyType = (key) => {
+    // Using `.includes()` will result a type error
+    // eslint-disable-next-line unicorn/prefer-includes
+    if (!validPrivateKeyTypes.some((element) => element === key)) {
+        consoleLog.fatal(`Invalid private key type ${chalk.red(key)} found, expected one of ${validPrivateKeyTypes.join(', ')}`);
+    }
+};
 const getConfig = {
     command: 'get <key> [keys...]',
     describe: 'Get config value(s) of the given key(s) in Logto database',
@@ -103,9 +111,15 @@ const rotateConfig = {
         describe: 'The tenant to operate',
         type: 'string',
         default: defaultTenantId,
+    })
+        .option('type', {
+        describe: `The key type for ${LogtoOidcConfigKey.PrivateKeys}, one of ${validPrivateKeyTypes.join(', ')}`,
+        type: 'string',
+        default: 'ec',
     }),
-    handler: async ({ key, tenantId }) => {
+    handler: async ({ key, tenantId, type }) => {
         validateRotateKey(key);
+        validatePrivateKeyType(type);
         const pool = await createPoolFromConfig();
         const { rows } = await getRowsByKeys(pool, tenantId, [key]);
         if (!rows[0]) {
@@ -117,7 +131,7 @@ const rotateConfig = {
             // No need for default. It's already exhaustive
             switch (key) {
                 case LogtoOidcConfigKey.PrivateKeys: {
-                    return [await generateOidcPrivateKey(), ...original];
+                    return [await generateOidcPrivateKey(type), ...original];
                 }
                 case LogtoOidcConfigKey.CookieKeys: {
                     return [generateOidcCookieKey(), ...original];

package/lib/commands/database/seed/cloud.d.ts

@@ -8,3 +8,11 @@ import type { CommonQueryMethods } from 'slonik';
  * For why it is necessary, see the redirect lifecycle of cloud Admin Console.
  */
 export declare const appendAdminConsoleRedirectUris: (pool: CommonQueryMethods) => Promise<void>;
+/**
+ * Create Cloud Service M2M application for the tenant.
+ *
+ * This is a built-in M2M application for the tenant to communicate with the cloud service.
+ * - default
+ * - admin
+ */
+export declare const seedTenantCloudServiceApplication: (pool: CommonQueryMethods, tenantId: string) => Promise<void>;

package/lib/commands/database/seed/cloud.js

@@ -1,7 +1,8 @@
-import { adminConsoleApplicationId, adminTenantId, defaultTenantId } from '@logto/schemas';
+import { adminConsoleApplicationId, adminTenantId, defaultTenantId, createTenantMachineToMachineApplication, createAdminTenantApplicationRole, createCloudConnectionConfig, AdminTenantRole, } from '@logto/schemas';
 import { GlobalValues } from '@logto/shared';
 import { appendPath } from '@silverhand/essentials';
 import { sql } from 'slonik';
+import { insertInto } from '../../../database.js';
 import { consoleLog } from '../../../utils.js';
 /**
  * Append Redirect URIs for the default tenant callback in cloud Admin Console.
@@ -32,3 +33,25 @@ export const appendAdminConsoleRedirectUris = async (pool) => {
   `);
     consoleLog.succeed('Appended initial Redirect URIs to Admin Console:', redirectUris.map(String));
 };
+/**
+ * Create Cloud Service M2M application for the tenant.
+ *
+ * This is a built-in M2M application for the tenant to communicate with the cloud service.
+ * - default
+ * - admin
+ */
+export const seedTenantCloudServiceApplication = async (pool, tenantId) => {
+    // Create Cloud Service M2M application
+    const cloudServiceApplication = createTenantMachineToMachineApplication(tenantId);
+    await pool.query(insertInto(cloudServiceApplication, 'applications'));
+    // Assign tenantApplicationRole to Cloud Service M2M application
+    const { id: tenantApplicationRoleId } = await pool.one(sql `
+    select id from roles
+    where name = ${AdminTenantRole.TenantApplication}
+    and tenant_id = ${adminTenantId}
+  `);
+    await pool.query(insertInto(createAdminTenantApplicationRole(cloudServiceApplication.id, tenantApplicationRoleId), 'applications_roles'));
+    // Create Cloud Service M2M application logto_config
+    await pool.query(insertInto(createCloudConnectionConfig(tenantId, cloudServiceApplication.id, cloudServiceApplication.secret), 'logto_configs'));
+    consoleLog.succeed('Cloud Service Application successfully created for:', tenantId);
+};

package/lib/commands/database/seed/tables.js

@@ -1,6 +1,6 @@
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { createDefaultAdminConsoleConfig, defaultTenantId, adminTenantId, defaultManagementApi, createAdminDataInAdminTenant, createMeApiInAdminTenant, createDefaultSignInExperience, createAdminTenantSignInExperience, createDefaultAdminConsoleApplication, createCloudApi, createTenantApplicationRole, createTenantMachineToMachineApplication, createAdminTenantApplicationRole, CloudScope, } from '@logto/schemas';
+import { createDefaultAdminConsoleConfig, defaultTenantId, adminTenantId, defaultManagementApi, createAdminDataInAdminTenant, createMeApiInAdminTenant, createDefaultSignInExperience, createAdminTenantSignInExperience, createDefaultAdminConsoleApplication, createCloudApi, createTenantApplicationRole, CloudScope, } from '@logto/schemas';
 import { Tenants } from '@logto/schemas/models';
 import { sql } from 'slonik';
 import { raw } from 'slonik-sql-tag-raw';
@@ -8,7 +8,7 @@ import { insertInto } from '../../../database.js';
 import { getDatabaseName } from '../../../queries/database.js';
 import { updateDatabaseTimestamp } from '../../../queries/system.js';
 import { consoleLog, getPathInModule } from '../../../utils.js';
-import { appendAdminConsoleRedirectUris } from './cloud.js';
+import { appendAdminConsoleRedirectUris, seedTenantCloudServiceApplication } from './cloud.js';
 import { seedOidcConfigs } from './oidc-config.js';
 import { assignScopesToRole, createTenant, seedAdminData } from './tenant.js';
 const getExplicitOrder = (query) => {
@@ -82,22 +82,21 @@ export const seedTables = async (connection, latestTimestamp, isCloud) => {
     await seedAdminData(connection, adminAdminData);
     await seedAdminData(connection, createMeApiInAdminTenant());
     const [cloudData, ...cloudAdditionalScopes] = createCloudApi();
-    const applicationRole = createTenantApplicationRole();
     await seedAdminData(connection, cloudData, ...cloudAdditionalScopes);
+    // Create tenant application role
+    const applicationRole = createTenantApplicationRole();
     await connection.query(insertInto(applicationRole, 'roles'));
     await assignScopesToRole(connection, adminTenantId, applicationRole.id, ...cloudAdditionalScopes
         .filter(({ name }) => name === CloudScope.SendSms || name === CloudScope.SendEmail)
         .map(({ id }) => id));
-    // Add M2M app for default tenant
-    const defaultTenantApplication = createTenantMachineToMachineApplication(defaultTenantId);
-    await connection.query(insertInto(defaultTenantApplication, 'applications'));
-    await connection.query(insertInto(createAdminTenantApplicationRole(defaultTenantApplication.id, applicationRole.id), 'applications_roles'));
     // Assign all cloud API scopes to role `admin:admin`
     await assignScopesToRole(connection, adminTenantId, adminAdminData.role.id, ...cloudAdditionalScopes.map(({ id }) => id));
+    // FIXME: @wangsijie should not create tenant Cloud Service application in the OSS DB.
+    await seedTenantCloudServiceApplication(connection, defaultTenantId);
     await Promise.all([
         connection.query(insertInto(createDefaultAdminConsoleConfig(defaultTenantId), 'logto_configs')),
-        connection.query(insertInto(createDefaultSignInExperience(defaultTenantId, isCloud), 'sign_in_experiences')),
         connection.query(insertInto(createDefaultAdminConsoleConfig(adminTenantId), 'logto_configs')),
+        connection.query(insertInto(createDefaultSignInExperience(defaultTenantId, isCloud), 'sign_in_experiences')),
         connection.query(insertInto(createAdminTenantSignInExperience(), 'sign_in_experiences')),
         connection.query(insertInto(createDefaultAdminConsoleApplication(), 'applications')),
         updateDatabaseTimestamp(connection, latestTimestamp),
@@ -105,5 +104,8 @@ export const seedTables = async (connection, latestTimestamp, isCloud) => {
     consoleLog.succeed('Seed data');
 };
 export const seedCloud = async (connection) => {
-    await appendAdminConsoleRedirectUris(connection);
+    await Promise.all([
+        appendAdminConsoleRedirectUris(connection),
+        seedTenantCloudServiceApplication(connection, adminTenantId),
+    ]);
 };

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

@@ -1,2 +1,6 @@
-export declare const generateOidcPrivateKey: (type?: 'rsa' | 'ec') => Promise<string>;
+export declare enum PrivateKeyType {
+    RSA = "rsa",
+    EC = "ec"
+}
+export declare const generateOidcPrivateKey: (type?: PrivateKeyType) => Promise<string>;
 export declare const generateOidcCookieKey: () => string;

package/lib/commands/database/utils.js

@@ -1,8 +1,13 @@
 import { generateKeyPair } from 'node:crypto';
 import { promisify } from 'node:util';
 import { generateStandardId } from '@logto/shared';
-export const generateOidcPrivateKey = async (type = 'ec') => {
-    if (type === 'rsa') {
+export var PrivateKeyType;
+(function (PrivateKeyType) {
+    PrivateKeyType["RSA"] = "rsa";
+    PrivateKeyType["EC"] = "ec";
+})(PrivateKeyType || (PrivateKeyType = {}));
+export const generateOidcPrivateKey = async (type = PrivateKeyType.EC) => {
+    if (type === PrivateKeyType.RSA) {
         const { privateKey } = await promisify(generateKeyPair)('rsa', {
             modulusLength: 4096,
             publicKeyEncoding: {
@@ -17,7 +22,7 @@ export const generateOidcPrivateKey = async (type = 'ec') => {
         return privateKey;
     }
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (type === 'ec') {
+    if (type === PrivateKeyType.EC) {
         const { privateKey } = await promisify(generateKeyPair)('ec', {
             // https://security.stackexchange.com/questions/78621/which-elliptic-curve-should-i-use
             namedCurve: 'secp384r1',

package/lib/commands/install/utils.js

@@ -61,7 +61,7 @@ export const validateDatabase = async () => {
             const pgOutput = safeExecSync('postgres --version') ?? '';
             // Filter out all brackets in the output since Homebrew will append `(Homebrew)`.
             const pgArray = pgOutput.split(' ').filter((value) => !value.startsWith('('));
-            const pgCurrent = semver.coerce(pgArray[pgArray.length - 1]);
+            const pgCurrent = semver.coerce(pgArray.at(-1));
             return !pgCurrent || pgCurrent.compare(pgRequired) < 0;
         },
     });

package/lib/commands/translate/index.js

@@ -1,6 +1,7 @@
 import { noop } from '@silverhand/essentials';
 import create from './create.js';
 import listTags from './list-tags.js';
+import syncKeys from './sync-keys/index.js';
 import sync from './sync.js';
 const translate = {
     command: ['translate', 't'],
@@ -14,6 +15,7 @@ const translate = {
         .command(create)
         .command(listTags)
         .command(sync)
+        .command(syncKeys)
         .demandCommand(1),
     handler: noop,
 };

package/lib/commands/translate/sync-keys/index.d.ts

@@ -0,0 +1,11 @@
+import { type CommandModule } from 'yargs';
+declare const syncKeys: CommandModule<{
+    path?: string;
+}, {
+    path?: string;
+    baseline: string;
+    target: string;
+    skipLint?: boolean;
+    package: string;
+}>;
+export default syncKeys;

package/lib/commands/translate/sync-keys/index.js

@@ -0,0 +1,84 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { isLanguageTag } from '@logto/language-kit';
+import ora from 'ora';
+import { consoleLog } from '../../../utils.js';
+import { inquireInstancePath } from '../../connector/utils.js';
+import { praseLocaleFiles, syncPhraseKeysAndFileStructure } from './utils.js';
+const execPromise = promisify(execFile);
+const syncKeys = {
+    command: ['sync-keys', 'sk'],
+    describe: [
+        'Sync nested object keys and the file structure from baseline to target.',
+        'If a key is missing in the target, it will be added with a comment to indicate that the phrase is untranslated;',
+        'If a key is missing in the baseline, it will be removed from the target;',
+        'If a key exists in both the baseline and the target, the value of the target will be used.',
+    ].join(' '),
+    builder: (yargs) => yargs
+        .option('baseline', {
+        alias: 'b',
+        type: 'string',
+        describe: 'The baseline language tag',
+        default: 'en',
+    })
+        .option('package', {
+        alias: 'pkg',
+        type: 'string',
+        describe: 'The package name of the phrases, one of `phrases` or `phrases-ui`',
+        default: 'phrases',
+    })
+        .option('target', {
+        alias: 't',
+        type: 'string',
+        describe: 'The target language tag, or `all` to sync all languages',
+    })
+        .option('skip-lint', {
+        alias: 's',
+        type: 'boolean',
+        describe: 'Skip running `eslint --fix` for locales after syncing',
+    })
+        .demandOption(['baseline', 'target']),
+    handler: async ({ path: inputPath, baseline: baselineTag, target: targetTag, skipLint, package: packageName, }) => {
+        if (!isLanguageTag(baselineTag)) {
+            consoleLog.fatal('Invalid baseline language tag');
+        }
+        if (targetTag !== 'all' && !isLanguageTag(targetTag)) {
+            consoleLog.fatal('Invalid target language tag');
+        }
+        if (baselineTag === targetTag) {
+            consoleLog.fatal('Baseline and target cannot be the same');
+        }
+        if (packageName !== 'phrases' && packageName !== 'phrases-ui') {
+            consoleLog.fatal('Invalid package name, expected `phrases` or `phrases-ui`');
+        }
+        const instancePath = await inquireInstancePath(inputPath);
+        const phrasesPath = path.join(instancePath, 'packages', packageName);
+        const localesPath = path.join(phrasesPath, 'src/locales');
+        const entrypoint = path.join(localesPath, baselineTag.toLowerCase(), 'index.ts');
+        const baseline = praseLocaleFiles(entrypoint);
+        const targetLocales = targetTag === 'all' ? fs.readdirSync(localesPath) : [targetTag.toLowerCase()];
+        /* eslint-disable no-await-in-loop */
+        for (const target of targetLocales) {
+            if (target === baselineTag) {
+                continue;
+            }
+            const spinner = ora({
+                text: `Syncing object keys and file structure from ${baselineTag} to ${target}`,
+            }).start();
+            const targetDirectory = path.join(localesPath, target);
+            await syncPhraseKeysAndFileStructure(baseline, target, targetDirectory);
+            spinner.succeed(`Synced object keys and file structure from ${baselineTag} to ${target}`);
+        }
+        /* eslint-enable no-await-in-loop */
+        if (!skipLint) {
+            const spinner = ora({
+                text: 'Running `eslint --fix` for locales',
+            }).start();
+            await execPromise('pnpm', ['eslint', '--ext', '.ts', path.relative(phrasesPath, localesPath), '--fix'], { cwd: phrasesPath });
+            spinner.succeed('Ran `eslint --fix` for locales');
+        }
+    },
+};
+export default syncKeys;

package/lib/commands/translate/sync-keys/utils.d.ts

@@ -0,0 +1,56 @@
+type FileStructure = {
+    [key: string]: {
+        filePath?: string;
+        structure: FileStructure;
+    };
+};
+type NestedPhraseObject = {
+    [key: string]: string | NestedPhraseObject;
+};
+type ParsedTuple = readonly [NestedPhraseObject, FileStructure];
+/**
+ * Given a entrypoint file path of a language, parse the nested object of
+ * phrases and the file structure.
+ *
+ * @example
+ * Given the following file:
+ *
+ * ```ts
+ * import errors from './errors/index.js';
+ *
+ * const translation = {
+ *   page_title: 'Anwendungen',
+ *   errors,
+ * };
+ * ```
+ *
+ * The returned object will be:
+ *
+ * ```ts
+ * {
+ *   page_title: 'Anwendungen',
+ *   errors: {
+ *     page_not_found: 'Seite nicht gefunden',
+ *   },
+ * }
+ * ```
+ *
+ * And the file structure will be:
+ *
+ * ```ts
+ * {
+ *   errors: {
+ *     filePath: './errors/index.js',
+ *     structure: {},
+ *   },
+ * }
+ * ```
+ *
+ * @param filePath The entrypoint file path of a language
+ *
+ * @returns A tuple of the nested object of phrases and the file structure
+ *
+ */
+export declare const praseLocaleFiles: (filePath: string) => ParsedTuple;
+export declare const syncPhraseKeysAndFileStructure: (baseline: ParsedTuple, targetLocale: string, targetDirectory: string) => Promise<void>;
+export {};

package/lib/commands/translate/sync-keys/utils.js

@@ -0,0 +1,249 @@
+import { readFileSync, existsSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { tryThat } from '@silverhand/essentials';
+import ts from 'typescript';
+import { consoleLog } from '../../../utils.js';
+/**
+ * Given a entrypoint file path of a language, parse the nested object of
+ * phrases and the file structure.
+ *
+ * @example
+ * Given the following file:
+ *
+ * ```ts
+ * import errors from './errors/index.js';
+ *
+ * const translation = {
+ *   page_title: 'Anwendungen',
+ *   errors,
+ * };
+ * ```
+ *
+ * The returned object will be:
+ *
+ * ```ts
+ * {
+ *   page_title: 'Anwendungen',
+ *   errors: {
+ *     page_not_found: 'Seite nicht gefunden',
+ *   },
+ * }
+ * ```
+ *
+ * And the file structure will be:
+ *
+ * ```ts
+ * {
+ *   errors: {
+ *     filePath: './errors/index.js',
+ *     structure: {},
+ *   },
+ * }
+ * ```
+ *
+ * @param filePath The entrypoint file path of a language
+ *
+ * @returns A tuple of the nested object of phrases and the file structure
+ *
+ */
+export const praseLocaleFiles = (filePath) => {
+    const content = readFileSync(filePath, 'utf8');
+    const ast = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const importIdentifierPath = new Map();
+    const traverseNode = (node, nestedObject, fileStructure) => {
+        /**
+         * Handle property assignment in object literal expression:
+         *
+         * - Shorthand property assignments (e.g. `{ errors }`) are treated as import
+         * - Property assignments will be categorized per its initializer:
+         *   - Object literal expressions (e.g. `{ errors: { page_not_found: 'Page not found' } }`)
+         *     will be treated as nested object
+         *   - String literals (e.g. `{ page_title: 'Applications' }`) or no substitution template
+         *     literals (e.g. `{ page_title: `Applications` }`) will be treated as string
+         *   - Others are not supported, and will exit with error
+         */
+        const handleProperty = (property) => {
+            // Treat shorthand property assignment as import
+            if (ts.isShorthandPropertyAssignment(property)) {
+                const key = property.name.getText();
+                const importPath = importIdentifierPath.get(key);
+                if (!importPath) {
+                    consoleLog.fatal(`Cannot find import path for ${key} in ${filePath}`);
+                }
+                const resolvedPath = path.resolve(path.dirname(filePath), importPath);
+                // Recursively parse the nested object from the imported file
+                const [phrases, structure] = praseLocaleFiles(resolvedPath);
+                // eslint-disable-next-line @silverhand/fp/no-mutation
+                nestedObject[key] = phrases;
+                // eslint-disable-next-line @silverhand/fp/no-mutation
+                fileStructure[key] = {
+                    filePath: importPath,
+                    structure,
+                };
+            }
+            if (ts.isPropertyAssignment(property)) {
+                const key = property.name.getText();
+                // Nested object, recursively parse it
+                if (ts.isObjectLiteralExpression(property.initializer)) {
+                    const [phrases, structure] = traverseNode(property.initializer, {}, {});
+                    // eslint-disable-next-line @silverhand/fp/no-mutation
+                    nestedObject[key] = phrases;
+                    // eslint-disable-next-line @silverhand/fp/no-mutation
+                    fileStructure[key] = { structure };
+                }
+                else if (ts.isStringLiteral(property.initializer) ||
+                    ts.isNoSubstitutionTemplateLiteral(property.initializer)) {
+                    const value = property.initializer.getText();
+                    // eslint-disable-next-line @silverhand/fp/no-mutation
+                    nestedObject[key] = value;
+                }
+                else {
+                    consoleLog.fatal('Unsupported property:', property);
+                }
+            }
+        };
+        if (ts.isImportDeclaration(node)) {
+            const importPath = node.moduleSpecifier.getText().slice(1, -1).replace('.js', '.ts');
+            const importIdentifier = node.importClause?.getText();
+            // Assuming only default import is used
+            if (importIdentifier) {
+                importIdentifierPath.set(importIdentifier, importPath);
+            }
+        }
+        else if (ts.isObjectLiteralExpression(node)) {
+            for (const property of node.properties) {
+                handleProperty(property);
+            }
+        }
+        else {
+            node.forEachChild((child) => {
+                traverseNode(child, nestedObject, fileStructure);
+            });
+        }
+        return [nestedObject, fileStructure];
+    };
+    return traverseNode(ast, {}, {});
+};
+const getIdentifier = (filePath) => {
+    const filename = path.basename(filePath, '.ts');
+    return (filename === 'index' ? path.basename(path.dirname(filePath)) : filename).replaceAll('-', '_');
+};
+/** Traverse the file structure and return an array of imports in the current file. */
+const getCurrentFileImports = (fileStructure) => {
+    const imports = new Set();
+    for (const [key, value] of Object.entries(fileStructure)) {
+        // If the key has a file path, treat it as an import and stop traversing
+        // since it's pointing to another file
+        if (value.filePath) {
+            imports.add([key, value.filePath]);
+        }
+        // Otherwise, recursively traverse the nested object
+        else {
+            for (const importEntry of getCurrentFileImports(value.structure)) {
+                imports.add(importEntry);
+            }
+        }
+    }
+    return [...imports];
+};
+/**
+ * Recursively traverse the nested object of phrases and the file structure of
+ * the baseline language, and generate the target language directory with the
+ * same file structure.
+ *
+ * Values of the nested object will be replaced with the values of the target
+ * language if the key exists; otherwise, the value of the baseline language
+ * will be used.
+ *
+ * @param baseline The baseline language tuple
+ * @param targetObject The target language nested object
+ * @param targetFilePath The target language entrypoint file path
+ * @param isRoot Whether the target file is the root entrypoint
+ */
+/* eslint-disable no-await-in-loop */
+const traverseNode = async (baseline, targetObject, targetFilePath, isRoot = false) => {
+    const [, baselineStructure] = baseline;
+    const targetDirectory = path.dirname(targetFilePath);
+    await fs.mkdir(targetDirectory, { recursive: true });
+    await fs.writeFile(targetFilePath, '', { flag: 'w+' });
+    if (isRoot) {
+        await fs.appendFile(targetFilePath, "import type { LocalePhrase } from '../../types.js';\n\n");
+    }
+    // Write imports first
+    const baselineEntries = getCurrentFileImports(baselineStructure);
+    for (const [key, value] of baselineEntries
+        .slice()
+        .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))) {
+        const importPath = path.join(targetDirectory, value);
+        await fs.appendFile(targetFilePath, `import ${key} from './${path
+            .relative(targetDirectory, importPath)
+            .replace('.ts', '.js')}';\n`);
+    }
+    // Add a newline between imports and the object
+    if (baselineEntries.length > 0) {
+        await fs.appendFile(targetFilePath, '\n');
+    }
+    // Write the object
+    const identifier = getIdentifier(targetFilePath);
+    await fs.appendFile(targetFilePath, `const ${identifier} = {\n`);
+    // Recursively traverse the nested object of phrases and the file structure
+    // of the baseline language
+    const traverseObject = async (baseline, targetObject, tabSize) => {
+        const [baselineObject, baselineStructure] = baseline;
+        for (const [key, value] of Object.entries(baselineObject)) {
+            const existingValue = targetObject[key];
+            if (typeof value === 'string') {
+                // If the key exists in the target language and the value is a string, use
+                // the value of the target language; otherwise, use the value of the
+                // baseline language and add a comment to indicate that the phrase is
+                // untranslated to help identify missing translations.
+                await (typeof existingValue === 'string'
+                    ? fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: ${existingValue},\n`)
+                    : fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: ${value}, // UNTRANSLATED\n`));
+            }
+            // Not a string, treat it as a nested object or an import
+            else {
+                const keyStructure = baselineStructure[key];
+                // If the key has a file structure, treat it as an import
+                if (keyStructure?.filePath) {
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key},\n`);
+                    await traverseNode([value, keyStructure.structure], typeof existingValue === 'object' ? existingValue : {}, path.join(targetDirectory, keyStructure.filePath));
+                }
+                // Otherwise, treat it as a nested object.
+                else {
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: {\n`);
+                    await traverseObject([value, keyStructure?.structure ?? {}], typeof existingValue === 'object' ? existingValue : {}, tabSize + 2);
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}},\n`);
+                }
+            }
+        }
+    };
+    await traverseObject(baseline, targetObject, 2);
+    await (isRoot
+        ? fs.appendFile(targetFilePath, '} satisfies LocalePhrase;\n\n')
+        : fs.appendFile(targetFilePath, '};\n\n'));
+    await fs.appendFile(targetFilePath, `export default Object.freeze(${identifier});\n`);
+};
+/* eslint-enable no-await-in-loop */
+export const syncPhraseKeysAndFileStructure = async (baseline, targetLocale, targetDirectory) => {
+    const targetEntrypoint = path.join(targetDirectory, 'index.ts');
+    const isTargetLocaleExist = existsSync(targetEntrypoint);
+    const targetObject = isTargetLocaleExist ? praseLocaleFiles(targetEntrypoint)[0] : {};
+    const backupDirectory = targetDirectory + '.bak';
+    if (isTargetLocaleExist) {
+        await fs.rename(targetDirectory, backupDirectory);
+    }
+    else {
+        consoleLog.warn(`Cannot find ${targetLocale} entrypoint, creating one`);
+    }
+    await tryThat(traverseNode(baseline, targetObject, path.join(targetDirectory, 'index.ts'), true), (error) => {
+        consoleLog.plain();
+        consoleLog.error(error);
+        consoleLog.plain();
+        consoleLog.fatal(`Failed to sync keys for ${targetLocale}, the backup is at ${backupDirectory} for recovery`);
+    });
+    if (isTargetLocaleExist) {
+        await fs.rm(backupDirectory, { recursive: true });
+    }
+};

package/lib/connector/utils.d.ts

@@ -1,10 +1,10 @@
-import type { AllConnector, BaseConnector, ConnectorMetadata, GetConnectorConfig } from '@logto/connector-kit';
+import type { AllConnector, BaseConnector, ConnectorMetadata, GetConnectorConfig, GetCloudServiceClient } from '@logto/connector-kit';
 import { ConnectorType } from '@logto/connector-kit';
 import type { ConnectorFactory } from './types.js';
 export declare function validateConnectorModule(connector: Partial<BaseConnector<ConnectorType>>): asserts connector is BaseConnector<ConnectorType>;
-export declare const readUrl: (url: string, baseUrl: string, type: 'text' | 'svg') => Promise<string>;
+export declare const readUrl: (url: string, baseUrl: string, type: 'text' | 'image') => Promise<string>;
 export declare const parseMetadata: (metadata: AllConnector['metadata'], packagePath: string) => Promise<AllConnector['metadata']>;
-export declare const buildRawConnector: <T extends AllConnector = AllConnector>(connectorFactory: ConnectorFactory<T>, getConnectorConfig?: GetConnectorConfig) => Promise<{
+export declare const buildRawConnector: <T extends AllConnector = AllConnector>(connectorFactory: ConnectorFactory<T>, getConnectorConfig?: GetConnectorConfig, getCloudServiceClient?: GetCloudServiceClient) => Promise<{
     rawConnector: T;
     rawMetadata: ConnectorMetadata;
 }>;

package/lib/connector/utils.js

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { ConnectorError, ConnectorErrorCodes, ConnectorType } from '@logto/connector-kit';
+import { consoleLog } from '../utils.js';
 import { notImplemented } from './consts.js';
 export function validateConnectorModule(connector) {
     if (!connector.metadata) {
@@ -14,6 +15,11 @@ export function validateConnectorModule(connector) {
         throw new ConnectorError(ConnectorErrorCodes.UnexpectedType);
     }
 }
+const supportedImageTypes = Object.freeze({
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+});
+const isSupportedImageType = (extension) => Object.keys(supportedImageTypes).includes(extension);
 export const readUrl = async (url, baseUrl, type) => {
     if (!url) {
         return url;
@@ -24,25 +30,32 @@ export const readUrl = async (url, baseUrl, type) => {
     if (!existsSync(path.join(baseUrl, url))) {
         return url;
     }
-    if (type === 'svg') {
-        const data = await readFile(path.join(baseUrl, url));
-        return `data:image/svg+xml;base64,${data.toString('base64')}`;
+    if (type === 'image') {
+        const filePath = path.join(baseUrl, url);
+        const extension = path.extname(filePath);
+        if (!isSupportedImageType(extension)) {
+            consoleLog.warn(`[readUrl] unexpected image type: ${filePath}, only support ".svg" and ".png". Falling back to empty string.`);
+            return '';
+        }
+        const data = await readFile(filePath);
+        return `data:${supportedImageTypes[extension]};base64,${data.toString('base64')}`;
     }
     return readFile(path.join(baseUrl, url), 'utf8');
 };
 export const parseMetadata = async (metadata, packagePath) => {
     return {
         ...metadata,
-        logo: await readUrl(metadata.logo, packagePath, 'svg'),
-        logoDark: metadata.logoDark && (await readUrl(metadata.logoDark, packagePath, 'svg')),
+        logo: await readUrl(metadata.logo, packagePath, 'image'),
+        logoDark: metadata.logoDark && (await readUrl(metadata.logoDark, packagePath, 'image')),
         readme: await readUrl(metadata.readme, packagePath, 'text'),
         configTemplate: metadata.configTemplate && (await readUrl(metadata.configTemplate, packagePath, 'text')),
     };
 };
-export const buildRawConnector = async (connectorFactory, getConnectorConfig) => {
+export const buildRawConnector = async (connectorFactory, getConnectorConfig, getCloudServiceClient) => {
     const { createConnector, path: packagePath } = connectorFactory;
     const rawConnector = await createConnector({
         getConfig: getConnectorConfig ?? notImplemented,
+        getCloudServiceClient,
     });
     validateConnectorModule(rawConnector);
     const rawMetadata = await parseMetadata(rawConnector.metadata, packagePath);

package/lib/package-json.d.ts

@@ -66,6 +66,7 @@ export declare const packageJson: {
         "slonik-interceptor-preset": string;
         "slonik-sql-tag-raw": string;
         tar: string;
+        typescript: string;
         yargs: string;
         zod: string;
     };
@@ -84,7 +85,6 @@ export declare const packageJson: {
         "lint-staged": string;
         prettier: string;
         sinon: string;
-        typescript: string;
     };
     eslintConfig: {
         extends: string;

package/lib/package-json.js

@@ -1,6 +1,6 @@
 export const packageJson = {
     "name": "@logto/cli",
-    "version": "1.6.0",
+    "version": "1.8.0",
     "description": "Logto CLI.",
     "author": "Silverhand Inc. <contact@silverhand.io>",
     "homepage": "https://github.com/logto-io/logto#readme",
@@ -48,7 +48,7 @@ export const packageJson = {
         "@logto/language-kit": "workspace:^1.0.0",
         "@logto/phrases": "workspace:^1.4.1",
         "@logto/phrases-ui": "workspace:^1.2.0",
-        "@logto/schemas": "workspace:1.6.0",
+        "@logto/schemas": "workspace:1.8.0",
         "@logto/shared": "workspace:^2.0.0",
         "@silverhand/essentials": "^2.5.0",
         "chalk": "^5.0.0",
@@ -61,7 +61,7 @@ export const packageJson = {
         "ora": "^6.1.2",
         "p-limit": "^4.0.0",
         "p-queue": "^7.3.4",
-        "p-retry": "^5.1.2",
+        "p-retry": "^6.0.0",
         "pg-protocol": "^1.6.0",
         "roarr": "^7.11.0",
         "semver": "^7.3.8",
@@ -69,12 +69,13 @@ export const packageJson = {
         "slonik-interceptor-preset": "^1.2.10",
         "slonik-sql-tag-raw": "^1.1.4",
         "tar": "^6.1.11",
+        "typescript": "^5.0.0",
         "yargs": "^17.6.0",
         "zod": "^3.20.2"
     },
     "devDependencies": {
-        "@silverhand/eslint-config": "3.0.1",
-        "@silverhand/ts-config": "3.0.0",
+        "@silverhand/eslint-config": "4.0.1",
+        "@silverhand/ts-config": "4.0.0",
         "@types/inquirer": "^9.0.0",
         "@types/jest": "^29.4.0",
         "@types/node": "^18.11.18",
@@ -82,12 +83,11 @@ export const packageJson = {
         "@types/sinon": "^10.0.13",
         "@types/tar": "^6.1.2",
         "@types/yargs": "^17.0.13",
-        "eslint": "^8.34.0",
+        "eslint": "^8.44.0",
         "jest": "^29.5.0",
-        "lint-staged": "^13.0.0",
-        "prettier": "^2.8.2",
-        "sinon": "^15.0.0",
-        "typescript": "^5.0.0"
+        "lint-staged": "^14.0.0",
+        "prettier": "^3.0.0",
+        "sinon": "^15.0.0"
     },
     "eslintConfig": {
         "extends": "@silverhand",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logto/cli",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "Logto CLI.",
   "author": "Silverhand Inc. <contact@silverhand.io>",
   "homepage": "https://github.com/logto-io/logto#readme",
@@ -33,7 +33,7 @@
     "@logto/language-kit": "^1.0.0",
     "@logto/phrases": "^1.4.1",
     "@logto/phrases-ui": "^1.2.0",
-    "@logto/schemas": "1.6.0",
+    "@logto/schemas": "1.8.0",
     "@logto/shared": "^2.0.0",
     "@silverhand/essentials": "^2.5.0",
     "chalk": "^5.0.0",
@@ -46,7 +46,7 @@
     "ora": "^6.1.2",
     "p-limit": "^4.0.0",
     "p-queue": "^7.3.4",
-    "p-retry": "^5.1.2",
+    "p-retry": "^6.0.0",
     "pg-protocol": "^1.6.0",
     "roarr": "^7.11.0",
     "semver": "^7.3.8",
@@ -54,12 +54,13 @@
     "slonik-interceptor-preset": "^1.2.10",
     "slonik-sql-tag-raw": "^1.1.4",
     "tar": "^6.1.11",
+    "typescript": "^5.0.0",
     "yargs": "^17.6.0",
     "zod": "^3.20.2"
   },
   "devDependencies": {
-    "@silverhand/eslint-config": "3.0.1",
-    "@silverhand/ts-config": "3.0.0",
+    "@silverhand/eslint-config": "4.0.1",
+    "@silverhand/ts-config": "4.0.0",
     "@types/inquirer": "^9.0.0",
     "@types/jest": "^29.4.0",
     "@types/node": "^18.11.18",
@@ -67,12 +68,11 @@
     "@types/sinon": "^10.0.13",
     "@types/tar": "^6.1.2",
     "@types/yargs": "^17.0.13",
-    "eslint": "^8.34.0",
+    "eslint": "^8.44.0",
     "jest": "^29.5.0",
-    "lint-staged": "^13.0.0",
-    "prettier": "^2.8.2",
-    "sinon": "^15.0.0",
-    "typescript": "^5.0.0"
+    "lint-staged": "^14.0.0",
+    "prettier": "^3.0.0",
+    "sinon": "^15.0.0"
   },
   "eslintConfig": {
     "extends": "@silverhand",