@logto/cli 1.0.0-beta.11

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

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedByPool = void 0;
+const promises_1 = require("fs/promises");
+const path_1 = __importDefault(require("path"));
+const schemas_1 = require("@logto/schemas");
+const shared_1 = require("@logto/shared");
+const chalk_1 = __importDefault(require("chalk"));
+const slonik_1 = require("slonik");
+const slonik_sql_tag_raw_1 = require("slonik-sql-tag-raw");
+const zod_1 = require("zod");
+const database_1 = require("../../../database");
+const logto_config_1 = require("../../../queries/logto-config");
+const utilities_1 = require("../../../utilities");
+const alteration_1 = require("../alteration");
+const oidc_config_1 = require("./oidc-config");
+const createTables = async (connection) => {
+    const tableDirectory = (0, utilities_1.getPathInModule)('@logto/schemas', 'tables');
+    const directoryFiles = await (0, promises_1.readdir)(tableDirectory);
+    const tableFiles = directoryFiles.filter((file) => file.endsWith('.sql'));
+    const queries = await Promise.all(tableFiles.map(async (file) => [
+        file,
+        await (0, promises_1.readFile)(path_1.default.join(tableDirectory, file), 'utf8'),
+    ]));
+    // Await in loop is intended for better error handling
+    for (const [, query] of queries) {
+        // eslint-disable-next-line no-await-in-loop
+        await connection.query((0, slonik_1.sql) `${(0, slonik_sql_tag_raw_1.raw)(query)}`);
+    }
+};
+const seedTables = async (connection) => {
+    const { managementResource, defaultSignInExperience, createDefaultSetting, createDemoAppApplication, defaultRole, } = schemas_1.seeds;
+    await Promise.all([
+        connection.query((0, database_1.insertInto)(managementResource, 'resources')),
+        connection.query((0, database_1.insertInto)(createDefaultSetting(), 'settings')),
+        connection.query((0, database_1.insertInto)(defaultSignInExperience, 'sign_in_experiences')),
+        connection.query((0, database_1.insertInto)(createDemoAppApplication((0, shared_1.buildApplicationSecret)()), 'applications')),
+        connection.query((0, database_1.insertInto)(defaultRole, 'roles')),
+        (0, logto_config_1.updateDatabaseTimestamp)(connection, await (0, alteration_1.getLatestAlterationTimestamp)()),
+    ]);
+};
+const seedOidcConfigs = async (pool) => {
+    const configGuard = zod_1.z.object({
+        key: zod_1.z.nativeEnum(schemas_1.LogtoOidcConfigKey),
+        value: zod_1.z.unknown(),
+    });
+    const { rows } = await (0, logto_config_1.getRowsByKeys)(pool, Object.values(schemas_1.LogtoOidcConfigKey));
+    // Filter out valid keys that hold a valid value
+    const result = await Promise.all(rows.map(async (row) => {
+        try {
+            const { key, value } = await configGuard.parseAsync(row);
+            await schemas_1.logtoConfigGuards[key].parseAsync(value);
+            return key;
+        }
+        catch { }
+    }));
+    const existingKeys = new Set(result.filter(Boolean));
+    const validOptions = Object.values(schemas_1.LogtoOidcConfigKey).filter((key) => {
+        const included = existingKeys.has(key);
+        if (included) {
+            utilities_1.log.info(`Key ${chalk_1.default.green(key)} exists, skipping`);
+        }
+        return !included;
+    });
+    // The awaits in loop is intended since we'd like to log info in sequence
+    /* eslint-disable no-await-in-loop */
+    for (const key of validOptions) {
+        const { value, fromEnv } = await oidc_config_1.oidcConfigReaders[key]();
+        if (fromEnv) {
+            utilities_1.log.info(`Read config ${chalk_1.default.green(key)} from env`);
+        }
+        else {
+            utilities_1.log.info(`Generated config ${chalk_1.default.green(key)}`);
+        }
+        await (0, logto_config_1.updateValueByKey)(pool, key, value);
+    }
+    /* eslint-enable no-await-in-loop */
+    utilities_1.log.succeed('Seed OIDC config');
+};
+const seedChoices = Object.freeze(['all', 'oidc']);
+const seedByPool = async (pool, type) => {
+    await pool.transaction(async (connection) => {
+        if (type !== 'oidc') {
+            await (0, utilities_1.oraPromise)(createTables(connection), {
+                text: 'Create tables',
+                prefixText: chalk_1.default.blue('[info]'),
+            });
+            await (0, utilities_1.oraPromise)(seedTables(connection), {
+                text: 'Seed data',
+                prefixText: chalk_1.default.blue('[info]'),
+            });
+        }
+        await seedOidcConfigs(connection);
+    });
+};
+exports.seedByPool = seedByPool;
+const seed = {
+    command: 'seed [type]',
+    describe: 'Create database then seed tables and data',
+    builder: (yargs) => yargs
+        .option('swe', {
+        describe: 'Skip the seeding process when Logto configs table exists',
+        alias: 'skip-when-exists',
+        type: 'boolean',
+    })
+        .positional('type', {
+        describe: 'Optional seed type',
+        type: 'string',
+        choices: seedChoices,
+        default: 'all',
+    }),
+    handler: async ({ type, swe }) => {
+        const pool = await (0, database_1.createPoolAndDatabaseIfNeeded)();
+        if (swe && (await (0, logto_config_1.doesConfigsTableExist)(pool))) {
+            utilities_1.log.info('Seeding skipped');
+            await pool.end();
+            return;
+        }
+        try {
+            // Cannot avoid `as` since the official type definition of `yargs` doesn't work.
+            // The value of `type` can be ensured, so it's safe to use `as` here.
+            // eslint-disable-next-line no-restricted-syntax
+            await (0, exports.seedByPool)(pool, type);
+        }
+        catch (error) {
+            console.error(error);
+            console.log();
+            utilities_1.log.warn('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.');
+        }
+        await pool.end();
+    },
+};
+exports.default = seed;

