@logto/cli 1.0.0-rc.1 → 1.0.0-rc.3

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

@@ -0,0 +1,109 @@
+import { readdir, readFile } from 'fs/promises';
+import path from 'path';
+import { createDefaultAdminConsoleConfig, defaultTenantId, adminTenantId, defaultManagementApi, createAdminDataInAdminTenant, createMeApiInAdminTenant, createDefaultSignInExperience, createAdminTenantSignInExperience, createDefaultAdminConsoleApplication, createCloudApi, createTenantApplicationRole, createTenantMachineToMachineApplication, createAdminTenantApplicationRole, CloudScope, } from '@logto/schemas';
+import { Tenants } from '@logto/schemas/models';
+import { sql } from 'slonik';
+import { raw } from 'slonik-sql-tag-raw';
+import { insertInto } from '../../../database.js';
+import { getDatabaseName } from '../../../queries/database.js';
+import { updateDatabaseTimestamp } from '../../../queries/system.js';
+import { getPathInModule, log } from '../../../utils.js';
+import { appendAdminConsoleRedirectUris } from './cloud.js';
+import { seedOidcConfigs } from './oidc-config.js';
+import { assignScopesToRole, createTenant, seedAdminData } from './tenant.js';
+const getExplicitOrder = (query) => {
+    const matched = /\/\*\s*init_order\s*=\s*([\d.]+)\s*\*\//.exec(query)?.[1];
+    return matched ? Number(matched) : undefined;
+};
+const compareQuery = ([t1, q1], [t2, q2]) => {
+    const o1 = getExplicitOrder(q1);
+    const o2 = getExplicitOrder(q2);
+    if (o1 === undefined && o2 === undefined) {
+        return t1.localeCompare(t2);
+    }
+    if (o1 === undefined) {
+        return 1;
+    }
+    if (o2 === undefined) {
+        return -1;
+    }
+    return o1 - o2;
+};
+const lifecycleNames = Object.freeze([
+    'before_all',
+    'after_all',
+    'after_each',
+]);
+export const createTables = async (connection) => {
+    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 readFile(path.join(tableDirectory, file), 'utf8'),
+    ]));
+    const runLifecycleQuery = async (lifecycle, parameters = {}) => {
+        const query = queries.find(([file]) => file.slice(1, -4) === lifecycle)?.[1];
+        if (query) {
+            await connection.query(sql `${raw(
+            /* eslint-disable no-template-curly-in-string */
+            query
+                .replaceAll('${name}', parameters.name ?? '')
+                .replaceAll('${database}', parameters.database ?? '')
+            /* eslint-enable no-template-curly-in-string */
+            )}`);
+        }
+    };
+    const allQueries = [
+        [Tenants.tableName, Tenants.raw],
+        ...queries.filter(([file]) => !lifecycleNames.includes(file.slice(1, -4))),
+    ];
+    const sorted = allQueries.slice().sort(compareQuery);
+    const database = await getDatabaseName(connection, true);
+    await runLifecycleQuery('before_all', { database });
+    /* eslint-disable no-await-in-loop */
+    for (const [file, query] of sorted) {
+        await connection.query(sql `${raw(query)}`);
+        if (!query.includes('/* no_after_each */')) {
+            await runLifecycleQuery('after_each', { name: file.split('.')[0], database });
+        }
+    }
+    /* eslint-enable no-await-in-loop */
+    await runLifecycleQuery('after_all', { database });
+};
+export const seedTables = async (connection, latestTimestamp) => {
+    await createTenant(connection, defaultTenantId);
+    await seedOidcConfigs(connection, defaultTenantId);
+    await seedAdminData(connection, defaultManagementApi);
+    await createTenant(connection, adminTenantId);
+    await seedOidcConfigs(connection, adminTenantId);
+    await seedAdminData(connection, createAdminDataInAdminTenant(defaultTenantId));
+    const adminAdminData = createAdminDataInAdminTenant(adminTenantId);
+    await seedAdminData(connection, adminAdminData);
+    await seedAdminData(connection, createMeApiInAdminTenant());
+    const [cloudData, ...cloudAdditionalScopes] = createCloudApi();
+    const applicationRole = createTenantApplicationRole();
+    await seedAdminData(connection, cloudData, ...cloudAdditionalScopes);
+    await connection.query(insertInto(applicationRole, 'roles'));
+    await assignScopesToRole(connection, adminTenantId, applicationRole.id, ...cloudAdditionalScopes
+        .filter(({ name }) => name === CloudScope.SendSms || name === CloudScope.SendEmail)
+        .map(({ id }) => id));
+    // Add M2M app for default tenant
+    const defaultTenantApplication = createTenantMachineToMachineApplication(defaultTenantId);
+    await connection.query(insertInto(defaultTenantApplication, 'applications'));
+    await connection.query(insertInto(createAdminTenantApplicationRole(defaultTenantApplication.id, applicationRole.id), 'applications_roles'));
+    // Assign all cloud API scopes to role `admin:admin`
+    await assignScopesToRole(connection, adminTenantId, adminAdminData.role.id, ...cloudAdditionalScopes.map(({ id }) => id));
+    await Promise.all([
+        connection.query(insertInto(createDefaultAdminConsoleConfig(defaultTenantId), 'logto_configs')),
+        connection.query(insertInto(createDefaultSignInExperience(defaultTenantId), 'sign_in_experiences')),
+        connection.query(insertInto(createDefaultAdminConsoleConfig(adminTenantId), 'logto_configs')),
+        connection.query(insertInto(createAdminTenantSignInExperience(), 'sign_in_experiences')),
+        connection.query(insertInto(createDefaultAdminConsoleApplication(), 'applications')),
+        updateDatabaseTimestamp(connection, latestTimestamp),
+    ]);
+    log.succeed('Seed data');
+};
+export const seedCloud = async (connection) => {
+    await appendAdminConsoleRedirectUris(connection);
+};

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

