@logto/cli 1.11.0 → 1.13.0

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

@@ -1,8 +1,10 @@
 import type { DatabasePool } from 'slonik';
 import type { CommandModule } from 'yargs';
-export declare const seedByPool: (pool: DatabasePool, cloud?: boolean) => Promise<void>;
+export declare const seedByPool: (pool: DatabasePool, cloud?: boolean, test?: boolean) => Promise<void>;
 declare const seed: CommandModule<Record<string, unknown>, {
     swe?: boolean;
     cloud?: boolean;
+    test?: boolean;
+    'legacy-test-data'?: boolean;
 }>;
 export default seed;

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

@@ -3,8 +3,8 @@ import { doesConfigsTableExist } from '../../../queries/logto-config.js';
 import { consoleLog, oraPromise } from '../../../utils.js';
 import { getLatestAlterationTimestamp } from '../alteration/index.js';
 import { getAlterationDirectory } from '../alteration/utils.js';
-import { createTables, seedCloud, seedTables } from './tables.js';
-export const seedByPool = async (pool, cloud = false) => {
+import { createTables, seedCloud, seedTables, seedTest } from './tables.js';
+export const seedByPool = async (pool, cloud = false, test = false) => {
     await pool.transaction(async (connection) => {
         // Check alteration scripts available in order to insert correct timestamp
         const latestTimestamp = await getLatestAlterationTimestamp();
@@ -19,6 +19,14 @@ export const seedByPool = async (pool, cloud = false) => {
         if (cloud) {
             await seedCloud(connection);
         }
+        if (test) {
+            await seedTest(connection);
+        }
+    });
+};
+const seedLegacyTestData = async (pool) => {
+    return pool.transaction(async (connection) => {
+        await seedTest(connection, true);
     });
 };
 const seed = {
@@ -33,25 +41,44 @@ const seed = {
         .option('cloud', {
         describe: 'Seed additional cloud data',
         type: 'boolean',
-        hidden: true,
+    })
+        .option('test', {
+        describe: 'Seed additional test data',
+        type: 'boolean',
+    })
+        .option('legacy-test-data', {
+        describe: 'Seed test data only for legacy Logto versions (<=1.12.0), this option conflicts with others',
+        type: 'boolean',
     }),
-    handler: async ({ swe, cloud }) => {
+    handler: async ({ swe, cloud, test, legacyTestData }) => {
         const pool = await createPoolAndDatabaseIfNeeded();
+        if (legacyTestData) {
+            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+            if (swe || cloud || test) {
+                throw new Error('The `legacy-test-data` option conflicts with other options, please use it alone.');
+            }
+            await seedLegacyTestData(pool);
+            await pool.end();
+            return;
+        }
         if (swe && (await doesConfigsTableExist(pool))) {
             consoleLog.info('Seeding skipped');
             await pool.end();
             return;
         }
         try {
-            await seedByPool(pool, cloud);
+            await seedByPool(pool, cloud, test);
         }
         catch (error) {
             consoleLog.error(error);
             consoleLog.error('Error ocurred during seeding your database.\n\n' +
                 '  Nothing has changed since the seeding process was in a transaction.\n' +
                 '  Try to fix the error and seed again.');
+            throw error;
+        }
+        finally {
+            await pool.end();
         }
-        await pool.end();
     },
 };
 export default seed;

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

@@ -2,3 +2,12 @@ import type { DatabaseTransactionConnection } from 'slonik';
 export declare const createTables: (connection: DatabaseTransactionConnection) => Promise<void>;
 export declare const seedTables: (connection: DatabaseTransactionConnection, latestTimestamp: number, isCloud: boolean) => Promise<void>;
 export declare const seedCloud: (connection: DatabaseTransactionConnection) => Promise<void>;
+/**
+ * Seed additional test data for integration or alteration tests.
+ *
+ * It will create two users to the admin tenant (`test-1` and `test-2`), and do the following:
+ *
+ * - `test-1` will be assigned the management roles for both `default` and `admin` tenant.
+ * - `test-2`  will be assigned the management role for `default` tenant.
+ */
+export declare const seedTest: (connection: DatabaseTransactionConnection, forLegacy?: boolean) => Promise<void>;

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

@@ -1,7 +1,9 @@
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { createDefaultAdminConsoleConfig, defaultTenantId, adminTenantId, defaultManagementApi, createAdminDataInAdminTenant, createMeApiInAdminTenant, createDefaultSignInExperience, createAdminTenantSignInExperience, createDefaultAdminConsoleApplication, createCloudApi, createTenantApplicationRole, CloudScope, } from '@logto/schemas';
+import { createDefaultAdminConsoleConfig, defaultTenantId, adminTenantId, defaultManagementApi, createAdminDataInAdminTenant, createMeApiInAdminTenant, createDefaultSignInExperience, createAdminTenantSignInExperience, createDefaultAdminConsoleApplication, createCloudApi, createTenantApplicationRole, CloudScope, Roles, UsersRoles, LogtoConfigs, SignInExperiences, Applications, OrganizationUserRelations, getTenantOrganizationId, Users, OrganizationRoleUserRelations, TenantRole, } from '@logto/schemas';
+import { getTenantRole } from '@logto/schemas';
 import { Tenants } from '@logto/schemas/models';
+import { convertToIdentifiers, generateStandardId } from '@logto/shared';
 import { sql } from 'slonik';
 import { raw } from 'slonik-sql-tag-raw';
 import { insertInto } from '../../../database.js';
@@ -10,7 +12,8 @@ import { updateDatabaseTimestamp } from '../../../queries/system.js';
 import { consoleLog, getPathInModule } from '../../../utils.js';
 import { appendAdminConsoleRedirectUris, seedTenantCloudServiceApplication } from './cloud.js';
 import { seedOidcConfigs } from './oidc-config.js';
-import { assignScopesToRole, createTenant, seedAdminData } from './tenant.js';
+import { seedTenantOrganizations } from './tenant-organizations.js';
+import { assignScopesToRole, createTenant, seedAdminData, seedLegacyManagementApiUserRole, seedManagementApiProxyApplications, } from './tenant.js';
 const getExplicitOrder = (query) => {
     const matched = /\/\*\s*init_order\s*=\s*([\d.]+)\s*\*\//.exec(query)?.[1];
     return matched ? Number(matched) : undefined;
@@ -85,21 +88,21 @@ export const seedTables = async (connection, latestTimestamp, isCloud) => {
     await seedAdminData(connection, cloudData, ...cloudAdditionalScopes);
     // Create tenant application role
     const applicationRole = createTenantApplicationRole();
-    await connection.query(insertInto(applicationRole, 'roles'));
+    await connection.query(insertInto(applicationRole, Roles.table));
     await assignScopesToRole(connection, adminTenantId, applicationRole.id, ...cloudAdditionalScopes
         .filter(({ name }) => name === CloudScope.SendSms || name === CloudScope.SendEmail)
         .map(({ id }) => id));
-    // 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(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')),
+        seedLegacyManagementApiUserRole(connection),
+        seedTenantCloudServiceApplication(connection, defaultTenantId),
+        connection.query(insertInto(createDefaultAdminConsoleConfig(defaultTenantId), LogtoConfigs.table)),
+        connection.query(insertInto(createDefaultAdminConsoleConfig(adminTenantId), LogtoConfigs.table)),
+        connection.query(insertInto(createDefaultSignInExperience(defaultTenantId, isCloud), SignInExperiences.table)),
+        connection.query(insertInto(createAdminTenantSignInExperience(), SignInExperiences.table)),
+        connection.query(insertInto(createDefaultAdminConsoleApplication(), Applications.table)),
         updateDatabaseTimestamp(connection, latestTimestamp),
+        seedTenantOrganizations(connection),
+        seedManagementApiProxyApplications(connection),
     ]);
     consoleLog.succeed('Seed data');
 };
@@ -109,3 +112,61 @@ export const seedCloud = async (connection) => {
         seedTenantCloudServiceApplication(connection, adminTenantId),
     ]);
 };
+/**
+ * Seed additional test data for integration or alteration tests.
+ *
+ * It will create two users to the admin tenant (`test-1` and `test-2`), and do the following:
+ *
+ * - `test-1` will be assigned the management roles for both `default` and `admin` tenant.
+ * - `test-2`  will be assigned the management role for `default` tenant.
+ */
+export const seedTest = async (connection, forLegacy = false) => {
+    const roles = convertToIdentifiers(Roles);
+    const getManagementRole = async (tenantId) => connection.one(sql `
+      select ${roles.fields.id}
+      from ${roles.table}
+      where ${roles.fields.tenantId} = ${adminTenantId}
+      and ${roles.fields.name} = ${`${tenantId}:admin`}
+    `);
+    const assignRoleToUser = async (userId, roleId) => connection.query(insertInto({ id: generateStandardId(), userId, roleId, tenantId: adminTenantId }, UsersRoles.table));
+    const userIds = Object.freeze(['test-1', 'test-2']);
+    await Promise.all([
+        connection.query(insertInto({ id: userIds[0], username: 'test1', tenantId: adminTenantId }, Users.table)),
+        connection.query(insertInto({ id: userIds[1], username: 'test2', tenantId: adminTenantId }, Users.table)),
+    ]);
+    if (forLegacy) {
+        const adminTenantRole = await getManagementRole(adminTenantId);
+        await assignRoleToUser(userIds[0], adminTenantRole.id);
+    }
+    consoleLog.succeed('Created test users');
+    // The only legacy user role for Management API. Used in OSS only.
+    const defaultTenantRole = await getManagementRole(defaultTenantId);
+    await Promise.all([
+        assignRoleToUser(userIds[0], defaultTenantRole.id),
+        assignRoleToUser(userIds[1], defaultTenantRole.id),
+    ]);
+    consoleLog.succeed('Assigned tenant management roles to the test users');
+    // This check is for older versions (<=v.12.0) that don't have tenant organization initialized.
+    if (forLegacy) {
+        consoleLog.warn('Tenant organization is not enabled in legacy Logto versions, skip seeding tenant organization data');
+        return;
+    }
+    const addOrganizationMembership = async (userId, tenantId) => connection.query(insertInto({ userId, organizationId: getTenantOrganizationId(tenantId), tenantId: adminTenantId }, OrganizationUserRelations.table));
+    await Promise.all([
+        addOrganizationMembership(userIds[0], adminTenantId),
+        addOrganizationMembership(userIds[0], defaultTenantId),
+        addOrganizationMembership(userIds[1], defaultTenantId),
+    ]);
+    const assignOrganizationRole = async (userId, tenantId, tenantRole) => connection.query(insertInto({
+        userId,
+        organizationRoleId: getTenantRole(tenantRole).id,
+        organizationId: getTenantOrganizationId(tenantId),
+        tenantId: adminTenantId,
+    }, OrganizationRoleUserRelations.table));
+    await Promise.all([
+        assignOrganizationRole(userIds[0], adminTenantId, TenantRole.Admin),
+        assignOrganizationRole(userIds[0], defaultTenantId, TenantRole.Admin),
+        assignOrganizationRole(userIds[1], defaultTenantId, TenantRole.Admin),
+    ]);
+    consoleLog.succeed('Assigned tenant organization membership and roles to the test users');
+};

package/lib/commands/database/seed/tenant-organizations.d.ts

@@ -0,0 +1,8 @@
+import type { DatabaseTransactionConnection } from 'slonik';
+/**
+ * Seed initial data in the admin tenant for tenant organizations (`default` and `admin`):
+ *
+ * - Organization roles and scopes for tenant management.
+ * - Create tenant organizations for the initial tenants (`default` and `admin`).
+ */
+export declare const seedTenantOrganizations: (connection: DatabaseTransactionConnection) => Promise<void>;

package/lib/commands/database/seed/tenant-organizations.js

@@ -0,0 +1,28 @@
+import { defaultTenantId, adminTenantId, OrganizationRoles, TenantRole, getTenantScope, OrganizationScopes, TenantScope, getTenantRole, OrganizationRoleScopeRelations, tenantRoleScopes, getTenantOrganizationCreateData, Organizations, } from '@logto/schemas';
+import { insertInto } from '../../../database.js';
+import { consoleLog } from '../../../utils.js';
+/**
+ * Seed initial data in the admin tenant for tenant organizations (`default` and `admin`):
+ *
+ * - Organization roles and scopes for tenant management.
+ * - Create tenant organizations for the initial tenants (`default` and `admin`).
+ */
+export const seedTenantOrganizations = async (connection) => {
+    const tenantIds = [defaultTenantId, adminTenantId];
+    // Init organization template
+    await Promise.all([
+        connection.query(insertInto(Object.values(TenantRole).map((role) => getTenantRole(role)), OrganizationRoles.table)),
+        connection.query(insertInto(Object.values(TenantScope).map((scope) => getTenantScope(scope)), OrganizationScopes.table)),
+    ]);
+    // Link organization roles and scopes
+    await connection.query(insertInto(Object.entries(tenantRoleScopes).flatMap(([role, scopes]) => scopes.map((scope) => ({
+        tenantId: adminTenantId,
+        // eslint-disable-next-line no-restricted-syntax -- `Object.entries` converts the enum to string
+        organizationRoleId: getTenantRole(role).id,
+        organizationScopeId: getTenantScope(scope).id,
+    }))), OrganizationRoleScopeRelations.table));
+    consoleLog.succeed('Initialized tenant organization template');
+    // Init tenant organizations
+    await connection.query(insertInto(tenantIds.map((id) => getTenantOrganizationCreateData(id)), Organizations.table));
+    consoleLog.succeed('Created tenant organizations');
+};

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

@@ -1,5 +1,15 @@
-import type { AdminData, UpdateAdminData, CreateScope } from '@logto/schemas';
-import type { CommonQueryMethods } from 'slonik';
+import { type AdminData, type UpdateAdminData, type CreateScope } from '@logto/schemas';
+import type { CommonQueryMethods, DatabaseTransactionConnection } from 'slonik';
 export declare const createTenant: (pool: CommonQueryMethods, tenantId: string) => Promise<void>;
 export declare const seedAdminData: (pool: CommonQueryMethods, data: AdminData | UpdateAdminData, ...additionalScopes: CreateScope[]) => Promise<void>;
 export declare const assignScopesToRole: (pool: CommonQueryMethods, tenantId: string, roleId: string, ...scopeIds: string[]) => Promise<void>;
+/**
+ * For each initial tenant (`default` and `admin`), create a machine-to-machine application for
+ * Management API proxy and assign the corresponding proxy role to it.
+ */
+export declare const seedManagementApiProxyApplications: (connection: DatabaseTransactionConnection) => Promise<void>;
+/**
+ * Seed the legacy user role for accessing default Management API, and assign the `all` scope to
+ * it. Used in OSS only.
+ */
+export declare const seedLegacyManagementApiUserRole: (connection: DatabaseTransactionConnection) => Promise<void>;

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

@@ -1,10 +1,12 @@
 import { createTenantMetadata } from '@logto/core-kit';
+import { defaultTenantId, adminTenantId, Applications, ApplicationsRoles, getMapiProxyM2mApp, getMapiProxyRole, defaultManagementApiAdminName, Roles, PredefinedScope, getManagementApiResourceIndicator, } from '@logto/schemas';
 import { generateStandardId } from '@logto/shared';
 import { assert } from '@silverhand/essentials';
 import { sql } from 'slonik';
 import { raw } from 'slonik-sql-tag-raw';
 import { insertInto } from '../../../database.js';
 import { getDatabaseName } from '../../../queries/database.js';
+import { consoleLog } from '../../../utils.js';
 export const createTenant = async (pool, tenantId) => {
     const database = await getDatabaseName(pool, true);
     const { parentRole, role, password } = createTenantMetadata(database, tenantId);
@@ -54,3 +56,49 @@ export const assignScopesToRole = async (pool, tenantId, roleId, ...scopeIds) =>
         tenantId,
     }, 'roles_scopes'))));
 };