package/lib/commands/database/seed/oidc-config.d.ts

@@ -0,0 +1,12 @@
+import { LogtoOidcConfigKey, LogtoOidcConfigType } from '@logto/schemas';
+/**
+ * Each config reader will do the following things in order:
+ * 1. Try to read value from env (mimic the behavior from the original core)
+ * 2. Generate value if #1 doesn't work
+ */
+export declare const oidcConfigReaders: {
+    [key in LogtoOidcConfigKey]: () => Promise<{
+        value: LogtoOidcConfigType[key];
+        fromEnv: boolean;
+    }>;
+};

package/lib/commands/database/seed/oidc-config.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oidcConfigReaders = void 0;
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const util_1 = require("util");
+const schemas_1 = require("@logto/schemas");
+const essentials_1 = require("@silverhand/essentials");
+const nanoid_1 = require("nanoid");
+const isBase64FormatPrivateKey = (key) => !key.includes('-');
+/**
+ * Each config reader will do the following things in order:
+ * 1. Try to read value from env (mimic the behavior from the original core)
+ * 2. Generate value if #1 doesn't work
+ */
+exports.oidcConfigReaders = {
+    /**
+     * Try to read private keys with the following order:
+     *
+     * 1. From `process.env.OIDC_PRIVATE_KEYS`.
+     * 2. Fetch path from `process.env.OIDC_PRIVATE_KEY_PATHS` then read from that path.
+     *
+     *
+     * @returns The private keys for OIDC provider.
+     * @throws An error when failed to read a private key.
+     */
+    [schemas_1.LogtoOidcConfigKey.PrivateKeys]: async () => {
+        // Direct keys in env
+        const privateKeys = (0, essentials_1.getEnvAsStringArray)('OIDC_PRIVATE_KEYS');
+        if (privateKeys.length > 0) {
+            return {
+                value: privateKeys.map((key) => {
+                    if (isBase64FormatPrivateKey(key)) {
+                        return Buffer.from(key, 'base64').toString('utf8');
+                    }
+                    return key;
+                }),
+                fromEnv: true,
+            };
+        }
+        // Read keys from files
+        const privateKeyPaths = (0, essentials_1.getEnvAsStringArray)('OIDC_PRIVATE_KEY_PATHS');
+        if (privateKeyPaths.length > 0) {
+            return {
+                value: await Promise.all(privateKeyPaths.map(async (path) => (0, promises_1.readFile)(path, 'utf8'))),
+                fromEnv: true,
+            };
+        }
+        // Generate a new key
+        const { privateKey } = await (0, util_1.promisify)(crypto_1.generateKeyPair)('rsa', {
+            modulusLength: 4096,
+            publicKeyEncoding: {
+                type: 'spki',
+                format: 'pem',
+            },
+            privateKeyEncoding: {
+                type: 'pkcs8',
+                format: 'pem',
+            },
+        });
+        return {
+            value: [privateKey],
+            fromEnv: false,
+        };
+    },
+    [schemas_1.LogtoOidcConfigKey.CookieKeys]: async () => {
+        const envKey = 'OIDC_COOKIE_KEYS';
+        const keys = (0, essentials_1.getEnvAsStringArray)(envKey);
+        return { value: keys.length > 0 ? keys : [(0, nanoid_1.nanoid)()], fromEnv: keys.length > 0 };
+    },
+    [schemas_1.LogtoOidcConfigKey.RefreshTokenReuseInterval]: async () => {
+        const envKey = 'OIDC_REFRESH_TOKEN_REUSE_INTERVAL';
+        const raw = Number((0, essentials_1.getEnv)(envKey));
+        const value = Math.max(3, raw || 0);
+        return { value, fromEnv: raw === value };
+    },
+};

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