@@ -0,0 +1,5 @@
+import type { AdminData, UpdateAdminData, CreateScope } from '@logto/schemas';
+import type { CommonQueryMethods } 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>;

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

@@ -0,0 +1,53 @@
+import { generateStandardId } from '@logto/core-kit';
+import { createTenantMetadata } 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';
+export const createTenant = async (pool, tenantId) => {
+    const database = await getDatabaseName(pool, true);
+    const { parentRole, role, password } = createTenantMetadata(database, tenantId);
+    const tenantModel = { id: tenantId, dbUser: role, dbUserPassword: password };
+    await pool.query(insertInto(tenantModel, 'tenants'));
+    await pool.query(sql `
+    create role ${sql.identifier([role])} with inherit login
+      password '${raw(password)}'
+      in role ${sql.identifier([parentRole])};
+  `);
+};
+export const seedAdminData = async (pool, data, ...additionalScopes) => {
+    const { resource, scope, role } = data;
+    assert(resource.tenantId === scope.tenantId && scope.tenantId === role.tenantId, new Error('All data should have the same tenant ID'));
+    const processRole = async () => {
+        if ('id' in role) {
+            await pool.query(insertInto(role, 'roles'));
+            return role.id;
+        }
+        // Query by role name for existing roles
+        const { id } = await pool.one(sql `
+      select id from roles
+      where name=${role.name}
+      and tenant_id=${String(role.tenantId)}
+    `);
+        return id;
+    };
+    await pool.query(insertInto(resource, 'resources'));
+    await pool.query(insertInto(scope, 'scopes'));
+    await Promise.all(additionalScopes.map(async (scope) => pool.query(insertInto(scope, 'scopes'))));
+    const roleId = await processRole();
+    await pool.query(insertInto({
+        id: generateStandardId(),
+        roleId,
+        scopeId: scope.id,
+        tenantId: resource.tenantId,
+    }, 'roles_scopes'));
+};
+export const assignScopesToRole = async (pool, tenantId, roleId, ...scopeIds) => {
+    await Promise.all(scopeIds.map(async (scopeId) => pool.query(insertInto({
+        id: generateStandardId(),
+        roleId,
+        scopeId,
+        tenantId,
+    }, 'roles_scopes'))));
+};

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

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

