@logto/cli 1.0.0-beta.16 → 1.0.0-beta.18

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

@@ -1,102 +1,106 @@
-"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");
+import { readdir, readFile } from 'fs/promises';
+import path from 'path';
+import { generateStandardId } from '@logto/core-kit';
+import { logtoConfigGuards, LogtoOidcConfigKey, managementResource, defaultSignInExperience, createDefaultSetting, createDemoAppApplication, defaultRole, } from '@logto/schemas';
+import { Hooks } from '@logto/schemas/models';
+import chalk from 'chalk';
+import { sql } from 'slonik';
+import { raw } from 'slonik-sql-tag-raw';
+import { z } from 'zod';
+import { createPoolAndDatabaseIfNeeded, insertInto } from '../../../database.js';
+import { getRowsByKeys, doesConfigsTableExist, updateDatabaseTimestamp, updateValueByKey, } from '../../../queries/logto-config.js';
+import { getPathInModule, log, oraPromise } from '../../../utilities.js';
+import { getLatestAlterationTimestamp } from '../alteration/index.js';
+import { getAlterationDirectory } from '../alteration/utils.js';
+import { oidcConfigReaders } from './oidc-config.js';
 const createTables = async (connection) => {
-    const tableDirectory = (0, utilities_1.getPathInModule)('@logto/schemas', 'tables');
-    const directoryFiles = await (0, promises_1.readdir)(tableDirectory);
+    const tableDirectory = getPathInModule('@logto/schemas', 'tables');
+    const directoryFiles = await 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 readFile(path.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)}`);
+        await connection.query(sql `${raw(query)}`);
+    }
+    for (const table of [Hooks]) {
+        // eslint-disable-next-line no-await-in-loop
+        await connection.query(sql `${raw(table.raw)}`);
     }
 };
-const seedTables = async (connection) => {
-    const { managementResource, defaultSignInExperience, createDefaultSetting, createDemoAppApplication, defaultRole, } = schemas_1.seeds;
+const seedTables = async (connection, latestTimestamp) => {
     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)()),
+        connection.query(insertInto(managementResource, 'resources')),
+        connection.query(insertInto(createDefaultSetting(), 'settings')),
+        connection.query(insertInto(defaultSignInExperience, 'sign_in_experiences')),
+        connection.query(insertInto(createDemoAppApplication(generateStandardId()), 'applications')),
+        connection.query(insertInto(defaultRole, 'roles')),
+        updateDatabaseTimestamp(connection, latestTimestamp),
     ]);
 };
 const seedOidcConfigs = async (pool) => {
-    const configGuard = zod_1.z.object({
-        key: zod_1.z.nativeEnum(schemas_1.LogtoOidcConfigKey),
-        value: zod_1.z.unknown(),
+    const configGuard = z.object({
+        key: z.nativeEnum(LogtoOidcConfigKey),
+        value: z.unknown(),
     });
-    const { rows } = await (0, logto_config_1.getRowsByKeys)(pool, Object.values(schemas_1.LogtoOidcConfigKey));
+    const { rows } = await getRowsByKeys(pool, Object.values(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);
+            await logtoConfigGuards[key].parseAsync(value);
             return key;
         }
         catch { }
     }));
     const existingKeys = new Set(result.filter(Boolean));
-    const validOptions = Object.values(schemas_1.LogtoOidcConfigKey).filter((key) => {
+    const validOptions = Object.values(LogtoOidcConfigKey).filter((key) => {
         const included = existingKeys.has(key);
         if (included) {
-            utilities_1.log.info(`Key ${chalk_1.default.green(key)} exists, skipping`);
+            log.info(`Key ${chalk.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]();
+        const { value, fromEnv } = await oidcConfigReaders[key]();
         if (fromEnv) {
-            utilities_1.log.info(`Read config ${chalk_1.default.green(key)} from env`);
+            log.info(`Read config ${chalk.green(key)} from env`);
         }
         else {
-            utilities_1.log.info(`Generated config ${chalk_1.default.green(key)}`);
+            log.info(`Generated config ${chalk.green(key)}`);
         }
-        await (0, logto_config_1.updateValueByKey)(pool, key, value);
+        await updateValueByKey(pool, key, value);
     }
     /* eslint-enable no-await-in-loop */
-    utilities_1.log.succeed('Seed OIDC config');
+    log.succeed('Seed OIDC config');
 };
 const seedChoices = Object.freeze(['all', 'oidc']);