@@ -0,0 +1,14 @@
+import { CommandModule } from 'yargs';
+export declare type InstallArgs = {
+    path?: string;
+    skipSeed: boolean;
+    officialConnectors?: boolean;
+    downloadUrl?: string;
+};
+declare const install: CommandModule<unknown, {
+    p?: string;
+    ss: boolean;
+    oc?: boolean;
+    du?: string;
+}>;
+export default install;

package/lib/commands/install/index.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const database_1 = require("../../database");
+const utilities_1 = require("../../utilities");
+const utils_1 = require("../connector/utils");
+const utils_2 = require("./utils");
+const installLogto = async ({ path, skipSeed, officialConnectors, downloadUrl }) => {
+    (0, utils_2.validateNodeVersion)();
+    // Get instance path
+    const instancePath = await (0, utils_2.inquireInstancePath)(path);
+    // Validate if user has a valid database
+    await (0, utils_2.validateDatabase)();
+    // Download and decompress
+    const tarPath = !downloadUrl || (0, utils_2.isUrl)(downloadUrl) ? await (0, utils_2.downloadRelease)(downloadUrl) : downloadUrl;
+    await (0, utils_2.decompress)(instancePath, tarPath);
+    // Seed database
+    if (skipSeed) {
+        utilities_1.log.info(`Skipped database seeding.\n\n' + '  You can use the ${chalk_1.default.green('db seed')} command to seed database when ready.\n`);
+    }
+    else {
+        await (0, utils_2.seedDatabase)(instancePath);
+    }
+    // Save to dot env
+    await (0, utils_2.createEnv)(instancePath, await (0, database_1.getDatabaseUrlFromConfig)());
+    // Add official connectors
+    if (await (0, utils_2.inquireOfficialConnectors)(officialConnectors)) {
+        await (0, utils_1.addOfficialConnectors)(instancePath);
+    }
+    else {
+        utilities_1.log.info('Skipped adding official connectors.\n\n' +
+            `  You can use the ${chalk_1.default.green('connector add')} command to add connectors at any time.\n`);
+    }
+    // Finale
+    (0, utils_2.logFinale)(instancePath);
+};
+const install = {
+    command: ['init', 'i', 'install'],
+    describe: 'Download and run the latest Logto release',
+    builder: (yargs) => yargs.options({
+        p: {
+            alias: 'path',
+            describe: 'Path of Logto, must be a non-existing path',
+            type: 'string',
+        },
+        ss: {
+            alias: 'skip-seed',
+            describe: 'Skip Logto database seeding',
+            type: 'boolean',
+            default: false,
+        },
+        oc: {
+            alias: 'official-connectors',
+            describe: 'Add official connectors after downloading Logto',
+            type: 'boolean',
+        },
+        du: {
+            alias: 'download-url',
+            describe: 'URL for downloading Logto, can be a local path to tar',
+            type: 'string',
+            hidden: true,
+        },
+    }),
+    handler: async ({ p, ss, oc, du }) => {
+        await installLogto({ path: p, skipSeed: ss, officialConnectors: oc, downloadUrl: du });
+    },
+};
+exports.default = install;

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