package/lib/commands/database/system.js

@@ -0,0 +1,63 @@
+import { systemGuards, systemKeys } from '@logto/schemas';
+import { noop } from '@silverhand/essentials';
+import chalk from 'chalk';
+import { createPoolFromConfig } from '../../database.js';
+import { getRowByKey, updateValueByKey } from '../../queries/system.js';
+import { log } from '../../utils.js';
+const validKeysDisplay = chalk.green(systemKeys.join(', '));
+const validateKey = (key) => {
+    // Using `.includes()` will result a type error
+    // eslint-disable-next-line unicorn/prefer-includes
+    if (!systemKeys.some((element) => element === key)) {
+        log.error(`Invalid config key ${chalk.red(key)} found, expected one of ${validKeysDisplay}`);
+    }
+};
+const getConfig = {
+    command: 'get <key>',
+    describe: 'Get system value of the given key in Logto database',
+    builder: (yargs) => yargs.positional('key', {
+        describe: `The key to get from database system table, one of ${validKeysDisplay}`,
+        type: 'string',
+        demandOption: true,
+    }),
+    handler: async ({ key }) => {
+        validateKey(key);
+        const pool = await createPoolFromConfig();
+        const row = await getRowByKey(pool, key);
+        await pool.end();
+        const value = row?.value;
+        console.log(chalk.magenta(key) +
+            '=' +
+            (value === undefined ? chalk.gray(value) : chalk.green(JSON.stringify(value))));
+    },
+};
+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 system table, 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 }) => {
+        validateKey(key);
+        const guarded = systemGuards[key].parse(JSON.parse(value));
+        const pool = await createPoolFromConfig();
+        await updateValueByKey(pool, key, guarded);
+        await pool.end();
+        log.info(`Update ${chalk.green(key)} succeeded`);
+    },
+};
+const system = {
+    command: ['system'],
+    describe: 'Commands for Logto system config',
+    builder: (yargs) => yargs.command(getConfig).command(setConfig).demandCommand(1),
+    handler: noop,
+};
+export default system;

package/lib/commands/database/{utilities.js → utils.js}

@@ -1,6 +1,6 @@
 import { generateKeyPair } from 'crypto';
 import { promisify } from 'util';
