@logto/cli 1.0.0-rc.2 → 1.0.1

package/LICENSE

@@ -1,3 +1,9 @@
+Portions of this software are licensed as follows:
+
+* All content that resides under the "packages/cloud" directory of this repository, if that directory exists, is licensed under the license defined in "packages/cloud/LICENSE" (Elastic-2.0).
+* All third party components incorporated into this software are licensed under the original license provided by the owner of the applicable component.
+* Content outside of the above mentioned directories or restrictions above is available under the "MPL-2.0" license as defined below.
+
 Mozilla Public License Version 2.0
 ==================================
 

package/lib/commands/connector/add.d.ts

@@ -5,5 +5,6 @@ declare const add: CommandModule<{
     packages?: string[];
     path?: string;
     official: boolean;
+    cloud: boolean;
 }>;
 export default add;

package/lib/commands/connector/add.js

@@ -16,11 +16,21 @@ const add = {
         default: false,
         describe: 'Add all official connectors.\n' +
             "If it's true, the specified package names will be ignored.",
+    })
+        .option('cloud', {
+        describe: 'Add additional connectors for Logto Cloud',
+        type: 'boolean',
+        default: false,
+        hidden: true,
     }),
-    handler: async ({ packages: packageNames, path, official }) => {
+    handler: async ({ packages: packageNames, path, official, cloud }) => {
         const instancePath = await inquireInstancePath(path);
+        if (cloud && !official) {
+            log.error('--cloud option can only be used with --official option');
+        }
         if (official) {
-            await addOfficialConnectors(instancePath);
+            // Add demo connectors for Logto Cloud only
+            await addOfficialConnectors(instancePath, cloud);
         }
         else {
             if (!packageNames?.length) {

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

@@ -17,4 +17,4 @@ export declare const normalizePackageName: (name: string) => string;
 export declare const isOfficialConnector: (packageName: string) => boolean;
 export declare const getConnectorPackagesFrom: (instancePath?: string) => Promise<import("../../utils.js").ConnectorPackage[]>;
 export declare const addConnectors: (instancePath: string, packageNames: string[]) => Promise<void>;
-export declare const addOfficialConnectors: (instancePath: string) => Promise<void>;
+export declare const addOfficialConnectors: (instancePath: string, includingCloudConnectors?: boolean) => Promise<void>;

package/lib/commands/connector/utils.js

@@ -127,7 +127,7 @@ export const addConnectors = async (instancePath, packageNames) => {
     }
 };
 const officialConnectorPrefix = '@logto/connector-';
-const fetchOfficialConnectorList = async () => {
+const fetchOfficialConnectorList = async (includingCloudConnectors = false) => {
     const fetchList = async (from = 0, size = 20) => {
         const parameters = new URLSearchParams({
             text: officialConnectorPrefix,
@@ -142,10 +142,11 @@ const fetchOfficialConnectorList = async () => {
     for (let page = 0;; ++page) {
         // eslint-disable-next-line no-await-in-loop
         const { objects } = await fetchList(page * 20, 20);
+        const excludeList = ['mock', 'kit', ...(includingCloudConnectors ? [] : ['logto'])];
         // eslint-disable-next-line @silverhand/fp/no-mutating-methods
         packages.push(...objects
             .filter(({ package: { name, scope } }) => scope === 'logto' &&
-            ['mock', 'kit'].every((excluded) => !name.slice(officialConnectorPrefix.length).startsWith(excluded)))
+            excludeList.every((excluded) => !name.slice(officialConnectorPrefix.length).startsWith(excluded)))
             .map(({ package: data }) => data));
         if (objects.length < 20) {
             break;
@@ -153,8 +154,8 @@ const fetchOfficialConnectorList = async () => {
     }
     return packages;
 };
-export const addOfficialConnectors = async (instancePath) => {
-    const packages = await oraPromise(fetchOfficialConnectorList(), {
+export const addOfficialConnectors = async (instancePath, includingCloudConnectors = false) => {
+    const packages = await oraPromise(fetchOfficialConnectorList(includingCloudConnectors), {
         text: 'Fetch official connector list',
         prefixText: chalk.blue('[info]'),
     });

package/lib/commands/database/index.js

@@ -2,10 +2,11 @@ import { noop } from '@silverhand/essentials';
 import alteration from './alteration/index.js';
 import config from './config.js';
 import seed from './seed/index.js';
+import system from './system.js';
 const database = {
     command: ['database', 'db'],
     describe: 'Commands for Logto database',
-    builder: (yargs) => yargs.command(config).command(seed).command(alteration).demandCommand(1),
+    builder: (yargs) => yargs.command(config).command(seed).command(alteration).command(system).demandCommand(1),
     handler: noop,
 };
 export default database;

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

@@ -0,0 +1,10 @@
+import type { CommonQueryMethods } from 'slonik';
+/**
+ * Append Redirect URIs for the default tenant callback in cloud Admin Console.
+ * It reads the same env variables as core to construct the cloud `UrlSet`.
+ *
+ * E.g., by default, it will appends `http://localhost:3003/default/callback` to the Redirect URIs.
+ *
+ * For why it is necessary, see the redirect lifecycle of cloud Admin Console.
+ */
+export declare const appendAdminConsoleRedirectUris: (pool: CommonQueryMethods) => Promise<void>;

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

@@ -0,0 +1,34 @@
+import { adminConsoleApplicationId, adminTenantId, defaultTenantId } from '@logto/schemas';
+import { GlobalValues } from '@logto/shared';
+import { appendPath } from '@silverhand/essentials';
+import { sql } from 'slonik';
+import { log } from '../../../utils.js';
+/**
+ * Append Redirect URIs for the default tenant callback in cloud Admin Console.
+ * It reads the same env variables as core to construct the cloud `UrlSet`.
+ *
+ * E.g., by default, it will appends `http://localhost:3003/default/callback` to the Redirect URIs.
+ *
+ * For why it is necessary, see the redirect lifecycle of cloud Admin Console.
+ */
+export const appendAdminConsoleRedirectUris = async (pool) => {
+    const redirectUris = new GlobalValues().cloudUrlSet
+        .deduplicated()
+        .flatMap((endpoint) => [defaultTenantId, adminTenantId].map((tenantId) => appendPath(endpoint, tenantId, 'callback')));
+    const metadataKey = sql.identifier(['oidc_client_metadata']);
+    // Copied from packages/cloud/src/queries/tenants.ts
+    // Can be merged into the original once we remove slonik
+    await pool.query(sql `
+    update applications
+    set ${metadataKey} = jsonb_set(
+      ${metadataKey},
+      '{redirectUris}',
+      (select jsonb_agg(distinct value) from jsonb_array_elements(
+        ${metadataKey}->'redirectUris' || ${sql.jsonb(redirectUris.map(String))}
+      ))
+    )
+    where id = ${adminConsoleApplicationId}
+    and tenant_id = ${adminTenantId}
+  `);
+    log.succeed('Appended initial Redirect URIs to Admin Console:', redirectUris.map(String));
+};

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

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

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

@@ -4,25 +4,22 @@ import { doesConfigsTableExist } from '../../../queries/logto-config.js';
 import { log, oraPromise } from '../../../utils.js';
 import { getLatestAlterationTimestamp } from '../alteration/index.js';
 import { getAlterationDirectory } from '../alteration/utils.js';
-import { createTables, seedTables } from './tables.js';
-const seedChoices = Object.freeze(['all', 'oidc']);
-export const seedByPool = async (pool, type) => {
+import { createTables, seedCloud, seedTables } from './tables.js';
+export const seedByPool = async (pool, cloud = false) => {
     await pool.transaction(async (connection) => {
-        if (type !== 'oidc') {
-            // 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.blue('[info]'),
-            });
-            await oraPromise(seedTables(connection, latestTimestamp), {
-                text: 'Seed data',
-                prefixText: chalk.blue('[info]'),
-            });
+        // 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.blue('[info]'),
+        });
+        await seedTables(connection, latestTimestamp, cloud);
+        if (cloud) {
+            await seedCloud(connection);
         }
     });
 };
@@ -35,13 +32,12 @@ const seed = {
         alias: 'skip-when-exists',
         type: 'boolean',
     })
-        .positional('type', {
-        describe: 'Optional seed type',
-        type: 'string',
-        choices: seedChoices,
-        default: 'all',
+        .option('cloud', {
+        describe: 'Seed additional cloud data',
+        type: 'boolean',
+        hidden: true,
     }),
-    handler: async ({ type, swe }) => {
+    handler: async ({ swe, cloud }) => {
         const pool = await createPoolAndDatabaseIfNeeded();
         if (swe && (await doesConfigsTableExist(pool))) {
             log.info('Seeding skipped');
@@ -49,10 +45,7 @@ const seed = {
             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 seedByPool(pool, type);
+            await seedByPool(pool, cloud);
         }
         catch (error) {
             console.error(error);

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

@@ -1,3 +1,4 @@
 import type { DatabaseTransactionConnection } from 'slonik';
 export declare const createTables: (connection: DatabaseTransactionConnection) => Promise<void>;
-export declare const seedTables: (connection: DatabaseTransactionConnection, latestTimestamp: number) => Promise<void>;
+export declare const seedTables: (connection: DatabaseTransactionConnection, latestTimestamp: number, isCloud: boolean) => Promise<void>;
+export declare const seedCloud: (connection: DatabaseTransactionConnection) => Promise<void>;

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

@@ -1,15 +1,16 @@
 import { readdir, readFile } from 'fs/promises';
 import path from 'path';
-import { createDefaultAdminConsoleConfig, defaultTenantId, adminTenantId, defaultManagementApi, createAdminDataInAdminTenant, createMeApiInAdminTenant, createDefaultSignInExperience, createAdminTenantSignInExperience, createDefaultAdminConsoleApplication, } from '@logto/schemas';
-import { Hooks, Tenants } from '@logto/schemas/models';
+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 } from '../../../utils.js';
+import { getPathInModule, log } from '../../../utils.js';
+import { appendAdminConsoleRedirectUris } from './cloud.js';
 import { seedOidcConfigs } from './oidc-config.js';
-import { createTenant, seedAdminData } from './tenant.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;
@@ -54,7 +55,6 @@ export const createTables = async (connection) => {
         }
     };
     const allQueries = [
-        [Hooks.tableName, Hooks.raw],
         [Tenants.tableName, Tenants.raw],
         ...queries.filter(([file]) => !lifecycleNames.includes(file.slice(1, -4))),
     ];
@@ -71,19 +71,39 @@ export const createTables = async (connection) => {
     /* eslint-enable no-await-in-loop */
     await runLifecycleQuery('after_all', { database });
 };
-export const seedTables = async (connection, latestTimestamp) => {
+export const seedTables = async (connection, latestTimestamp, isCloud) => {
     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(createDefaultSignInExperience(defaultTenantId, isCloud), '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

@@ -1,4 +1,5 @@
-import type { AdminData } from '@logto/schemas';
+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) => 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

@@ -16,16 +16,38 @@ export const createTenant = async (pool, tenantId) => {
       in role ${sql.identifier([parentRole])};
   `);
 };
-export const seedAdminData = async (pool, data) => {
+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 pool.query(insertInto(role, 'roles'));
+    await Promise.all(additionalScopes.map(async (scope) => pool.query(insertInto(scope, 'scopes'))));
+    const roleId = await processRole();
     await pool.query(insertInto({
         id: generateStandardId(),
-        roleId: role.id,
+        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/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

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import { getDatabaseUrlFromConfig } from '../../database.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

@@ -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<T>;
+    path: string;
+};
+export type ConnectorPackage = {
+    name: string;
+    path: string;
+};

package/lib/connector/types.js

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

package/lib/connector/utils.d.ts

@@ -0,0 +1,11 @@
+import type { AllConnector, BaseConnector, ConnectorMetadata, GetConnectorConfig } from '@logto/connector-kit';
+import { ConnectorType } from '@logto/connector-kit';
+import type { ConnectorFactory } from './types.js';
+export declare function validateConnectorModule(connector: Partial<BaseConnector<ConnectorType>>): asserts connector is BaseConnector<ConnectorType>;
+export declare const readUrl: (url: string, baseUrl: string, type: 'text' | 'svg') => Promise<string>;
+export declare const parseMetadata: (metadata: AllConnector['metadata'], packagePath: string) => Promise<AllConnector['metadata']>;
+export declare const buildRawConnector: <T extends AllConnector = AllConnector>(connectorFactory: ConnectorFactory<T>, getConnectorConfig?: GetConnectorConfig) => Promise<{
+    rawConnector: T;
+    rawMetadata: ConnectorMetadata;
+}>;
+export declare const isKeyInObject: <Key extends string>(object: unknown, key: Key) => object is Record<string, unknown> & Record<Key, unknown>;

package/lib/connector/utils.js

@@ -0,0 +1,51 @@
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import path from 'path';
+import { ConnectorError, ConnectorErrorCodes, ConnectorType } from '@logto/connector-kit';
+import { notImplemented } from './consts.js';
+export function validateConnectorModule(connector) {
+    if (!connector.metadata) {
+        throw new ConnectorError(ConnectorErrorCodes.InvalidMetadata);
+    }
+    if (!connector.configGuard) {
+        throw new ConnectorError(ConnectorErrorCodes.InvalidConfigGuard);
+    }
+    if (!connector.type || !Object.values(ConnectorType).includes(connector.type)) {
+        throw new ConnectorError(ConnectorErrorCodes.UnexpectedType);
+    }
+}
+export const readUrl = async (url, baseUrl, type) => {
+    if (!url) {
+        return url;
+    }
+    if (type !== 'text' && url.startsWith('http')) {
+        return url;
+    }
+    if (!existsSync(path.join(baseUrl, url))) {
+        return url;
+    }
+    if (type === 'svg') {
+        const data = await readFile(path.join(baseUrl, url));
+        return `data:image/svg+xml;base64,${data.toString('base64')}`;
+    }
+    return readFile(path.join(baseUrl, url), 'utf8');
+};
+export const parseMetadata = async (metadata, packagePath) => {
+    return {
+        ...metadata,
+        logo: await readUrl(metadata.logo, packagePath, 'svg'),
+        logoDark: metadata.logoDark && (await readUrl(metadata.logoDark, packagePath, 'svg')),
+        readme: await readUrl(metadata.readme, packagePath, 'text'),
+        configTemplate: metadata.configTemplate && (await readUrl(metadata.configTemplate, packagePath, 'text')),
+    };
+};
+export const buildRawConnector = async (connectorFactory, getConnectorConfig) => {
+    const { createConnector, path: packagePath } = connectorFactory;
+    const rawConnector = await createConnector({
+        getConfig: getConnectorConfig ?? notImplemented,
+    });
+    validateConnectorModule(rawConnector);
+    const rawMetadata = await parseMetadata(rawConnector.metadata, packagePath);
+    return { rawConnector, rawMetadata };
+};
+export const isKeyInObject = (object, key) => object !== null && typeof object === 'object' && key in object;

package/lib/database.js

@@ -1,9 +1,9 @@
 import { convertToPrimitiveOrSql } from '@logto/shared';
 import { assert } from '@silverhand/essentials';
 import decamelize from 'decamelize';
+import { DatabaseError } from 'pg-protocol';
 import { createPool, parseDsn, sql, stringifyDsn } from 'slonik';
 import { createInterceptors } from 'slonik-interceptor-preset';
-import { z } from 'zod';
 import { ConfigKey, getCliConfigWithPrompt, log } from './utils.js';
 export const defaultDatabaseUrl = 'postgresql://localhost:5432/logto';
 export const getDatabaseUrlFromConfig = async () => (await getCliConfigWithPrompt({
@@ -29,10 +29,9 @@ export const createPoolAndDatabaseIfNeeded = async () => {
         return await createPoolFromConfig();
     }
     catch (error) {
-        const result = z.object({ code: 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')) {
+        if (!(error instanceof DatabaseError && error.code === '3D000')) {
             log.error(error);
         }
         const databaseUrl = await getDatabaseUrlFromConfig();

package/lib/package-json.d.ts

@@ -40,6 +40,7 @@ export declare const packageJson: {
         url: string;
     };
     dependencies: {
+        "@logto/connector-kit": string;
         "@logto/core-kit": string;
         "@logto/schemas": string;
         "@logto/shared": string;
@@ -54,6 +55,7 @@ export declare const packageJson: {
         ora: string;
         "p-limit": string;
         "p-retry": string;
+        "pg-protocol": string;
         roarr: string;
         semver: string;
         slonik: string;

package/lib/package-json.js

@@ -1,6 +1,6 @@
 export const packageJson = {
     "name": "@logto/cli",
-    "version": "1.0.0-rc.2",
+    "version": "1.0.1",
     "description": "Logto CLI.",
     "author": "Silverhand Inc. <contact@silverhand.io>",
     "homepage": "https://github.com/logto-io/logto#readme",
@@ -43,10 +43,11 @@ export const packageJson = {
         "url": "https://github.com/logto-io/logto/issues"
     },
     "dependencies": {
+        "@logto/connector-kit": "workspace:*",
         "@logto/core-kit": "workspace:*",
         "@logto/schemas": "workspace:*",
         "@logto/shared": "workspace:*",
-        "@silverhand/essentials": "2.2.0",
+        "@silverhand/essentials": "^2.5.0",
         "chalk": "^5.0.0",
         "decamelize": "^6.0.0",
         "dotenv": "^16.0.0",
@@ -57,6 +58,7 @@ export const packageJson = {
         "ora": "^6.1.2",
         "p-limit": "^4.0.0",
         "p-retry": "^5.1.2",
+        "pg-protocol": "^1.6.0",
         "roarr": "^7.11.0",
         "semver": "^7.3.8",
         "slonik": "^30.0.0",
@@ -70,14 +72,14 @@ export const packageJson = {
         "@silverhand/eslint-config": "2.0.1",
         "@silverhand/ts-config": "2.0.3",
         "@types/inquirer": "^9.0.0",
-        "@types/jest": "^29.1.2",
+        "@types/jest": "^29.4.0",
         "@types/node": "^18.11.18",
         "@types/semver": "^7.3.12",
         "@types/sinon": "^10.0.13",
         "@types/tar": "^6.1.2",
         "@types/yargs": "^17.0.13",
         "eslint": "^8.34.0",
-        "jest": "^29.3.1",
+        "jest": "^29.5.0",
         "lint-staged": "^13.0.0",
         "prettier": "^2.8.2",
         "sinon": "^15.0.0",

package/lib/queries/system.d.ts

@@ -1,4 +1,9 @@
+import type { System, SystemKey } from '@logto/schemas';
+import { systemGuards } from '@logto/schemas';
 import type { CommonQueryMethods, DatabaseTransactionConnection } from 'slonik';
+import type { z } from 'zod';
 export declare const doesSystemsTableExist: (pool: CommonQueryMethods) => Promise<boolean>;
 export declare const getCurrentDatabaseAlterationTimestamp: (pool: CommonQueryMethods) => Promise<number>;
 export declare const updateDatabaseTimestamp: (connection: DatabaseTransactionConnection, timestamp: number) => Promise<void>;
+export declare const getRowByKey: (pool: CommonQueryMethods, key: SystemKey) => Promise<System | null>;
+export declare const updateValueByKey: <T extends SystemKey>(pool: CommonQueryMethods, key: T, value: z.TypeOf<import("@logto/schemas").SystemGuard[T]>) => Promise<import("slonik").QueryResult<import("slonik").QueryResultRow>>;

package/lib/queries/system.js

@@ -1,8 +1,8 @@
 import { systemGuards, Systems, AlterationStateKey } from '@logto/schemas';
 import { convertToIdentifiers } from '@logto/shared';
+import { DatabaseError } from 'pg-protocol';
 import { sql } from 'slonik';
-import { z } from 'zod';
-const { fields } = convertToIdentifiers(Systems);
+const { fields, table } = convertToIdentifiers(Systems);
 const doesTableExist = async (pool, table) => {
     const { rows } = await pool.query(sql `select to_regclass(${table}) as regclass`);
     return Boolean(rows[0]?.regclass);
@@ -20,10 +20,9 @@ export const getCurrentDatabaseAlterationTimestamp = async (pool) => {
         return (parsed.success && parsed.data.timestamp) || 0;
     }
     catch (error) {
-        const result = z.object({ code: z.string() }).safeParse(error);
         // Relation does not exist, treat as 0
         // https://www.postgresql.org/docs/14/errcodes-appendix.html
-        if (result.success && result.data.code === '42P01') {
+        if (error instanceof DatabaseError && error.code === '42P01') {
             return 0;
         }
         throw error;
@@ -41,3 +40,13 @@ export const updateDatabaseTimestamp = async (connection, timestamp) => {
         on conflict (${fields.key}) do update set ${fields.value}=excluded.${fields.value}
     `);
 };
+export const getRowByKey = async (pool, key) => pool.maybeOne(sql `
+    select ${sql.join([fields.key, fields.value], sql `,`)} from ${table}
+      where ${fields.key} = ${key}
+  `);
+export const updateValueByKey = async (pool, key, value) => pool.query(sql `
+      insert into ${table} (${fields.key}, ${fields.value}) 
+        values (${key}, ${sql.jsonb(value)})
+        on conflict (${fields.key})
+          do update set ${fields.value}=excluded.${fields.value}
+    `);

package/lib/queries/system.test.js

@@ -1,5 +1,6 @@
 import { AlterationStateKey, Systems } from '@logto/schemas';
 import { convertToIdentifiers } from '@logto/shared';
+import { DatabaseError } from 'pg-protocol';
 import { createMockPool, createMockQueryResult, sql } from 'slonik';
 import { expectSqlAssert } from '../test-utils.js';
 import { updateDatabaseTimestamp, getCurrentDatabaseAlterationTimestamp } from './system.js';
@@ -15,7 +16,10 @@ const timestamp = 1_663_923_776;
 const systemsTableExists = async () => createMockQueryResult([{ regclass: true }]);
 describe('getCurrentDatabaseAlterationTimestamp()', () => {
     it('returns 0 if query failed (table not found)', async () => {
-        mockQuery.mockImplementationOnce(systemsTableExists).mockRejectedValueOnce({ code: '42P01' });
+        const error = new DatabaseError('test', 0, 'noData');
+        // eslint-disable-next-line @silverhand/fp/no-mutation
+        error.code = '42P01';
+        mockQuery.mockImplementationOnce(systemsTableExists).mockRejectedValueOnce(error);
         await expect(getCurrentDatabaseAlterationTimestamp(pool)).resolves.toBe(0);
     });
     it('returns 0 if the row is not found', async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logto/cli",
-  "version": "1.0.0-rc.2",
+  "version": "1.0.1",
   "description": "Logto CLI.",
   "author": "Silverhand Inc. <contact@silverhand.io>",
   "homepage": "https://github.com/logto-io/logto#readme",
@@ -28,7 +28,7 @@
     "url": "https://github.com/logto-io/logto/issues"
   },
   "dependencies": {
-    "@silverhand/essentials": "2.2.0",
+    "@silverhand/essentials": "^2.5.0",
     "chalk": "^5.0.0",
     "decamelize": "^6.0.0",
     "dotenv": "^16.0.0",
@@ -39,6 +39,7 @@
     "ora": "^6.1.2",
     "p-limit": "^4.0.0",
     "p-retry": "^5.1.2",
+    "pg-protocol": "^1.6.0",
     "roarr": "^7.11.0",
     "semver": "^7.3.8",
     "slonik": "^30.0.0",
@@ -47,22 +48,23 @@
     "tar": "^6.1.11",
     "yargs": "^17.6.0",
     "zod": "^3.20.2",
-    "@logto/core-kit": "1.0.0-rc.0",
-    "@logto/schemas": "1.0.0-rc.1",
-    "@logto/shared": "1.0.0-rc.1"
+    "@logto/connector-kit": "1.1.0",
+    "@logto/core-kit": "1.1.0",
+    "@logto/schemas": "1.0.0",
+    "@logto/shared": "1.0.0"
   },
   "devDependencies": {
     "@silverhand/eslint-config": "2.0.1",
     "@silverhand/ts-config": "2.0.3",
     "@types/inquirer": "^9.0.0",
-    "@types/jest": "^29.1.2",
+    "@types/jest": "^29.4.0",
     "@types/node": "^18.11.18",
     "@types/semver": "^7.3.12",
     "@types/sinon": "^10.0.13",
     "@types/tar": "^6.1.2",
     "@types/yargs": "^17.0.13",
     "eslint": "^8.34.0",
-    "jest": "^29.3.1",
+    "jest": "^29.5.0",
     "lint-staged": "^13.0.0",
     "prettier": "^2.8.2",
     "sinon": "^15.0.0",

package/LICENSE.cloud

@@ -1,93 +0,0 @@
-Elastic License 2.0
-
-URL: https://www.elastic.co/licensing/elastic-license
-
-## Acceptance
-
-By using the software, you agree to all of the terms and conditions below.
-
-## Copyright License
-
-The licensor grants you a non-exclusive, royalty-free, worldwide,
-non-sublicensable, non-transferable license to use, copy, distribute, make
-available, and prepare derivative works of the software, in each case subject to
-the limitations and conditions below.
-
-## Limitations
-
-You may not provide the software to third parties as a hosted or managed
-service, where the service provides users with access to any substantial set of
-the features or functionality of the software.
-
-You may not move, change, disable, or circumvent the license key functionality
-in the software, and you may not remove or obscure any functionality in the
-software that is protected by the license key.
-
-You may not alter, remove, or obscure any licensing, copyright, or other notices
-of the licensor in the software. Any use of the licensor’s trademarks is subject
-to applicable law.
-
-## Patents
-
-The licensor grants you a license, under any patent claims the licensor can
-license, or becomes able to license, to make, have made, use, sell, offer for
-sale, import and have imported the software, in each case subject to the
-limitations and conditions in this license. This license does not cover any
-patent claims that you cause to be infringed by modifications or additions to
-the software. If you or your company make any written claim that the software
-infringes or contributes to infringement of any patent, your patent license for
-the software granted under these terms ends immediately. If your company makes
-such a claim, your patent license ends immediately for work on behalf of your
-company.
-
-## Notices
-
-You must ensure that anyone who gets a copy of any part of the software from you
-also gets a copy of these terms.
-
-If you modify the software, you must include in any modified copies of the
-software prominent notices stating that you have modified the software.
-
-## No Other Rights
-
-These terms do not imply any licenses other than those expressly granted in
-these terms.
-
-## Termination
-
-If you use the software in violation of these terms, such use is not licensed,
-and your licenses will automatically terminate. If the licensor provides you
-with a notice of your violation, and you cease all violation of this license no
-later than 30 days after you receive that notice, your licenses will be
-reinstated retroactively. However, if you violate these terms after such
-reinstatement, any additional violation of these terms will cause your licenses
-to terminate automatically and permanently.
-
-## No Liability
-
-*As far as the law allows, the software comes as is, without any warranty or
-condition, and the licensor will not be liable to you for any damages arising
-out of these terms or the use or nature of the software, under any kind of
-legal claim.*
-
-## Definitions
-
-The **licensor** is the entity offering these terms, and the **software** is the
-software the licensor makes available under these terms, including any portion
-of it.
-
-**you** refers to the individual or entity agreeing to these terms.
-
-**your company** is any legal entity, sole proprietorship, or other kind of
-organization that you work for, plus all organizations that have control over,
-are under the control of, or are under common control with that
-organization. **control** means ownership of substantially all the assets of an
-entity, or the power to direct its management and policies by vote, contract, or
-otherwise. Control can be direct or indirect.
-
-**your licenses** are all the licenses granted to you for the software under
-these terms.
-
-**use** means anything you do with the software requiring one of your licenses.
-
-**trademark** means trademarks, service marks, and similar rights.