-const seedByPool = async (pool, type) => {
+export const seedByPool = async (pool, type) => {
     await pool.transaction(async (connection) => {
         if (type !== 'oidc') {
-            await (0, utilities_1.oraPromise)(createTables(connection), {
+            // Check alteration scripts available in order to insert correct timestamp
+            const latestTimestamp = await getLatestAlterationTimestamp();
+            if (latestTimestamp < 1) {
+                throw new Error(`No alteration script found when seeding the database.\n` +
+                    `Please check \`${getAlterationDirectory()}\` to see if there are alteration scripts available.\n`);
+            }
+            await oraPromise(createTables(connection), {
                 text: 'Create tables',
-                prefixText: chalk_1.default.blue('[info]'),
+                prefixText: chalk.blue('[info]'),
             });
-            await (0, utilities_1.oraPromise)(seedTables(connection), {
+            await oraPromise(seedTables(connection, latestTimestamp), {
                 text: 'Seed data',
-                prefixText: chalk_1.default.blue('[info]'),
+                prefixText: chalk.blue('[info]'),
             });
         }
         await seedOidcConfigs(connection);
     });
 };
-exports.seedByPool = seedByPool;
 const seed = {
     command: 'seed [type]',
     describe: 'Create database then seed tables and data',
@@ -113,9 +117,9 @@ const seed = {
         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');
+        const pool = await createPoolAndDatabaseIfNeeded();
+        if (swe && (await doesConfigsTableExist(pool))) {
+            log.info('Seeding skipped');
             await pool.end();
             return;
         }
@@ -123,16 +127,16 @@ const seed = {
             // 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);
+            await seedByPool(pool, type);
         }
         catch (error) {
             console.error(error);
             console.log();
-            utilities_1.log.warn('Error ocurred during seeding your database.\n\n' +
+            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;
+export default seed;

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

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.oidcConfigReaders = void 0;
-const promises_1 = require("fs/promises");
-const schemas_1 = require("@logto/schemas");
-const essentials_1 = require("@silverhand/essentials");
-const utilities_1 = require("../utilities");
+import { readFile } from 'fs/promises';
+import { LogtoOidcConfigKey } from '@logto/schemas';
+import { getEnv, getEnvAsStringArray } from '@silverhand/essentials';
+import { generateOidcCookieKey, generateOidcPrivateKey } from '../utilities.js';
 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 = {
+export const oidcConfigReaders = {
     /**
      * Try to read private keys with the following order:
      *
@@ -22,9 +19,9 @@ exports.oidcConfigReaders = {
      * @returns The private keys for OIDC provider.
      * @throws An error when failed to read a private key.
      */
-    [schemas_1.LogtoOidcConfigKey.PrivateKeys]: async () => {
+    [LogtoOidcConfigKey.PrivateKeys]: async () => {
         // Direct keys in env
-        const privateKeys = (0, essentials_1.getEnvAsStringArray)('OIDC_PRIVATE_KEYS');
+        const privateKeys = getEnvAsStringArray('OIDC_PRIVATE_KEYS');
         if (privateKeys.length > 0) {
             return {
                 value: privateKeys.map((key) => {
@@ -37,26 +34,26 @@ exports.oidcConfigReaders = {
             };
         }
         // Read keys from files
-        const privateKeyPaths = (0, essentials_1.getEnvAsStringArray)('OIDC_PRIVATE_KEY_PATHS');
+        const privateKeyPaths = getEnvAsStringArray('OIDC_PRIVATE_KEY_PATHS');
         if (privateKeyPaths.length > 0) {
             return {
-                value: await Promise.all(privateKeyPaths.map(async (path) => (0, promises_1.readFile)(path, 'utf8'))),
+                value: await Promise.all(privateKeyPaths.map(async (path) => readFile(path, 'utf8'))),
                 fromEnv: true,
             };
         }
         return {
-            value: [await (0, utilities_1.generateOidcPrivateKey)()],
+            value: [await generateOidcPrivateKey()],
             fromEnv: false,
         };
     },
-    [schemas_1.LogtoOidcConfigKey.CookieKeys]: async () => {
+    [LogtoOidcConfigKey.CookieKeys]: async () => {
         const envKey = 'OIDC_COOKIE_KEYS';
-        const keys = (0, essentials_1.getEnvAsStringArray)(envKey);
-        return { value: keys.length > 0 ? keys : [(0, utilities_1.generateOidcCookieKey)()], fromEnv: keys.length > 0 };
+        const keys = getEnvAsStringArray(envKey);
+        return { value: keys.length > 0 ? keys : [generateOidcCookieKey()], fromEnv: keys.length > 0 };
     },
-    [schemas_1.LogtoOidcConfigKey.RefreshTokenReuseInterval]: async () => {
+    [LogtoOidcConfigKey.RefreshTokenReuseInterval]: async () => {
         const envKey = 'OIDC_REFRESH_TOKEN_REUSE_INTERVAL';
-        const raw = Number((0, essentials_1.getEnv)(envKey));
+        const raw = Number(getEnv(envKey));
         const value = Math.max(3, raw || 0);
         return { value, fromEnv: raw === value };
     },

package/lib/commands/database/utilities.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateOidcCookieKey = exports.generateOidcPrivateKey = void 0;
-const crypto_1 = require("crypto");
-const util_1 = require("util");
-const nanoid_1 = require("nanoid");
-const generateOidcPrivateKey = async () => {
-    const { privateKey } = await (0, util_1.promisify)(crypto_1.generateKeyPair)('rsa', {
+import { generateKeyPair } from 'crypto';
+import { promisify } from 'util';
+import { nanoid } from 'nanoid';
+export const generateOidcPrivateKey = async () => {
+    const { privateKey } = await promisify(generateKeyPair)('rsa', {
         modulusLength: 4096,
         publicKeyEncoding: {
             type: 'spki',
@@ -18,6 +15,4 @@ const generateOidcPrivateKey = async () => {
     });
     return privateKey;
 };
-exports.generateOidcPrivateKey = generateOidcPrivateKey;
-const generateOidcCookieKey = () => (0, nanoid_1.nanoid)();
-exports.generateOidcCookieKey = generateOidcCookieKey;
+export const generateOidcCookieKey = () => nanoid();

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

@@ -1,5 +1,5 @@
 import type { CommandModule } from 'yargs';
-export declare type InstallArgs = {
+export type InstallArgs = {
     path?: string;
     skipSeed: boolean;
     officialConnectors?: boolean;

package/lib/commands/install/index.js

@@ -1,41 +1,27 @@
-"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");
+import chalk from 'chalk';
+import { getDatabaseUrlFromConfig } from '../../database.js';
+import { log } from '../../utilities.js';
+import { validateNodeVersion, inquireInstancePath, validateDatabase, downloadRelease, seedDatabase, createEnv, logFinale, decompress, isUrl, } from './utils.js';
 const installLogto = async ({ path, skipSeed, officialConnectors, downloadUrl }) => {
-    (0, utils_2.validateNodeVersion)();
+    validateNodeVersion();
     // Get instance path
-    const instancePath = await (0, utils_2.inquireInstancePath)(path);
+    const instancePath = await inquireInstancePath(path);
     // Validate if user has a valid database
-    await (0, utils_2.validateDatabase)();
+    await 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);
+    const tarPath = !downloadUrl || isUrl(downloadUrl) ? await downloadRelease(downloadUrl) : downloadUrl;
+    await 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`);
+        log.info(`Skipped database seeding.\n\n' + '  You can use the ${chalk.green('db seed')} command to seed database when ready.\n`);
     }
     else {
-        await (0, utils_2.seedDatabase)(instancePath);
+        await 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`);
-    }
+    await createEnv(instancePath, await getDatabaseUrlFromConfig());
     // Finale
-    (0, utils_2.logFinale)(instancePath);
+    logFinale(instancePath);
 };
 const install = {
     command: ['init', 'i', 'install'],
@@ -68,4 +54,4 @@ const install = {
         await installLogto({ path: p, skipSeed: ss, officialConnectors: oc, downloadUrl: du });
     },
 };
-exports.default = install;
+export default install;

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

@@ -7,5 +7,4 @@ export declare const decompress: (toPath: string, tarPath: string) => Promise<vo
 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

@@ -1,94 +1,63 @@
-"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');
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { assert } from '@silverhand/essentials';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import * as semver from 'semver';
+import tar from 'tar';
+import { createPoolAndDatabaseIfNeeded } from '../../database.js';
+import { packageJson } from '../../package-json.js';
+import { cliConfig, ConfigKey, downloadFile, isTty, log, oraPromise, safeExecSync, } from '../../utilities.js';
+import { seedByPool } from '../database/seed/index.js';
+export const defaultPath = path.join(os.homedir(), 'logto');
 const pgRequired = new semver.SemVer('14.0.0');
-const validateNodeVersion = () => {
+export const validateNodeVersion = () => {
     const required = [new semver.SemVer('16.13.0'), new semver.SemVer('18.12.0')];
     const requiredVersionString = required.map((version) => '^' + version.version).join(' || ');
-    const current = new semver.SemVer((0, child_process_1.execSync)('node -v', { encoding: 'utf8', stdio: 'pipe' }));
+    const current = new semver.SemVer(execSync('node -v', { encoding: 'utf8', stdio: 'pipe' }));
     if (required.every((version) => version.major !== current.major)) {
-        utilities_1.log.error(`Logto requires NodeJS ${requiredVersionString}, but ${current.version} found.`);
+        log.error(`Logto requires NodeJS ${requiredVersionString}, but ${current.version} found.`);
     }
     if (required.some((version) => version.major === current.major && version.compare(current) > 0)) {
-        utilities_1.log.warn(`Logto is tested under NodeJS ${requiredVersionString}, but version ${current.version} found.`);
+        log.warn(`Logto is tested under NodeJS ${requiredVersionString}, 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.`
+const validatePath = (value) => existsSync(path.resolve(value))
+    ? `The path ${chalk.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'));
+export const inquireInstancePath = async (initialPath) => {
+    if (!isTty()) {
+        assert(initialPath, new Error('Path is missing'));
         return initialPath;
     }
-    const { instancePath } = await inquirer_1.default.prompt({
+    const { instancePath } = await inquirer.prompt({
         name: 'instancePath',
         message: 'Where should we create your Logto instance?',
         type: 'input',
-        default: exports.defaultPath,
+        default: defaultPath,
         filter: (value) => value.trim(),
         validate: validatePath,
     }, { instancePath: initialPath });
     // Validate for initialPath
     const validated = validatePath(instancePath);
     if (validated !== true) {
-        utilities_1.log.error(validated);
+        log.error(validated);
     }
     return instancePath;
 };
-exports.inquireInstancePath = inquireInstancePath;
-const validateDatabase = async () => {
-    if (utilities_1.cliConfig.has(utilities_1.ConfigKey.DatabaseUrl) || !(0, utilities_1.isTty)()) {
+export const validateDatabase = async () => {
+    if (cliConfig.has(ConfigKey.DatabaseUrl) || !isTty()) {
         return;
     }
-    const { hasPostgresUrl } = await inquirer_1.default.prompt({
+    const { hasPostgresUrl } = await inquirer.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') ?? '';
+            const pgOutput = safeExecSync('postgres --version') ?? '';
             // Filter out all brackets in the output since Homebrew will append `(Homebrew)`.
             const pgArray = pgOutput.split(' ').filter((value) => !value.startsWith('('));
             const pgCurrent = semver.coerce(pgArray[pgArray.length - 1]);
@@ -96,74 +65,59 @@ const validateDatabase = async () => {
         },
     });
     if (hasPostgresUrl === false) {
-        utilities_1.log.error('Logto requires a Postgres instance to run.');
+        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);
+export const downloadRelease = async (url) => {
+    const tarFilePath = path.resolve(os.tmpdir(), './logto.tar.gz');
+    const from = url ??
+        `https://github.com/logto-io/logto/releases/download/v${packageJson.version}/logto.tar.gz`;
+    log.info(`Download Logto from ${from}`);
+    log.info(`Target ${tarFilePath}`);
+    await downloadFile(from, tarFilePath);
     return tarFilePath;
 };
-exports.downloadRelease = downloadRelease;
-const decompress = async (toPath, tarPath) => {
+export 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 });
+            await fs.mkdir(toPath);
+            await tar.extract({ file: tarPath, cwd: toPath, strip: 1 });
         }
         catch (error) {
-            utilities_1.log.error(error);
+            log.error(error);
         }
     };
-    return (0, utilities_1.oraPromise)(run(), {
+    return oraPromise(run(), {
         text: `Decompress to ${toPath}`,
-        prefixText: chalk_1.default.blue('[info]'),
+        prefixText: chalk.blue('[info]'),
     }, true);
 };
-exports.decompress = decompress;
-const seedDatabase = async (instancePath) => {
+export const seedDatabase = async (instancePath) => {
     try {
-        const pool = await (0, database_1.createPoolAndDatabaseIfNeeded)();
-        await (0, seed_1.seedByPool)(pool, 'all');
+        const pool = await createPoolAndDatabaseIfNeeded();
+        await seedByPool(pool, 'all');
         await pool.end();
     }
     catch (error) {
         console.error(error);
-        await (0, utilities_1.oraPromise)((0, fs_extra_1.remove)(instancePath), {
+        await oraPromise(fs.rm(instancePath, { force: true, recursive: true }), {
             text: 'Clean up',
-            prefixText: chalk_1.default.blue('[info]'),
+            prefixText: chalk.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.`);
+        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.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)}`);
+export const createEnv = async (instancePath, databaseUrl) => {
+    const dotEnvPath = path.resolve(instancePath, '.env');
+    await fs.writeFile(dotEnvPath, `DB_URL=${databaseUrl}`, 'utf8');
+    log.info(`Saved database URL to ${chalk.blue(dotEnvPath)}`);
 };
-exports.createEnv = createEnv;
-const logFinale = (instancePath) => {
+export 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;
+    log.info(`Use the command below to start Logto. Happy hacking!\n\n  ${chalk.green(startCommand)}`);
 };
-exports.inquireOfficialConnectors = inquireOfficialConnectors;
-const isUrl = (string) => {
+export const isUrl = (string) => {
     try {
         // On purpose to test
         // eslint-disable-next-line no-new
@@ -174,4 +128,3 @@ const isUrl = (string) => {
         return false;
     }
 };
-exports.isUrl = isUrl;

package/lib/constants.js

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