@logto/cli 1.0.0-beta.11

package/lib/commands/connector/utils.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOfficialConnectors = exports.addConnectors = exports.getConnectorPackagesFrom = exports.isOfficialConnector = exports.normalizePackageName = exports.inquireInstancePath = exports.npmPackResultGuard = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const essentials_1 = require("@silverhand/essentials");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = require("fs-extra");
+const inquirer_1 = __importDefault(require("inquirer"));
+const p_retry_1 = __importDefault(require("p-retry"));
+const tar_1 = __importDefault(require("tar"));
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const utilities_1 = require("../../utilities");
+const utils_1 = require("../install/utils");
+const coreDirectory = 'packages/core';
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+exports.npmPackResultGuard = zod_1.z
+    .object({
+    name: zod_1.z.string(),
+    version: zod_1.z.string(),
+    filename: zod_1.z.string(),
+})
+    .array();
+const buildPathErrorMessage = (value) => `The path ${chalk_1.default.green(value)} does not contain a Logto instance, please try another.`;
+const validatePath = async (value) => {
+    const corePackageJsonPath = path_1.default.resolve(path_1.default.join(value, coreDirectory, 'package.json'));
+    if (!(0, fs_1.existsSync)(corePackageJsonPath)) {
+        return buildPathErrorMessage(value);
+    }
+    const packageJson = await (0, promises_1.readFile)(corePackageJsonPath, { encoding: 'utf8' });
+    const packageName = await zod_1.z
+        .object({ name: zod_1.z.string() })
+        .parseAsync(JSON.parse(packageJson))
+        .then(({ name }) => name)
+        .catch(() => '');
+    if (packageName !== '@logto/core') {
+        return buildPathErrorMessage(value);
+    }
+    return true;
+};
+const inquireInstancePath = async (initialPath) => {
+    const inquire = async () => {
+        if (!(0, utilities_1.isTty)()) {
+            (0, essentials_1.assert)(initialPath, new Error('Path is missing'));
+            return initialPath;
+        }
+        const { instancePath } = await inquirer_1.default.prompt({
+            name: 'instancePath',
+            message: 'Where is your Logto instance?',
+            type: 'input',
+            default: utils_1.defaultPath,
+            filter: (value) => value.trim(),
+            validate: validatePath,
+        }, { instancePath: initialPath });
+        return instancePath;
+    };
+    const instancePath = await inquire();
+    const validated = await validatePath(instancePath);
+    if (validated !== true) {
+        utilities_1.log.error(validated);
+    }
+    return instancePath;
+};
+exports.inquireInstancePath = inquireInstancePath;
+const packagePrefix = 'connector-';
+const normalizePackageName = (name) => name
+    .split('/')
+    // Prepend prefix to the last fragment if needed
+    .map((fragment, index, array) => index === array.length - 1 && !fragment.startsWith(packagePrefix) && !fragment.startsWith('@')
+    ? packagePrefix + fragment
+    : fragment)
+    .join('/');
+exports.normalizePackageName = normalizePackageName;
+const getConnectorDirectory = (instancePath) => path_1.default.join(instancePath, coreDirectory, constants_1.connectorDirectory);
+const isOfficialConnector = (packageName) => packageName.startsWith('@logto/connector-');
+exports.isOfficialConnector = isOfficialConnector;
+const getConnectorPackageName = async (directory) => {
+    const filePath = path_1.default.join(directory, 'package.json');
+    if (!(0, fs_1.existsSync)(filePath)) {
+        return;
+    }
+    const json = await (0, promises_1.readFile)(filePath, 'utf8');
+    const { name } = zod_1.z.object({ name: zod_1.z.string() }).parse(JSON.parse(json));
+    if (name.startsWith('connector-') || Boolean(name.split('/')[1]?.startsWith('connector-'))) {
+        return name;
+    }
+};
+const getConnectorPackagesFrom = async (instancePath) => {
+    const directory = getConnectorDirectory(await (0, exports.inquireInstancePath)(instancePath));
+    const content = await (0, promises_1.readdir)(directory, 'utf8');
+    const rawPackages = await Promise.all(content.map(async (value) => {
+        const currentDirectory = path_1.default.join(directory, value);
+        return { name: await getConnectorPackageName(currentDirectory), path: currentDirectory };
+    }));
+    return rawPackages.filter((packageInfo) => typeof packageInfo.name === 'string');
+};
+exports.getConnectorPackagesFrom = getConnectorPackagesFrom;
+const addConnectors = async (instancePath, packageNames) => {
+    const cwd = getConnectorDirectory(instancePath);
+    if (!(0, fs_1.existsSync)(cwd)) {
+        await (0, promises_1.mkdir)(cwd);
+    }
+    utilities_1.log.info('Fetch connector metadata');
+    const results = await Promise.all(packageNames
+        .map((name) => (0, exports.normalizePackageName)(name))
+        .map(async (packageName) => {
+        const run = async () => {
+            const { stdout } = await execPromise(`npm pack ${packageName} --json`, { cwd });
+            const result = exports.npmPackResultGuard.parse(JSON.parse(stdout));
+            if (!result[0]) {
+                throw new Error(`Unable to execute ${chalk_1.default.green('npm pack')} on package ${chalk_1.default.green(packageName)}`);
+            }
+            const { filename, name } = result[0];
+            const escapedFilename = filename.replace(/\//g, '-').replace(/@/g, '');
+            const tarPath = path_1.default.join(cwd, escapedFilename);
+            const packageDirectory = path_1.default.join(cwd, name.replace(/\//g, '-'));
+            await (0, fs_extra_1.remove)(packageDirectory);
+            await (0, fs_extra_1.ensureDir)(packageDirectory);
+            await tar_1.default.extract({ cwd: packageDirectory, file: tarPath, strip: 1 });
+            await (0, promises_1.unlink)(tarPath);
+            utilities_1.log.succeed(`Added ${chalk_1.default.green(name)}`);
+        };
+        try {
+            await (0, p_retry_1.default)(run, { retries: 2 });
+        }
+        catch (error) {
+            console.warn(`[${packageName}]`, error);
+            return packageName;
+        }
+    }));
+    const errorPackages = results.filter(Boolean);
+    const errorCount = errorPackages.length;
+    utilities_1.log.info(errorCount
+        ? `Finished with ${errorCount} error${(0, essentials_1.conditionalString)(errorCount > 1 && 's')}.`
+        : 'Finished');
+    if (errorCount) {
+        utilities_1.log.warn('Failed to add ' + errorPackages.map((name) => chalk_1.default.green(name)).join(', '));
+    }
+};
+exports.addConnectors = addConnectors;
+const officialConnectorPrefix = '@logto/connector-';
+const fetchOfficialConnectorList = async () => {
+    const { stdout } = await execPromise(`npm search ${officialConnectorPrefix} --json`);
+    const packages = zod_1.z
+        .object({ name: zod_1.z.string() })
+        .transform(({ name }) => name)
+        .array()
+        .parse(JSON.parse(stdout));
+    return packages.filter((name) => ['mock', 'kit'].every((excluded) => !name.slice(officialConnectorPrefix.length).startsWith(excluded)));
+};
+const addOfficialConnectors = async (instancePath) => {
+    const packages = await (0, utilities_1.oraPromise)(fetchOfficialConnectorList(), {
+        text: 'Fetch official connector list',
+        prefixText: chalk_1.default.blue('[info]'),
+    });
+    await (0, exports.addConnectors)(instancePath, packages);
+};
+exports.addOfficialConnectors = addOfficialConnectors;

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

@@ -0,0 +1,11 @@
+import { DatabasePool } from 'slonik';
+import { CommandModule } from 'yargs';
+import { AlterationFile } from './type';
+export declare const getAlterationFiles: () => Promise<AlterationFile[]>;
+export declare const getLatestAlterationTimestamp: () => Promise<number>;
+export declare const getUndeployedAlterations: (pool: DatabasePool) => Promise<AlterationFile[]>;
+declare const alteration: CommandModule<unknown, {
+    action: string;
+    target?: string;
+}>;
+export default alteration;

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

@@ -0,0 +1,142 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUndeployedAlterations = exports.getLatestAlterationTimestamp = exports.getAlterationFiles = void 0;
+const path_1 = __importDefault(require("path"));
+const shared_1 = require("@logto/shared");
+const essentials_1 = require("@silverhand/essentials");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = require("fs-extra");
+const database_1 = require("../../../database");
+const logto_config_1 = require("../../../queries/logto-config");
+const utilities_1 = require("../../../utilities");
+const version_1 = require("./version");
+const alterationFilenameRegex = /-(\d+)-?.*\.js$/;
+const getTimestampFromFilename = (filename) => {
+    const match = alterationFilenameRegex.exec(filename);
+    if (!match?.[1]) {
+        throw new Error(`Can not get timestamp: ${filename}`);
+    }
+    return Number(match[1]);
+};
+const importAlterationScript = async (filePath) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const module = await Promise.resolve().then(() => __importStar(require(filePath)));
+    // eslint-disable-next-line no-restricted-syntax
+    return module.default;
+};
+const getAlterationFiles = async () => {
+    const alterationDirectory = (0, utilities_1.getPathInModule)('@logto/schemas', 'alterations-js');
+    /**
+     * We copy all alteration scripts to the CLI package root directory,
+     * since they need a proper context that includes required dependencies (such as slonik) in `node_modules/`.
+     * While the original `@logto/schemas` may remove them in production.
+     */
+    const packageDirectory = await (0, shared_1.findPackage)(
+    // Until we migrate to ESM
+    // eslint-disable-next-line unicorn/prefer-module
+    __dirname);
+    const localAlterationDirectory = path_1.default.resolve(
+    // Until we migrate to ESM
+    // eslint-disable-next-line unicorn/prefer-module
+    packageDirectory ?? __dirname, 'alteration-scripts');
+    if (!(0, fs_extra_1.existsSync)(alterationDirectory)) {
+        return [];
+    }
+    // We need to copy alteration files to execute in the CLI context to make `slonik` available
+    await (0, fs_extra_1.remove)(localAlterationDirectory);
+    await (0, fs_extra_1.copy)(alterationDirectory, localAlterationDirectory);
+    const directory = await (0, fs_extra_1.readdir)(localAlterationDirectory);
+    const files = directory.filter((file) => alterationFilenameRegex.test(file));
+    return files
+        .slice()
+        .sort((file1, file2) => getTimestampFromFilename(file1) - getTimestampFromFilename(file2))
+        .map((filename) => ({ path: path_1.default.join(localAlterationDirectory, filename), filename }));
+};
+exports.getAlterationFiles = getAlterationFiles;
+const getLatestAlterationTimestamp = async () => {
+    const files = await (0, exports.getAlterationFiles)();
+    const lastFile = files[files.length - 1];
+    if (!lastFile) {
+        return 0;
+    }
+    return getTimestampFromFilename(lastFile.filename);
+};
+exports.getLatestAlterationTimestamp = getLatestAlterationTimestamp;
+const getUndeployedAlterations = async (pool) => {
+    const databaseTimestamp = await (0, logto_config_1.getCurrentDatabaseAlterationTimestamp)(pool);
+    const files = await (0, exports.getAlterationFiles)();
+    return files.filter(({ filename }) => getTimestampFromFilename(filename) > databaseTimestamp);
+};
+exports.getUndeployedAlterations = getUndeployedAlterations;
+const deployAlteration = async (pool, { path: filePath, filename }) => {
+    const { up } = await importAlterationScript(filePath);
+    try {
+        await pool.transaction(async (connection) => {
+            await up(connection);
+            await (0, logto_config_1.updateDatabaseTimestamp)(connection, getTimestampFromFilename(filename));
+        });
+    }
+    catch (error) {
+        console.error(error);
+        await pool.end();
+        utilities_1.log.error(`Error ocurred during running alteration ${chalk_1.default.blue(filename)}.\n\n` +
+            "  This alteration didn't change anything since it was in a transaction.\n" +
+            '  Try to fix the error and deploy again.');
+    }
+    utilities_1.log.info(`Run alteration ${filename} succeeded`);
+};
+const alteration = {
+    command: ['alteration <action> [target]', 'alt', 'alter'],
+    describe: 'Perform database alteration',
+    builder: (yargs) => yargs
+        .positional('action', {
+        describe: 'The action to perform, now it only accepts `deploy`',
+        type: 'string',
+        demandOption: true,
+    })
+        .positional('target', {
+        describe: 'The target Logto version for alteration',
+        type: 'string',
+    }),
+    handler: async ({ action, target }) => {
+        if (action !== 'deploy') {
+            utilities_1.log.error('Unsupported action');
+        }
+        const pool = await (0, database_1.createPoolFromConfig)();
+        const alterations = await (0, version_1.chooseAlterationsByVersion)(await (0, exports.getUndeployedAlterations)(pool), target);
+        utilities_1.log.info(`Found ${alterations.length} alteration${(0, essentials_1.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();
+    },
+};
+exports.default = alteration;

package/lib/commands/database/alteration/index.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const slonik_1 = require("slonik");
+const functions = __importStar(require("."));
+const queries = __importStar(require("../../../queries/logto-config"));
+const version_1 = require("./version");
+const mockQuery = jest.fn();
+const pool = (0, slonik_1.createMockPool)({
+    query: async (sql, values) => {
+        return mockQuery(sql, values);
+    },
+});
+describe('getUndeployedAlterations()', () => {
+    const files = Object.freeze([
+        { filename: '1.0.0-1663923770-a.js', path: '/alterations-js/1.0.0-1663923770-a.js' },
+        { filename: '1.0.0-1663923771-b.js', path: '/alterations-js/1.0.0-1663923771-b.js' },
+        { filename: '1.0.0-1663923772-c.js', path: '/alterations-js/1.0.0-1663923772-c.js' },
+    ]);
+    beforeEach(() => {
+        // `getAlterationFiles()` will ensure the order
+        jest.spyOn(functions, 'getAlterationFiles').mockResolvedValueOnce([...files]);
+    });
+    it('returns all files if database timestamp is 0', async () => {
+        jest.spyOn(queries, 'getCurrentDatabaseAlterationTimestamp').mockResolvedValueOnce(0);
+        await expect(functions.getUndeployedAlterations(pool)).resolves.toEqual(files);
+    });
+    it('returns files whose timestamp is greater then database timestamp', async () => {
+        jest
+            .spyOn(queries, 'getCurrentDatabaseAlterationTimestamp')
+            .mockResolvedValueOnce(1663923770);
+        await expect(functions.getUndeployedAlterations(pool)).resolves.toEqual([files[1], files[2]]);
+    });
+});
+describe('chooseAlterationsByVersion()', () => {
+    const files = Object.freeze([
+        '1.0.0_beta.9-1663923770-a.js',
+        '1.0.0_beta.9-1663923771-b.js',
+        '1.0.0_beta.10-1663923772-c.js',
+        '1.0.0_beta.11-1663923773-c.js',
+        '1.0.0_beta.11-1663923774-c.js',
+        '1.0.0-1663923775-c.js',
+        '1.0.0-1663923776-c.js',
+        '1.0.1-1663923777-c.js',
+        '1.2.0-1663923778-c.js',
+        'next-1663923778-c.js',
+        'next-1663923779-c.js',
+        'next-1663923780-c.js',
+        'next1-1663923781-c.js',
+    ].map((filename) => ({ filename, path: '/alterations/' + filename })));
+    it('chooses nothing when input version is invalid', async () => {
+        await expect((0, version_1.chooseAlterationsByVersion)(files, 'next1')).rejects.toThrow('Invalid Version: next1');
+        await expect((0, version_1.chooseAlterationsByVersion)([], 'ok')).rejects.toThrow('Invalid Version: ok');
+    });
+    it('chooses correct alteration files', async () => {
+        await Promise.all([
+            expect((0, version_1.chooseAlterationsByVersion)([], 'v1.0.0')).resolves.toEqual([]),
+            expect((0, version_1.chooseAlterationsByVersion)(files, 'v1.0.0')).resolves.toEqual(files.slice(0, 7)),
+            expect((0, version_1.chooseAlterationsByVersion)(files, 'v1.0.0-beta.10')).resolves.toEqual(files.slice(0, 3)),
+            expect((0, version_1.chooseAlterationsByVersion)(files, 'v1.1.0')).resolves.toEqual(files.slice(0, 8)),
+            expect((0, version_1.chooseAlterationsByVersion)(files, 'v1.2.0')).resolves.toEqual(files.slice(0, 9)),
+            expect((0, version_1.chooseAlterationsByVersion)(files, 'next')).resolves.toEqual(files.slice(0, 12)),
+        ]);
+    });
+});

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

@@ -0,0 +1,4 @@
+export declare type AlterationFile = {
+    path: string;
+    filename: string;
+};

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

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

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

@@ -0,0 +1,2 @@
+import { AlterationFile } from './type';
+export declare const chooseAlterationsByVersion: (alterations: readonly AlterationFile[], initialVersion?: string) => Promise<AlterationFile[]>;

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

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseAlterationsByVersion = void 0;
+const essentials_1 = require("@silverhand/essentials");
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const semver_1 = require("semver");
+const utilities_1 = require("../../../utilities");
+const getVersionFromFilename = (filename) => {
+    try {
+        return new semver_1.SemVer(filename.split('-')[0]?.replaceAll('_', '-') ?? 'unknown');
+    }
+    catch { }
+};
+const latestTag = 'latest';
+const nextTag = 'next';
+const chooseAlterationsByVersion = async (alterations, initialVersion) => {
+    if (initialVersion === nextTag) {
+        const endIndex = (0, utilities_1.findLastIndex)(alterations, ({ filename }) => filename.startsWith(nextTag + '-') || Boolean(getVersionFromFilename(filename)));
+        if (endIndex === -1) {
+            return [];
+        }
+        utilities_1.log.info(`Deploy target ${chalk_1.default.green(nextTag)}`);
+        return alterations.slice(0, endIndex + 1);
+    }
+    const versions = alterations
+        .map(({ filename }) => getVersionFromFilename(filename))
+        .filter((version) => version instanceof semver_1.SemVer)
+        // Cannot use `Set` to deduplicate since it's a class
+        .filter((version, index, self) => index === self.findIndex((another) => (0, semver_1.eq)(version, another)))
+        .slice()
+        .sort((i, j) => (0, semver_1.compare)(j, i));
+    const initialSemVersion = (0, essentials_1.conditional)(initialVersion && initialVersion !== latestTag && new semver_1.SemVer(initialVersion));
+    const firstVersion = versions[0];
+    if (!firstVersion) {
+        return [];
+    }
+    const getTargetVersion = async () => {
+        if (initialVersion === latestTag) {
+            return firstVersion;
+        }
+        if (!(0, utilities_1.isTty)()) {
+            (0, essentials_1.assert)(initialSemVersion, new Error('Missing target version'));
+            return initialSemVersion;
+        }
+        const { version } = await inquirer_1.default.prompt({
+            type: 'list',
+            message: 'Choose the alteration target version',
+            name: 'version',
+            choices: versions.map((semVersion) => ({
+                name: semVersion.version,
+                value: semVersion,
+            })),
+        }, {
+            version: initialSemVersion,
+        });
+        return version;
+    };
+    const targetVersion = await getTargetVersion();
+    utilities_1.log.info(`Deploy target ${chalk_1.default.green(targetVersion.version)}`);
+    return alterations.filter(({ filename }) => {
+        const version = getVersionFromFilename(filename);
+        return version && !(0, semver_1.gt)(version, targetVersion);
+    });
+};
+exports.chooseAlterationsByVersion = chooseAlterationsByVersion;

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

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

package/lib/commands/database/config.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const schemas_1 = require("@logto/schemas");
+const essentials_1 = require("@silverhand/essentials");
+const chalk_1 = __importDefault(require("chalk"));
+const database_1 = require("../../database");
+const logto_config_1 = require("../../queries/logto-config");
+const utilities_1 = require("../../utilities");
+const validKeysDisplay = chalk_1.default.green(schemas_1.logtoConfigKeys.join(', '));
+const validateKeys = (keys) => {
+    const invalidKey = (Array.isArray(keys) ? keys : [keys]).find(
+    // Using `.includes()` will result a type error
+    // eslint-disable-next-line unicorn/prefer-includes
+    (key) => !schemas_1.logtoConfigKeys.some((element) => element === key));
+    if (invalidKey) {
+        utilities_1.log.error(`Invalid config key ${chalk_1.default.red(invalidKey)} found, expected one of ${validKeysDisplay}`);
+    }
+};
+const getConfig = {
+    command: 'get <key> [keys...]',
+    describe: 'Get config value(s) of the given key(s) in Logto database',
+    builder: (yargs) => yargs
+        .positional('key', {
+        describe: `The key to get from database, one of ${validKeysDisplay}`,
+        type: 'string',
+        demandOption: true,
+    })
+        .positional('keys', {
+        describe: 'The additional keys to get from database',
+        type: 'string',
+        array: true,
+        default: [],
+    }),
+    handler: async ({ key, keys }) => {
+        const queryKeys = (0, essentials_1.deduplicate)([key, ...keys]);
+        validateKeys(queryKeys);
+        const pool = await (0, database_1.createPoolFromConfig)();
+        const { rows } = await (0, logto_config_1.getRowsByKeys)(pool, queryKeys);
+        await pool.end();
+        console.log(queryKeys
+            .map((currentKey) => {
+            const value = rows.find(({ key }) => currentKey === key)?.value;
+            return (chalk_1.default.magenta(currentKey) +
+                '=' +
+                (value === undefined ? chalk_1.default.gray(value) : chalk_1.default.green(JSON.stringify(value))));
+        })
+            .join('\n'));
+    },
+};
+const setConfig = {
+    command: 'set <key> <value>',
+    describe: 'Set config value of the given key in Logto database',
+    builder: (yargs) => yargs
+        .positional('key', {
+        describe: `The key to get from database, one of ${validKeysDisplay}`,
+        type: 'string',
+        demandOption: true,
+    })
+        .positional('value', {
+        describe: 'The value to set, should be a valid JSON string',
+        type: 'string',
+        demandOption: true,
+    }),
+    handler: async ({ key, value }) => {
+        validateKeys(key);
+        const guarded = schemas_1.logtoConfigGuards[key].parse(JSON.parse(value));
+        const pool = await (0, database_1.createPoolFromConfig)();
+        await (0, logto_config_1.updateValueByKey)(pool, key, guarded);
+        await pool.end();
+        utilities_1.log.info(`Update ${chalk_1.default.green(key)} succeeded`);
+    },
+};
+const config = {
+    command: ['config', 'configs'],
+    describe: 'Commands for Logto database config',
+    builder: (yargs) => yargs.command(getConfig).command(setConfig).demandCommand(1),
+    handler: essentials_1.noop,
+};
+exports.default = config;

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

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

package/lib/commands/database/index.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const essentials_1 = require("@silverhand/essentials");
+const alteration_1 = __importDefault(require("./alteration"));
+const config_1 = __importDefault(require("./config"));
+const seed_1 = __importDefault(require("./seed"));
+const database = {
+    command: ['database', 'db'],
+    describe: 'Commands for Logto database',
+    builder: (yargs) => yargs.command(config_1.default).command(seed_1.default).command(alteration_1.default).demandCommand(1),
+    handler: essentials_1.noop,
+};
+exports.default = database;

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

@@ -0,0 +1,10 @@
+import { DatabasePool } from 'slonik';
+import { CommandModule } from 'yargs';
+declare const seedChoices: readonly ["all", "oidc"];
+declare type SeedChoice = typeof seedChoices[number];
+export declare const seedByPool: (pool: DatabasePool, type: SeedChoice) => Promise<void>;
+declare const seed: CommandModule<Record<string, unknown>, {
+    type: string;
+    swe?: boolean;
+}>;
+export default seed;