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

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);
+        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 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))),
     ];
@@ -78,12 +78,32 @@ export const seedTables = async (connection, latestTimestamp) => {
     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

@@ -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.`);
+};