+/**
+ * For each initial tenant (`default` and `admin`), create a machine-to-machine application for
+ * Management API proxy and assign the corresponding proxy role to it.
+ */
+export const seedManagementApiProxyApplications = async (connection) => {
+    const tenantIds = [defaultTenantId, adminTenantId];
+    // Create machine-to-machine applications for Management API proxy
+    await connection.query(insertInto(tenantIds.map((tenantId) => getMapiProxyM2mApp(tenantId)), Applications.table));
+    consoleLog.succeed('Created machine-to-machine applications for Management API proxy');
+    // Assign the proxy roles to the applications
+    await connection.query(insertInto(tenantIds.map((tenantId) => ({
+        tenantId: adminTenantId,
+        id: generateStandardId(),
+        applicationId: getMapiProxyM2mApp(tenantId).id,
+        roleId: getMapiProxyRole(tenantId).id,
+    })), ApplicationsRoles.table));
+    consoleLog.succeed('Assigned the proxy roles to the applications');
+};
+/**
+ * Seed the legacy user role for accessing default Management API, and assign the `all` scope to
+ * it. Used in OSS only.
+ */
+export const seedLegacyManagementApiUserRole = async (connection) => {
+    const roleId = generateStandardId();
+    await connection.query(insertInto({
+        tenantId: adminTenantId,
+        id: roleId,
+        name: defaultManagementApiAdminName,
+        description: 'Legacy user role for accessing default Management API. Used in OSS only.',
+    }, Roles.table));
+    await connection.query(sql `
+    insert into roles_scopes (id, role_id, scope_id, tenant_id)
+    values (
+      ${generateStandardId()},
+      ${roleId},
+      (
+        select scopes.id from scopes
+        join resources on scopes.resource_id = resources.id
+        where resources.indicator = ${getManagementApiResourceIndicator(defaultTenantId)}
+        and scopes.name = ${PredefinedScope.All}
+        and scopes.tenant_id = ${adminTenantId}
+      ),
+      ${adminTenantId}
+    );
+  `);
+};