-import { nanoid } from 'nanoid';
+import { generateStandardId } from '@logto/core-kit';
 export const generateOidcPrivateKey = async (type = 'ec') => {
     if (type === 'rsa') {
         const { privateKey } = await promisify(generateKeyPair)('rsa', {
@@ -34,4 +34,4 @@ export const generateOidcPrivateKey = async (type = 'ec') => {
     }
     throw new Error(`Unsupported private key ${String(type)}`);
 };
-export const generateOidcCookieKey = () => nanoid();
+export const generateOidcCookieKey = () => generateStandardId();

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

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

package/lib/commands/install/index.js

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
 import { getDatabaseUrlFromConfig } from '../../database.js';
-import { log } from '../../utilities.js';
+import { log } from '../../utils.js';
 import { validateNodeVersion, inquireInstancePath, validateDatabase, downloadRelease, seedDatabase, createEnv, logFinale, decompress, isUrl, } from './utils.js';
-const installLogto = async ({ path, skipSeed, officialConnectors, downloadUrl }) => {
+const installLogto = async ({ path, skipSeed, downloadUrl, cloud }) => {
     validateNodeVersion();
     // Get instance path
     const instancePath = await inquireInstancePath(path);
@@ -16,7 +16,7 @@ const installLogto = async ({ path, skipSeed, officialConnectors, downloadUrl })
         log.info(`Skipped database seeding.\n\n' + '  You can use the ${chalk.green('db seed')} command to seed database when ready.\n`);
     }
     else {
-        await seedDatabase(instancePath);
+        await seedDatabase(instancePath, cloud);
     }
     // Save to dot env
     await createEnv(instancePath, await getDatabaseUrlFromConfig());
@@ -38,10 +38,11 @@ const install = {
             type: 'boolean',
             default: false,
         },
-        oc: {
-            alias: 'official-connectors',
-            describe: 'Add official connectors after downloading Logto',
+        cloud: {
+            describe: 'Init Logto for cloud',
             type: 'boolean',
+            hidden: true,
+            default: false,
         },
         du: {
             alias: 'download-url',
@@ -50,8 +51,8 @@ const install = {
             hidden: true,
         },
     }),
-    handler: async ({ p, ss, oc, du }) => {
-        await installLogto({ path: p, skipSeed: ss, officialConnectors: oc, downloadUrl: du });
+    handler: async ({ p, ss, cloud, du }) => {
+        await installLogto({ path: p, skipSeed: ss, cloud, downloadUrl: du });
     },
 };
 export default install;

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

@@ -4,7 +4,7 @@ export declare const inquireInstancePath: (initialPath?: string) => Promise<stri
 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 seedDatabase: (instancePath: string, cloud: boolean) => Promise<void>;
 export declare const createEnv: (instancePath: string, databaseUrl: string) => Promise<void>;
 export declare const logFinale: (instancePath: string) => void;
 export declare const isUrl: (string: string) => boolean;

package/lib/commands/install/utils.js

@@ -10,7 +10,7 @@ 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 { cliConfig, ConfigKey, downloadFile, isTty, log, oraPromise, safeExecSync, } from '../../utils.js';
 import { seedByPool } from '../database/seed/index.js';
 export const defaultPath = path.join(os.homedir(), 'logto');
 const pgRequired = new semver.SemVer('14.0.0');
@@ -92,10 +92,10 @@ export const decompress = async (toPath, tarPath) => {
         prefixText: chalk.blue('[info]'),
     }, true);
 };
-export const seedDatabase = async (instancePath) => {
+export const seedDatabase = async (instancePath, cloud) => {
     try {
         const pool = await createPoolAndDatabaseIfNeeded();
-        await seedByPool(pool, 'all');
+        await seedByPool(pool);
         await pool.end();
     }
     catch (error) {

package/lib/connector/consts.d.ts

@@ -0,0 +1,7 @@
+export declare const notImplemented: () => never;
+export declare const defaultConnectorMethods: {
+    getAuthorizationUri: () => never;
+    getUserInfo: () => never;
+    sendMessage: () => never;
+    validateConfig: () => never;
+};

package/lib/connector/consts.js

@@ -0,0 +1,10 @@
+import { ConnectorError, ConnectorErrorCodes } from '@logto/connector-kit';
+export const notImplemented = () => {
+    throw new ConnectorError(ConnectorErrorCodes.NotImplemented);
+};
+export const defaultConnectorMethods = {
+    getAuthorizationUri: notImplemented,
+    getUserInfo: notImplemented,
+    sendMessage: notImplemented,
+    validateConfig: notImplemented,
+};

package/lib/connector/factories.d.ts

@@ -0,0 +1,2 @@
+import type { ConnectorFactory, ConnectorPackage } from './types.js';
+export declare const loadConnectorFactories: (connectorPackages: ConnectorPackage[], ignoreVersionMismatch: boolean) => Promise<ConnectorFactory<import("@logto/connector-kit").AllConnector>[]>;

package/lib/connector/factories.js

@@ -0,0 +1,34 @@
+import chalk from 'chalk';
+import { notImplemented } from './consts.js';
+import { loadConnector } from './loader.js';
+import { parseMetadata, validateConnectorModule } from './utils.js';
+// eslint-disable-next-line @silverhand/fp/no-let
+let cachedConnectorFactories;
+export const loadConnectorFactories = async (connectorPackages, ignoreVersionMismatch) => {
+    if (cachedConnectorFactories) {
+        return cachedConnectorFactories;
+    }
+    const connectorFactories = await Promise.all(connectorPackages.map(async ({ path: packagePath, name }) => {
+        try {
+            const createConnector = await loadConnector(packagePath, ignoreVersionMismatch);
+            const rawConnector = await createConnector({ getConfig: notImplemented });
+            validateConnectorModule(rawConnector);
+            return {
+                metadata: await parseMetadata(rawConnector.metadata, packagePath),
+                type: rawConnector.type,
+                createConnector,
+                path: packagePath,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.log(`${chalk.red(`[load-connector] skip ${chalk.bold(name)} due to error: ${error.message}`)}`);
+                return;
+            }
+            throw error;
+        }
+    }));
+    // eslint-disable-next-line @silverhand/fp/no-mutation
+    cachedConnectorFactories = connectorFactories.filter((connectorFactory) => connectorFactory !== undefined);
+    return cachedConnectorFactories;
+};

package/lib/connector/index.d.ts

@@ -0,0 +1,4 @@
+export * from './factories.js';
+export * from './types.js';
+export * from './consts.js';
+export * from './utils.js';

package/lib/connector/index.js

@@ -0,0 +1,4 @@
+export * from './factories.js';
+export * from './types.js';
+export * from './consts.js';
+export * from './utils.js';

package/lib/connector/loader.d.ts

@@ -0,0 +1,2 @@
+import type { AllConnector, CreateConnector } from '@logto/connector-kit';
+export declare const loadConnector: (connectorPath: string, ignoreVersionMismatch: boolean) => Promise<CreateConnector<AllConnector>>;

package/lib/connector/loader.js

@@ -0,0 +1,48 @@
+import path from 'path';
+import connectorKitMeta from '@logto/connector-kit/package.json' assert { type: 'json' };
+import { satisfies } from 'semver';
+import { isKeyInObject } from './utils.js';
+const connectorKit = '@logto/connector-kit';
+const { version: currentVersion } = connectorKitMeta;
+const checkConnectorKitVersion = (dependencies, ignoreVersionMismatch) => {
+    if (isKeyInObject(dependencies, connectorKit)) {
+        const value = dependencies[connectorKit];
+        if (typeof value === 'string') {
+            if (satisfies(currentVersion, value)) {
+                return;
+            }
+            const message = `Connector requires ${connectorKit} to be ${value}, but the version here is ${currentVersion}.`;
+            if (ignoreVersionMismatch) {
+                console.warn(`[warn] ${message}\n\nThis is highly discouraged in production.`);
+                return;
+            }
+            throw new Error(message);
+        }
+    }
+    throw new Error(`Cannot find ${connectorKit} in connector's dependency`);
+};
+export const loadConnector = async (connectorPath, ignoreVersionMismatch) => {
+    const { default: { dependencies },
+    // eslint-disable-next-line no-restricted-syntax
+     } = (await import(path.join(connectorPath, 'package.json'), {
+        assert: { type: 'json' },
+    }));
+    checkConnectorKitVersion(dependencies, ignoreVersionMismatch);
+    const loaded = await import(path.join(connectorPath, 'lib/index.js'));
+    if (isKeyInObject(loaded, 'default')) {
+        // CJS pattern
+        if (isKeyInObject(loaded.default, 'default')) {
+            if (typeof loaded.default.default === 'function') {
+                console.log(`[warn] Load connector ${connectorPath} in CJS mode`);
+                // eslint-disable-next-line no-restricted-syntax
+                return loaded.default.default;
+            }
+            // ESM pattern
+        }
+        else if (typeof loaded.default === 'function') {
+            // eslint-disable-next-line no-restricted-syntax
+            return loaded.default;
+        }
+    }
+    throw new Error(`Cannot load connector from ${connectorPath}, the connector package may be broken.`);
+};

package/lib/connector/types.d.ts

@@ -0,0 +1,12 @@
+import type { AllConnector, CreateConnector } from '@logto/connector-kit';
+/**
+ * Dynamic loaded connector type.
+ */
+export type ConnectorFactory<T extends AllConnector = AllConnector> = Pick<T, 'type' | 'metadata'> & {
+    createConnector: CreateConnector<AllConnector>;
+    path: string;
+};
+export type ConnectorPackage = {
+    name: string;
+    path: string;
+};

package/lib/connector/types.js

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