@@ -0,0 +1,11 @@
+export declare const defaultPath: string;
+export declare const validateNodeVersion: () => void;
+export declare const inquireInstancePath: (initialPath?: string) => Promise<string>;
+export declare const validateDatabase: () => Promise<void>;
+export declare const downloadRelease: (url?: string) => Promise<string>;
+export declare const decompress: (toPath: string, tarPath: string) => Promise<void>;
+export declare const seedDatabase: (instancePath: string) => Promise<void>;
+export declare const createEnv: (instancePath: string, databaseUrl: string) => Promise<void>;
+export declare const logFinale: (instancePath: string) => void;
+export declare const inquireOfficialConnectors: (initialAnswer?: boolean) => Promise<boolean>;
+export declare const isUrl: (string: string) => boolean;

package/lib/commands/install/utils.js

@@ -0,0 +1,176 @@
+"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.isUrl = exports.inquireOfficialConnectors = exports.logFinale = exports.createEnv = exports.seedDatabase = exports.decompress = exports.downloadRelease = exports.validateDatabase = exports.inquireInstancePath = exports.validateNodeVersion = exports.defaultPath = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+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 semver = __importStar(require("semver"));
+const tar_1 = __importDefault(require("tar"));
+const database_1 = require("../../database");
+const utilities_1 = require("../../utilities");
+const seed_1 = require("../database/seed");
+exports.defaultPath = path_1.default.join(os_1.default.homedir(), 'logto');
+const pgRequired = new semver.SemVer('14.0.0');
+const validateNodeVersion = () => {
+    const required = new semver.SemVer('16.0.0');
+    const current = new semver.SemVer((0, child_process_1.execSync)('node -v', { encoding: 'utf8', stdio: 'pipe' }));
+    if (required.compare(current) > 0) {
+        utilities_1.log.error(`Logto requires NodeJS >=${required.version}, but ${current.version} found.`);
+    }
+    if (current.major > required.major) {
+        utilities_1.log.warn(`Logto is tested under NodeJS ^${required.version}, but version ${current.version} found.`);
+    }
+};
+exports.validateNodeVersion = validateNodeVersion;
+const validatePath = (value) => (0, fs_1.existsSync)(path_1.default.resolve(value))
+    ? `The path ${chalk_1.default.green(value)} already exists, please try another.`
+    : true;
+const inquireInstancePath = async (initialPath) => {
+    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 should we create your Logto instance?',
+        type: 'input',
+        default: exports.defaultPath,
+        filter: (value) => value.trim(),
+        validate: validatePath,
+    }, { instancePath: initialPath });
+    // Validate for initialPath
+    const validated = validatePath(instancePath);
+    if (validated !== true) {
+        utilities_1.log.error(validated);
+    }
+    return instancePath;
+};
+exports.inquireInstancePath = inquireInstancePath;
+const validateDatabase = async () => {
+    if (utilities_1.cliConfig.has(utilities_1.ConfigKey.DatabaseUrl) || !(0, utilities_1.isTty)()) {
+        return;
+    }
+    const { hasPostgresUrl } = await inquirer_1.default.prompt({
+        name: 'hasPostgresUrl',
+        message: `Logto requires PostgreSQL >=${pgRequired.version} but cannot find in the current environment.\n  Do you have a remote PostgreSQL instance ready?`,
+        type: 'confirm',
+        when: () => {
+            const pgOutput = (0, utilities_1.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]);
+            return !pgCurrent || pgCurrent.compare(pgRequired) < 0;
+        },
+    });
+    if (hasPostgresUrl === false) {
+        utilities_1.log.error('Logto requires a Postgres instance to run.');
+    }
+};
+exports.validateDatabase = validateDatabase;
+const downloadRelease = async (url) => {
+    const tarFilePath = path_1.default.resolve(os_1.default.tmpdir(), './logto.tar.gz');
+    utilities_1.log.info(`Download Logto to ${tarFilePath}`);
+    await (0, utilities_1.downloadFile)(url ?? 'https://github.com/logto-io/logto/releases/latest/download/logto.tar.gz', tarFilePath);
+    return tarFilePath;
+};
+exports.downloadRelease = downloadRelease;
+const decompress = async (toPath, tarPath) => {
+    const run = async () => {
+        try {
+            await (0, promises_1.mkdir)(toPath);
+            await tar_1.default.extract({ file: tarPath, cwd: toPath, strip: 1 });
+        }
+        catch (error) {
+            utilities_1.log.error(error);
+        }
+    };
+    return (0, utilities_1.oraPromise)(run(), {
+        text: `Decompress to ${toPath}`,
+        prefixText: chalk_1.default.blue('[info]'),
+    }, true);
+};
+exports.decompress = decompress;
+const seedDatabase = async (instancePath) => {
+    try {
+        const pool = await (0, database_1.createPoolAndDatabaseIfNeeded)();
+        await (0, seed_1.seedByPool)(pool, 'all');
+        await pool.end();
+    }
+    catch (error) {
+        console.error(error);
+        await (0, utilities_1.oraPromise)((0, fs_extra_1.remove)(instancePath), {
+            text: 'Clean up',
+            prefixText: chalk_1.default.blue('[info]'),
+        });
+        utilities_1.log.error('Error occurred during seeding your Logto database. Nothing has changed since the seeding process was in a transaction.\n\n' +
+            `  To skip the database seeding, append ${chalk_1.default.green('--skip-seed')} to the command options.`);
+    }
+};
+exports.seedDatabase = seedDatabase;
+const createEnv = async (instancePath, databaseUrl) => {
+    const dotEnvPath = path_1.default.resolve(instancePath, '.env');
+    await (0, fs_extra_1.writeFile)(dotEnvPath, `DB_URL=${databaseUrl}`, {
+        encoding: 'utf8',
+    });
+    utilities_1.log.info(`Saved database URL to ${chalk_1.default.blue(dotEnvPath)}`);
+};
+exports.createEnv = createEnv;
+const logFinale = (instancePath) => {
+    const startCommand = `cd ${instancePath} && npm start`;
+    utilities_1.log.info(`Use the command below to start Logto. Happy hacking!\n\n  ${chalk_1.default.green(startCommand)}`);
+};
+exports.logFinale = logFinale;
+const inquireOfficialConnectors = async (initialAnswer) => {
+    const { value } = await inquirer_1.default.prompt({
+        name: 'value',
+        message: 'Do you want to add official connectors?',
+        type: 'confirm',
+        default: true,
+    }, { value: initialAnswer });
+    return value;
+};
+exports.inquireOfficialConnectors = inquireOfficialConnectors;
+const isUrl = (string) => {
+    try {
+        // On purpose to test
+        // eslint-disable-next-line no-new
+        new URL(string);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+exports.isUrl = isUrl;

package/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const connectorDirectory = "connectors";

package/lib/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectorDirectory = void 0;
+exports.connectorDirectory = 'connectors';

package/lib/database.d.ts

@@ -0,0 +1,12 @@
+import { SchemaLike } from '@logto/schemas';
+export declare const defaultDatabaseUrl = "postgresql://localhost:5432/logto";
+export declare const getDatabaseUrlFromConfig: () => Promise<string>;
+export declare const createPoolFromConfig: () => Promise<import("slonik").DatabasePool>;
+/**
+ * Create a database pool with the URL in CLI config; if no URL found, prompt to input.
+ * If the given database does not exists, it will try to create a new database by connecting to the maintenance database `postgres`.
+ *
+ * @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>;

package/lib/database.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertInto = exports.createPoolAndDatabaseIfNeeded = exports.createPoolFromConfig = exports.getDatabaseUrlFromConfig = exports.defaultDatabaseUrl = void 0;
+const shared_1 = require("@logto/shared");
+const decamelize_1 = __importDefault(require("decamelize"));
+const slonik_1 = require("slonik");
+const slonik_interceptor_preset_1 = require("slonik-interceptor-preset");
+const zod_1 = require("zod");
+const utilities_1 = require("./utilities");
+exports.defaultDatabaseUrl = 'postgresql://localhost:5432/logto';
+const getDatabaseUrlFromConfig = async () => (await (0, utilities_1.getCliConfigWithPrompt)({
+    key: utilities_1.ConfigKey.DatabaseUrl,
+    readableKey: 'Logto database URL',
+    defaultValue: exports.defaultDatabaseUrl,
+})) ?? '';
+exports.getDatabaseUrlFromConfig = getDatabaseUrlFromConfig;
+const createPoolFromConfig = async () => {
+    const databaseUrl = await (0, exports.getDatabaseUrlFromConfig)();
+    return (0, slonik_1.createPool)(databaseUrl, {
+        interceptors: (0, slonik_interceptor_preset_1.createInterceptors)(),
+    });
+};
+exports.createPoolFromConfig = createPoolFromConfig;
+/**
+ * Create a database pool with the URL in CLI config; if no URL found, prompt to input.
+ * If the given database does not exists, it will try to create a new database by connecting to the maintenance database `postgres`.
+ *
+ * @returns A new database pool with the database URL in config.
+ */
+const createPoolAndDatabaseIfNeeded = async () => {
+    try {
+        return await (0, exports.createPoolFromConfig)();
+    }
+    catch (error) {
+        const result = zod_1.z.object({ code: zod_1.z.string() }).safeParse(error);
+        // Database does not exist, try to create one
+        // https://www.postgresql.org/docs/14/errcodes-appendix.html
+        if (!(result.success && result.data.code === '3D000')) {
+            utilities_1.log.error(error);
+        }
+        const databaseUrl = await (0, exports.getDatabaseUrlFromConfig)();
+        const dsn = (0, slonik_1.parseDsn)(databaseUrl);
+        // It's ok to fall back to '?' since:
+        // - Database name is required to connect in the previous pool
+        // - It will throw error when creating database using '?'
+        const databaseName = dsn.databaseName ?? '?';
+        const maintenancePool = await (0, slonik_1.createPool)((0, slonik_1.stringifyDsn)({ ...dsn, databaseName: 'postgres' }));
+        await maintenancePool.query((0, slonik_1.sql) `
+      create database ${slonik_1.sql.identifier([databaseName])}
+        with
+        encoding = 'UTF8'
+        connection_limit = -1;
+    `);
+        await maintenancePool.end();
+        utilities_1.log.succeed(`Created database ${databaseName}`);
+        return (0, exports.createPoolFromConfig)();
+    }
+};
+exports.createPoolAndDatabaseIfNeeded = createPoolAndDatabaseIfNeeded;
+const insertInto = (object, table) => {
+    const keys = Object.keys(object);
+    return (0, slonik_1.sql) `
+    insert into ${slonik_1.sql.identifier([table])}
+    (${slonik_1.sql.join(keys.map((key) => slonik_1.sql.identifier([(0, decamelize_1.default)(key)])), (0, slonik_1.sql) `, `)})
+    values (${slonik_1.sql.join(keys.map((key) => (0, shared_1.convertToPrimitiveOrSql)(key, object[key] ?? null)), (0, slonik_1.sql) `, `)})
+  `;
+};
+exports.insertInto = insertInto;

package/lib/index.d.ts

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

package/lib/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const yargs_1 = __importDefault(require("yargs"));
+const helpers_1 = require("yargs/helpers");
+const connector_1 = __importDefault(require("./commands/connector"));
+const database_1 = __importDefault(require("./commands/database"));
+const install_1 = __importDefault(require("./commands/install"));
+const package_json_1 = require("./package-json");
+const utilities_1 = require("./utilities");
+void (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
+    .version(false)
+    .option('env', {
+    alias: ['e', 'env-file'],
+    describe: 'The path to your `.env` file',
+    type: 'string',
+})
+    .option('db', {
+    alias: ['db-url', 'database-url'],
+    describe: 'The Postgres URL to Logto database',
+    type: 'string',
+})
+    .option('version', {
+    alias: 'v',
+    describe: 'Print Logto CLI version',
+    type: 'boolean',
+    global: false,
+})
+    .middleware(({ version }) => {
+    if (version) {
+        console.log(package_json_1.packageJson.name + ' v' + package_json_1.packageJson.version);
+        // eslint-disable-next-line unicorn/no-process-exit
+        process.exit(0);
+    }
+}, true)
+    .middleware(({ env, db: databaseUrl }) => {
+    dotenv_1.default.config({ path: env });
+    const initialDatabaseUrl = databaseUrl ?? process.env[utilities_1.ConfigKey.DatabaseUrl];
+    if (initialDatabaseUrl) {
+        utilities_1.cliConfig.set(utilities_1.ConfigKey.DatabaseUrl, initialDatabaseUrl);
+    }
+})
+    .command(install_1.default)
+    .command(database_1.default)
+    .command(connector_1.default)
+    .demandCommand(1)
+    .showHelpOnFail(false, `Specify ${chalk_1.default.green('--help')} for available options`)
+    .strict()
+    .parserConfiguration({
+    'dot-notation': false,
+})
+    .parse();