package/lib/commands/install/utils.js

@@ -16,7 +16,7 @@ import { cliConfig, ConfigKey, consoleLog, downloadFile, isTty, oraPromise, safe
 import { seedByPool } from '../database/seed/index.js';
 const pgRequired = new semver.SemVer('14.0.0');
 export const validateNodeVersion = () => {
-    const required = [new semver.SemVer('18.12.0')];
+    const required = [new semver.SemVer('20.9.0')];
     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)) {

package/lib/commands/translate/index.js

@@ -11,6 +11,11 @@ const translate = {
         alias: 'p',
         type: 'string',
         describe: 'The path to your Logto instance directory',
+    })
+        .option('skip-core-check', {
+        alias: 'sc',
+        type: 'boolean',
+        describe: 'Skip checking if the core package is existed',
     })
         .command(create)
         .command(listTags)

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

@@ -1,8 +1,10 @@
 import { type CommandModule } from 'yargs';
 declare const syncKeys: CommandModule<{
     path?: string;
+    skipCoreCheck?: boolean;
 }, {
     path?: string;
+    skipCoreCheck?: boolean;
     baseline: string;
     target: string;
     skipLint?: boolean;

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

@@ -22,7 +22,7 @@ const syncKeys = {
         .option('package', {
         alias: 'pkg',
         type: 'string',
-        describe: 'The package name of the phrases, one of `phrases` or `phrases-experience`',
+        describe: 'The package name of the phrases, e.g. `phrases` or `phrases-experience`',
         default: 'phrases',
     })
         .option('target', {
@@ -31,12 +31,12 @@ const syncKeys = {
         describe: 'The target language tag, or `all` to sync all languages',
     })
         .option('skip-lint', {
-        alias: 's',
+        alias: 'sl',
         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, }) => {
+    handler: async ({ path: inputPath, skipCoreCheck, baseline: baselineTag, target: targetTag, skipLint, package: packageName, }) => {
         if (!isLanguageTag(baselineTag)) {
             consoleLog.fatal('Invalid baseline language tag');
         }
@@ -46,10 +46,7 @@ const syncKeys = {
         if (baselineTag === targetTag) {
             consoleLog.fatal('Baseline and target cannot be the same');
         }
-        if (packageName !== 'phrases' && packageName !== 'phrases-experience') {
-            consoleLog.fatal('Invalid package name, expected `phrases` or `phrases-experience`');
-        }
-        const instancePath = await inquireInstancePath(inputPath);
+        const instancePath = await inquireInstancePath(inputPath, skipCoreCheck);
         const phrasesPath = path.join(instancePath, 'packages', packageName);
         const localesPath = path.join(phrasesPath, 'src/locales');
         const entrypoint = path.join(localesPath, baselineTag.toLowerCase(), 'index.ts');

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

@@ -1,11 +1,11 @@
 type FileStructure = {
-    [key: string]: {
+    [key: string | number]: {
         filePath?: string;
         structure: FileStructure;
     };
 };
 type NestedPhraseObject = {
-    [key: string]: [phrase: string, isTranslated: boolean] | NestedPhraseObject;
+    [key: string | number]: [phrase: string, isTranslated: boolean] | NestedPhraseObject;
 };
 type ParsedTuple = readonly [NestedPhraseObject, FileStructure];
 /**

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

@@ -4,6 +4,28 @@ import path from 'node:path';
 import { tryThat } from '@silverhand/essentials';
 import ts from 'typescript';
 import { consoleLog } from '../../../utils.js';
+const getValue = (property) => {
+    if (ts.isStringLiteral(property.initializer) ||
+        ts.isNoSubstitutionTemplateLiteral(property.initializer)) {
+        return property.initializer.getText();
+    }
+    consoleLog.fatal('Unsupported property:', property.getFullText());
+};
+const hasLeadingUntranslatedComment = (fullText) => {
+    const commentRanges = ts.getLeadingCommentRanges(fullText, 0);
+    if (commentRanges?.[0]) {
+        if (commentRanges.length > 1) {
+            consoleLog.fatal('Multiple comments found for property.');
+        }
+        const commentRange = commentRanges[0];
+        const comment = fullText.slice(commentRange.pos, commentRange.end);
+        if (comment.includes(untranslatedMark)) {
+            return true;
+        }
+        consoleLog.warn('Unsupported comment:', comment);
+    }
+    return false;
+};
 const untranslatedMark = 'UNTRANSLATED';
 /**
  * Given a entrypoint file path of a language, parse the nested object of
@@ -94,33 +116,27 @@ export const parseLocaleFiles = (filePath) => {
                     fileStructure[key] = { structure };
                     /* eslint-enable @silverhand/fp/no-mutation */
                 }
-                else if (ts.isStringLiteral(property.initializer) ||
-                    ts.isNoSubstitutionTemplateLiteral(property.initializer)) {
-                    const value = property.initializer.getText();
-                    const commentRanges = ts.getLeadingCommentRanges(property.getFullText(), 0);
-                    if (commentRanges?.[0]) {
-                        if (commentRanges.length > 1) {
-                            consoleLog.fatal('Multiple comments found for property:', property);
-                        }
-                        const commentRange = commentRanges[0];
-                        const comment = property.getFullText().slice(commentRange.pos, commentRange.end);
-                        if (comment.includes(untranslatedMark)) {
-                            // eslint-disable-next-line @silverhand/fp/no-mutation
-                            nestedObject[key] = [value, false];
-                        }
-                        else {
-                            // eslint-disable-next-line @silverhand/fp/no-mutation
-                            nestedObject[key] = [value, true];
-                            consoleLog.warn('Unsupported comment:', comment);
+                else if (ts.isArrayLiteralExpression(property.initializer)) {
+                    const elements = property.initializer.elements.map((element) => {
+                        if (ts.isStringLiteralLike(element)) {
+                            return [
+                                [element.getText(), !hasLeadingUntranslatedComment(element.getFullText())],
+                                {},
+                            ];
                         }
-                    }
-                    else {
-                        // eslint-disable-next-line @silverhand/fp/no-mutation
-                        nestedObject[key] = [value, true];
-                    }
+                        return traverseNode(element, {}, {});
+                    });
+                    /* eslint-disable @silverhand/fp/no-mutation */
+                    nestedObject[key] = Object.fromEntries(elements.map(([phrases], index) => [index, phrases]));
+                    fileStructure[key] = {
+                        structure: Object.fromEntries(elements.map(([, structure], index) => [index, { structure }])),
+                    };
+                    /* eslint-enable @silverhand/fp/no-mutation */
                 }
                 else {
-                    consoleLog.fatal('Unsupported property:', property);
+                    const value = getValue(property);
+                    // eslint-disable-next-line @silverhand/fp/no-mutation
+                    nestedObject[key] = [value, !hasLeadingUntranslatedComment(property.getFullText())];
                 }
             }
         };
@@ -210,10 +226,13 @@ const traverseNode = async (baseline, targetObject, targetFilePath, isRoot = fal
     await fs.appendFile(targetFilePath, `const ${identifier} = {\n`);
     // Recursively traverse the nested object of phrases and the file structure
     // of the baseline language
+    // eslint-disable-next-line complexity
     const traverseObject = async (baseline, targetObject, tabSize) => {
         const [baselineObject, baselineStructure] = baseline;
+        const isBaselineArray = 0 in baselineObject;
         for (const [key, value] of Object.entries(baselineObject)) {
             const existingValue = targetObject[key];
+            const keyOutput = isBaselineArray ? '' : `${key}: `;
             if (Array.isArray(value)) {
                 const [phrase] = value;
                 // If the key exists in the target language and the value is a translated
@@ -221,11 +240,11 @@ const traverseNode = async (baseline, targetObject, targetFilePath, isRoot = fal
                 // of the baseline language and add a comment to indicate that the phrase
                 // is untranslated to help identify missing translations.
                 if (Array.isArray(existingValue) && existingValue[1]) {
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: ${existingValue[0]},\n`);
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${keyOutput}${existingValue[0]},\n`);
                 }
                 else {
                     await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}/** ${untranslatedMark} */\n`);
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: ${phrase},\n`);
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${keyOutput}${phrase},\n`);
                 }
             }
             // Not a string, treat it as a nested object or an import
@@ -236,11 +255,12 @@ const traverseNode = async (baseline, targetObject, targetFilePath, isRoot = fal
                     await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key},\n`);
                     await traverseNode([value, keyStructure.structure], Array.isArray(existingValue) ? {} : existingValue ?? {}, path.join(targetDirectory, keyStructure.filePath));
                 }
-                // Otherwise, treat it as a nested object.
+                // Otherwise, treat it as a nested object or array.
                 else {
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${key}: {\n`);
+                    const isValueArray = 0 in value;
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${keyOutput}${isValueArray ? '[' : '{'}\n`);
                     await traverseObject([value, keyStructure?.structure ?? {}], Array.isArray(existingValue) ? {} : existingValue ?? {}, tabSize + 2);
-                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}},\n`);
+                    await fs.appendFile(targetFilePath, `${' '.repeat(tabSize)}${isValueArray ? ']' : '}'},\n`);
                 }
             }
         }

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

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

package/lib/commands/translate/sync.js

@@ -1,15 +1,21 @@
 import { languages } from '@logto/language-kit';
 import { isBuiltInLanguageTag as isPhrasesBuiltInLanguageTag } from '@logto/phrases';
-import { isBuiltInLanguageTag as isPhrasesUiBuiltInLanguageTag } from '@logto/phrases-experience';
 import PQueue from 'p-queue';
 import { inquireInstancePath, lintLocaleFiles } from '../../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: 1 });
-        const instancePath = await inquireInstancePath(inputPath);
+    builder: (yargs) => yargs.option('package', {
+        alias: 'pkg',
+        type: 'string',
+        describe: 'The package name of the phrases, e.g. `phrases` or `phrases-experience`',
+        default: 'phrases',
+    }),
+    handler: async ({ path: inputPath, skipCoreCheck, package: packageName }) => {
+        const queue = new PQueue({ concurrency: 10 });
+        const instancePath = await inquireInstancePath(inputPath, skipCoreCheck);
+        const packages = packageName ? [packageName] : ['phrases', 'phrases-experience'];
         for (const languageTag of Object.keys(languages)) {
             if (languageTag === baseLanguage) {
                 continue;
@@ -19,25 +25,20 @@ const sync = {
                 verbose: false,
                 queue,
             };
-            /* eslint-disable no-await-in-loop */
-            if (isPhrasesBuiltInLanguageTag(languageTag)) {
-                await syncTranslation({
-                    ...baseOptions,
-                    packageName: 'phrases',
-                    languageTag,
-                });
+            for (const packageName of packages) {
+                /* eslint-disable no-await-in-loop */
+                if (isPhrasesBuiltInLanguageTag(languageTag)) {
+                    await syncTranslation({
+                        ...baseOptions,
+                        packageName,
+                        languageTag,
+                    });
+                }
+                /* eslint-enable no-await-in-loop */
             }
-            if (isPhrasesUiBuiltInLanguageTag(languageTag)) {
-                await syncTranslation({
-                    ...baseOptions,
-                    packageName: 'phrases-experience',
-                    languageTag,
-                });
-            }
-            /* eslint-enable no-await-in-loop */
         }
         await queue.onIdle();
-        void lintLocaleFiles(instancePath);
+        void lintLocaleFiles(instancePath, packageName);
     },
 };
 export default sync;

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

@@ -5,7 +5,7 @@ export declare const readLocaleFiles: (directory: string) => Promise<string[]>;
 export declare const readBaseLocaleFiles: (directory: string) => Promise<string[]>;
 export type TranslationOptions = {
     instancePath: string;
-    packageName: 'phrases' | 'phrases-experience';
+    packageName: string;
     languageTag: LanguageTag;
     verbose?: boolean;
     queue?: PQueue;

package/lib/commands/translate/utils.js

@@ -25,7 +25,7 @@ export const readBaseLocaleFiles = async (directory) => {
     }
     return readLocaleFiles(enDirectory);
 };
-export const createFullTranslation = async ({ instancePath, packageName, languageTag, verbose = true, queue = new PQueue({ concurrency: 5 }), }) => {
+export const createFullTranslation = async ({ instancePath, packageName, languageTag, verbose = true, queue = new PQueue({ concurrency: 10 }), }) => {
     const localeFiles = await getBaseAndTargetLocaleFiles(instancePath, packageName, languageTag);
     if (verbose) {
         consoleLog.info('Found ' +
@@ -54,7 +54,7 @@ export const createFullTranslation = async ({ instancePath, packageName, languag
     }
     return queue.onIdle();
 };
-export const syncTranslation = async ({ instancePath, packageName, languageTag, verbose = true, queue = new PQueue({ concurrency: 5 }), }) => {
+export const syncTranslation = async ({ instancePath, packageName, languageTag, verbose = true, queue = new PQueue({ concurrency: 10 }), }) => {
     const localeFiles = await getBaseAndTargetLocaleFiles(instancePath, packageName, languageTag);
     if (verbose) {
         consoleLog.info('Found ' +

package/lib/database.d.ts

@@ -9,4 +9,8 @@ export declare const createPoolFromConfig: () => Promise<import("slonik").Databa
  * @returns A new database pool with the database URL in config.
  */
 export declare const createPoolAndDatabaseIfNeeded: () => Promise<import("slonik").DatabasePool>;
-export declare const insertInto: <T extends SchemaLike<string>>(object: T, table: string) => import("slonik").TaggedTemplateLiteralInvocation<import("slonik").QueryResultRow>;
+/**
+ * Build an `insert into` query from the given payload. If the payload is an array, it will insert
+ * multiple rows.
+ */
+export declare const insertInto: <T extends SchemaLike<string>>(payload: T | T[], table: string) => import("slonik").TaggedTemplateLiteralInvocation<import("slonik").QueryResultRow>;

package/lib/database.js

@@ -54,11 +54,20 @@ export const createPoolAndDatabaseIfNeeded = async () => {
         return createPoolFromConfig();
     }
 };
-export const insertInto = (object, table) => {
-    const keys = Object.keys(object);
+/**
+ * Build an `insert into` query from the given payload. If the payload is an array, it will insert
+ * multiple rows.
+ */
+export const insertInto = (payload, table) => {
+    const first = Array.isArray(payload) ? payload[0] : payload;
+    if (!first) {
+        throw new Error('Payload cannot be empty');
+    }
+    const keys = Object.keys(first);
+    const values = Array.isArray(payload) ? payload : [payload];
     return sql `
     insert into ${sql.identifier([table])}
     (${sql.join(keys.map((key) => sql.identifier([decamelize(key)])), sql `, `)})
-    values (${sql.join(keys.map((key) => convertToPrimitiveOrSql(key, object[key] ?? null)), sql `, `)})
+    values ${sql.join(values.map((object) => sql `(${sql.join(keys.map((key) => convertToPrimitiveOrSql(key, object[key] ?? null)), sql `, `)})`), sql `, `)}
   `;
 };

package/lib/package-json.js

@@ -1,6 +1,6 @@
 export const packageJson = {
     "name": "@logto/cli",
-    "version": "1.11.0",
+    "version": "1.13.0",
     "description": "Logto CLI.",
     "author": "Silverhand Inc. <contact@silverhand.io>",
     "homepage": "https://github.com/logto-io/logto#readme",
@@ -37,30 +37,30 @@ export const packageJson = {
         "prepack": "pnpm build"
     },
     "engines": {
-        "node": "^18.12.0"
+        "node": "^20.9.0"
     },
     "bugs": {
         "url": "https://github.com/logto-io/logto/issues"
     },
     "dependencies": {
-        "@logto/connector-kit": "workspace:^2.0.0",
-        "@logto/core-kit": "workspace:^2.2.0",
-        "@logto/language-kit": "workspace:^1.0.0",
-        "@logto/phrases": "workspace:^1.7.0",
-        "@logto/phrases-experience": "workspace:^1.4.0",
-        "@logto/schemas": "workspace:1.11.0",
-        "@logto/shared": "workspace:^3.0.0",
-        "@silverhand/essentials": "^2.8.4",
+        "@logto/connector-kit": "workspace:^2.1.0",
+        "@logto/core-kit": "workspace:^2.3.0",
+        "@logto/language-kit": "workspace:^1.1.0",
+        "@logto/phrases": "workspace:^1.9.0",
+        "@logto/phrases-experience": "workspace:^1.6.0",
+        "@logto/schemas": "workspace:1.13.0",
+        "@logto/shared": "workspace:^3.1.0",
+        "@silverhand/essentials": "^2.9.0",
         "chalk": "^5.0.0",
         "decamelize": "^6.0.0",
         "dotenv": "^16.0.0",
-        "got": "^13.0.0",
+        "got": "^14.0.0",
         "hpagent": "^1.2.0",
         "inquirer": "^9.0.0",
         "nanoid": "^5.0.1",
-        "ora": "^6.1.2",
-        "p-limit": "^4.0.0",
-        "p-queue": "^7.3.4",
+        "ora": "^8.0.1",
+        "p-limit": "^5.0.0",
+        "p-queue": "^8.0.0",
         "p-retry": "^6.0.0",
         "pg-protocol": "^1.6.0",
         "roarr": "^7.11.0",
@@ -69,23 +69,23 @@ export const packageJson = {
         "slonik-interceptor-preset": "^1.2.10",
         "slonik-sql-tag-raw": "^1.1.4",
         "tar": "^6.1.11",
-        "typescript": "^5.0.0",
+        "typescript": "^5.3.3",
         "yargs": "^17.6.0",
         "zod": "^3.22.4"
     },
     "devDependencies": {
-        "@silverhand/eslint-config": "4.0.1",
-        "@silverhand/ts-config": "4.0.0",
+        "@silverhand/eslint-config": "5.0.0",
+        "@silverhand/ts-config": "5.0.0",
         "@withtyped/server": "^0.12.9",
         "@types/inquirer": "^9.0.0",
         "@types/jest": "^29.4.0",
-        "@types/node": "^18.11.18",
+        "@types/node": "^20.9.5",
         "@types/semver": "^7.3.12",
-        "@types/sinon": "^10.0.13",
+        "@types/sinon": "^17.0.0",
         "@types/tar": "^6.1.2",
         "@types/yargs": "^17.0.13",
         "eslint": "^8.44.0",
-        "jest": "^29.5.0",
+        "jest": "^29.7.0",
         "lint-staged": "^15.0.0",
         "prettier": "^3.0.0",
         "sinon": "^17.0.0"

package/lib/utils.d.ts

@@ -28,10 +28,10 @@ export declare const getCliConfigWithPrompt: ({ key, readableKey, comments, defa
  * findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
  */
 export declare function findLastIndex<T>(array: readonly T[], predicate: (value: T, index: number, object: readonly T[]) => boolean): number;
-export declare const inquireInstancePath: (initialPath?: string) => Promise<string>;
+export declare const inquireInstancePath: (initialPath?: string, skipCoreCheck?: boolean) => Promise<string>;
 export type ConnectorPackage = {
     name: string;
     path: string;
 };
 export declare const getConnectorPackagesFromDirectory: (directory: string) => Promise<ConnectorPackage[]>;
-export declare const lintLocaleFiles: (instancePath: string, packageName?: 'phrases' | 'phrases-experience') => Promise<void>;
+export declare const lintLocaleFiles: (instancePath: string, packageName?: string) => Promise<void>;

package/lib/utils.js

@@ -5,7 +5,7 @@ import { createRequire } from 'node:module';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { ConsoleLog } from '@logto/shared';
-import { assert, conditionalString } from '@silverhand/essentials';
+import { assert, conditional, conditionalString } from '@silverhand/essentials';
 import chalk from 'chalk';
 import { got } from 'got';
 import { HttpsProxyAgent } from 'hpagent';
@@ -139,9 +139,9 @@ const validatePath = async (value) => {
     }
     return true;
 };
-export const inquireInstancePath = async (initialPath) => {
+export const inquireInstancePath = async (initialPath, skipCoreCheck) => {
     const inquire = async () => {
-        if (!initialPath && (await validatePath('.')) === true) {
+        if (!initialPath && (skipCoreCheck ?? (await validatePath('.')) === true)) {
             return path.resolve('.');
         }
         if (!isTty()) {
@@ -154,14 +154,16 @@ export const inquireInstancePath = async (initialPath) => {
             type: 'input',
             default: defaultPath,
             filter: (value) => value.trim(),
-            validate: validatePath,
+            validate: conditional(!skipCoreCheck && validatePath),
         }, { instancePath: initialPath });
         return instancePath;
     };
     const instancePath = await inquire();
-    const validated = await validatePath(instancePath);
-    if (validated !== true) {
-        consoleLog.fatal(validated);
+    if (!skipCoreCheck) {
+        const validated = await validatePath(instancePath);
+        if (validated !== true) {
+            consoleLog.fatal(validated);
+        }
     }
     return instancePath;
 };
@@ -188,7 +190,7 @@ const execPromise = promisify(execFile);
 export const lintLocaleFiles = async (
 /** Logto instance path */
 instancePath, 
-/** Target package name, ignore to lint both packages */
+/** Target package name, ignore to lint both `phrases` and `phrases-experience` packages */
 packageName) => {
     const spinner = ora({
         text: 'Running `eslint --fix` for locales',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logto/cli",
-  "version": "1.11.0",
+  "version": "1.13.0",
   "description": "Logto CLI.",
   "author": "Silverhand Inc. <contact@silverhand.io>",
   "homepage": "https://github.com/logto-io/logto#readme",
@@ -22,30 +22,30 @@
     "url": "git+https://github.com/logto-io/logto.git"
   },
   "engines": {
-    "node": "^18.12.0"
+    "node": "^20.9.0"
   },
   "bugs": {
     "url": "https://github.com/logto-io/logto/issues"
   },
   "dependencies": {
-    "@logto/connector-kit": "^2.0.0",
-    "@logto/core-kit": "^2.2.0",
-    "@logto/language-kit": "^1.0.0",
-    "@logto/phrases": "^1.7.0",
-    "@logto/phrases-experience": "^1.4.0",
-    "@logto/schemas": "1.11.0",
-    "@logto/shared": "^3.0.0",
-    "@silverhand/essentials": "^2.8.4",
+    "@logto/connector-kit": "^2.1.0",
+    "@logto/core-kit": "^2.3.0",
+    "@logto/language-kit": "^1.1.0",
+    "@logto/phrases": "^1.9.0",
+    "@logto/phrases-experience": "^1.6.0",
+    "@logto/schemas": "1.13.0",
+    "@logto/shared": "^3.1.0",
+    "@silverhand/essentials": "^2.9.0",
     "chalk": "^5.0.0",
     "decamelize": "^6.0.0",
     "dotenv": "^16.0.0",
-    "got": "^13.0.0",
+    "got": "^14.0.0",
     "hpagent": "^1.2.0",
     "inquirer": "^9.0.0",
     "nanoid": "^5.0.1",
-    "ora": "^6.1.2",
-    "p-limit": "^4.0.0",
-    "p-queue": "^7.3.4",
+    "ora": "^8.0.1",
+    "p-limit": "^5.0.0",
+    "p-queue": "^8.0.0",
     "p-retry": "^6.0.0",
     "pg-protocol": "^1.6.0",
     "roarr": "^7.11.0",
@@ -54,23 +54,23 @@
     "slonik-interceptor-preset": "^1.2.10",
     "slonik-sql-tag-raw": "^1.1.4",
     "tar": "^6.1.11",
-    "typescript": "^5.0.0",
+    "typescript": "^5.3.3",
     "yargs": "^17.6.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {
-    "@silverhand/eslint-config": "4.0.1",
-    "@silverhand/ts-config": "4.0.0",
+    "@silverhand/eslint-config": "5.0.0",
+    "@silverhand/ts-config": "5.0.0",
     "@withtyped/server": "^0.12.9",
     "@types/inquirer": "^9.0.0",
     "@types/jest": "^29.4.0",
-    "@types/node": "^18.11.18",
+    "@types/node": "^20.9.5",
     "@types/semver": "^7.3.12",
-    "@types/sinon": "^10.0.13",
+    "@types/sinon": "^17.0.0",
     "@types/tar": "^6.1.2",
     "@types/yargs": "^17.0.13",
     "eslint": "^8.44.0",
-    "jest": "^29.5.0",
+    "jest": "^29.7.0",
     "lint-staged": "^15.0.0",
     "prettier": "^3.0.0",
     "sinon": "^17.0.0"