@logto/cli 1.18.0 → 1.19.0

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

@@ -2,7 +2,7 @@ import type { CommonQueryMethods } from '@silverhand/slonik';
 import type { CommandModule } from 'yargs';
 import type { AlterationFile } from './type.js';
 export declare const getLatestAlterationTimestamp: () => Promise<number>;
-export declare const getAvailableAlterations: (pool: CommonQueryMethods, compareMode?: 'gt' | 'lte') => Promise<AlterationFile[]>;
+export declare const getAvailableAlterations: (pool: CommonQueryMethods, compareMode?: "gt" | "lte") => Promise<AlterationFile[]>;
 declare const alteration: CommandModule<unknown, {
     action: string;
     target?: string;

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

@@ -0,0 +1,4 @@
+import type { CommandModule } from 'yargs';
+import { type ProxyCommandArgs } from './types.js';
+declare const proxy: CommandModule<unknown, ProxyCommandArgs>;
+export default proxy;

package/lib/commands/proxy/index.js

@@ -0,0 +1,80 @@
+import http from 'node:http';
+import { isValidUrl } from '@logto/core-kit';
+import { conditional } from '@silverhand/essentials';
+import chalk from 'chalk';
+import { consoleLog } from '../../utils.js';
+import { checkExperienceInput, createLogtoResponseHandler, createProxy, createStaticFileProxy, isLogtoRequestPath, } from './utils.js';
+const proxy = {
+    command: ['proxy'],
+    describe: 'Command for Logto proxy',
+    builder: (yargs) => yargs
+        .options({
+        'experience-uri': {
+            alias: ['x'],
+            describe: 'The URI of your custom sign-in experience page.',
+            type: 'string',
+        },
+        'experience-path': {
+            alias: ['xp'],
+            describe: 'The local folder path of your custom sign-in experience assets.',
+            type: 'string',
+        },
+        endpoint: {
+            alias: 'ep',
+            describe: 'Logto endpoint URI, which can be found in Logto Console. E.g.: https://<tenant-id>.logto.app/',
+            type: 'string',
+        },
+        port: {
+            alias: 'p',
+            describe: 'The port number where the proxy server will be running on. Defaults to 9000.',
+            type: 'number',
+            default: 9000,
+        },
+        verbose: {
+            alias: 'v',
+            describe: 'Show verbose output.',
+            type: 'boolean',
+            default: false,
+        },
+    })
+        .global('e'),
+    handler: async ({ 'experience-uri': url, 'experience-path': path, endpoint, port, verbose }) => {
+        checkExperienceInput(url, path);
+        if (!endpoint || !isValidUrl(endpoint)) {
+            consoleLog.fatal('A valid Logto endpoint URI must be provided.');
+        }
+        const logtoEndpointUrl = new URL(endpoint);
+        const proxyUrl = new URL(`http://localhost:${port}`);
+        const proxyLogtoRequest = createProxy(logtoEndpointUrl.href, async (proxyResponse, request, response) => createLogtoResponseHandler({
+            proxyResponse,
+            request,
+            response,
+            logtoEndpointUrl,
+            proxyUrl,
+            verbose,
+        }));
+        const proxyExperienceServerRequest = conditional(url && createProxy(url));
+        const proxyExperienceStaticFileRequest = conditional(path && createStaticFileProxy(path));
+        const server = http.createServer((request, response) => {
+            if (verbose) {
+                consoleLog.info(`Incoming request: ${chalk.blue(request.method, request.url)}`);
+            }
+            // Proxy the requests to Logto endpoint
+            if (isLogtoRequestPath(request.url)) {
+                void proxyLogtoRequest(request, response);
+                return;
+            }
+            if (proxyExperienceServerRequest) {
+                void proxyExperienceServerRequest(request, response);
+                return;
+            }
+            if (proxyExperienceStaticFileRequest) {
+                void proxyExperienceStaticFileRequest(request, response);
+            }
+        });
+        server.listen(port, () => {
+            consoleLog.info(`Proxy server is running on ${chalk.blue(proxyUrl.href)}`);
+        });
+    },
+};
+export default proxy;

package/lib/commands/proxy/types.d.ts

@@ -0,0 +1,16 @@
+import type * as http from 'node:http';
+export type ProxyCommandArgs = {
+    'experience-uri'?: string;
+    'experience-path'?: string;
+    endpoint?: string;
+    port: number;
+    verbose: boolean;
+};
+export type ProxyResponseHandler = {
+    proxyResponse: http.IncomingMessage;
+    request: http.IncomingMessage;
+    response: http.ServerResponse;
+    logtoEndpointUrl: URL;
+    proxyUrl: URL;
+    verbose: boolean;
+};

package/lib/commands/proxy/types.js

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

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

@@ -0,0 +1,27 @@
+import type http from 'node:http';
+import { type OnProxyEvent } from 'http-proxy-middleware/dist/types.js';
+import { type ProxyResponseHandler } from './types.js';
+export declare const createProxy: (targetUrl: string, onProxyResponse?: OnProxyEvent["proxyRes"]) => import("http-proxy-middleware").RequestHandler<http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, (err?: any) => void>;
+export declare const createStaticFileProxy: (staticPath: string) => (request: http.IncomingMessage, response: http.ServerResponse) => Promise<void>;
+/**
+ * Intercept the response from Logto endpoint and replace Logto endpoint URLs in the response with the
+ * proxy URL. The string replace happens in the following cases:
+ * - The response is a redirect response, and the `location` property in response header may contain Logto
+ *   endpoint URI.
+ * - The response body is JSON, which consists of properties such as `**_endpoint` and `redirectTo`. These
+ *   properties may contain Logto endpoint URI.
+ * - The response is HTML content that contains a form. The form action URL may contain Logto endpoint URI.
+ *
+ * Note: the `issuer` and `jwks_uri` properties in the `/oidc/.well-known` response should not be replaced,
+ * even they also contain the Logto endpoint URI.
+ */
+export declare const createLogtoResponseHandler: ({ proxyResponse, request, response, logtoEndpointUrl, proxyUrl, verbose, }: ProxyResponseHandler) => Promise<void>;
+export declare const checkExperienceInput: (url?: string, staticPath?: string) => void;
+/**
+ * Check if the request path is a Logto request path.
+ * @example isLogtoRequestPath('/oidc/.well-known/openid-configuration') // true
+ * @example isLogtoRequestPath('/oidc/auth') // true
+ * @example isLogtoRequestPath('/api/interaction/submit') // true
+ * @example isLogtoRequestPath('/consent') // true
+ */
+export declare const isLogtoRequestPath: (requestPath?: string) => boolean;

package/lib/commands/proxy/utils.js

@@ -0,0 +1,123 @@
+import { existsSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isValidUrl } from '@logto/core-kit';
+import { conditional, trySafe } from '@silverhand/essentials';
+import chalk from 'chalk';
+import { createProxyMiddleware, responseInterceptor } from 'http-proxy-middleware';
+import mime from 'mime';
+import { consoleLog } from '../../utils.js';
+export const createProxy = (targetUrl, onProxyResponse) => {
+    const hasResponseHandler = Boolean(onProxyResponse);
+    return createProxyMiddleware({
+        target: targetUrl,
+        changeOrigin: true,
+        selfHandleResponse: hasResponseHandler,
+        ...conditional(hasResponseHandler && {
+            on: {
+                proxyRes: onProxyResponse,
+                error: (error) => {
+                    consoleLog.error(chalk.red(error));
+                },
+            },
+        }),
+    });
+};
+const index = 'index.html';
+const indexContentType = 'text/html; charset=utf-8';
+const noCache = 'no-cache, no-store, must-revalidate';
+const maxAgeSevenDays = 'max-age=604_800_000';
+export const createStaticFileProxy = (staticPath) => async (request, response) => {
+    if (!request.url) {
+        response.writeHead(400).end();
+        return;
+    }
+    if (request.method === 'HEAD' || request.method === 'GET') {
+        const fallBackToIndex = !isFileAssetPath(request.url);
+        const requestPath = path.join(staticPath, fallBackToIndex ? index : request.url);
+        try {
+            const content = await fs.readFile(requestPath, 'utf8');
+            response.setHeader('cache-control', fallBackToIndex ? noCache : maxAgeSevenDays);
+            response.setHeader('content-type', getMimeType(request.url));
+            response.writeHead(200);
+            response.end(content);
+        }
+        catch (error) {
+            consoleLog.error(chalk.red(error));
+            response.setHeader('content-type', getMimeType(request.url));
+            response.writeHead(existsSync(request.url) ? 500 : 404);
+            response.end();
+        }
+    }
+};
+/**
+ * Intercept the response from Logto endpoint and replace Logto endpoint URLs in the response with the
+ * proxy URL. The string replace happens in the following cases:
+ * - The response is a redirect response, and the `location` property in response header may contain Logto
+ *   endpoint URI.
+ * - The response body is JSON, which consists of properties such as `**_endpoint` and `redirectTo`. These
+ *   properties may contain Logto endpoint URI.
+ * - The response is HTML content that contains a form. The form action URL may contain Logto endpoint URI.
+ *
+ * Note: the `issuer` and `jwks_uri` properties in the `/oidc/.well-known` response should not be replaced,
+ * even they also contain the Logto endpoint URI.
+ */
+export const createLogtoResponseHandler = async ({ proxyResponse, request, response, logtoEndpointUrl, proxyUrl, verbose, }) => {
+    const { location } = proxyResponse.headers;
+    if (location) {
+        // eslint-disable-next-line @silverhand/fp/no-mutation
+        proxyResponse.headers.location = location.replace(logtoEndpointUrl.href, proxyUrl.href);
+    }
+    void responseInterceptor(async (responseBuffer, proxyResponse) => {
+        const responseBody = responseBuffer.toString();
+        if (verbose) {
+            consoleLog.info(`Response received: ${chalk.green(responseBody)}`);
+        }
+        if (proxyResponse.headers['content-type']?.includes('text/html')) {
+            return responseBody.replace(`action="${logtoEndpointUrl.href}`, `action="${proxyUrl.href}`);
+        }
+        if (proxyResponse.headers['content-type']?.includes('application/json')) {
+            const jsonData = trySafe(() => JSON.parse(responseBody));
+            if (jsonData && typeof jsonData === 'object') {
+                const updatedEntries = Object.entries(jsonData).map(([key, value]) => {
+                    if ((key === 'redirectTo' || key.endsWith('_endpoint')) && typeof value === 'string') {
+                        return [key, value.replace(logtoEndpointUrl.href, proxyUrl.href)];
+                    }
+                    return [key, value];
+                });
+                return JSON.stringify(Object.fromEntries(updatedEntries));
+            }
+        }
+        return responseBody;
+    })(proxyResponse, request, response);
+};
+export const checkExperienceInput = (url, staticPath) => {
+    if (staticPath && url) {
+        consoleLog.fatal('Only one of the experience URI or path can be provided.');
+    }
+    if (!staticPath && !url) {
+        consoleLog.fatal('Either a sign-in experience URI or local path must be provided.');
+    }
+    if (url && !isValidUrl(url)) {
+        consoleLog.fatal('A valid sign-in experience URI must be provided. E.g.: http://localhost:4000');
+    }
+    if (staticPath && !existsSync(path.join(staticPath, index))) {
+        consoleLog.fatal('The provided path does not contain a valid index.html file.');
+    }
+};
+/**
+ * Check if the request path is a Logto request path.
+ * @example isLogtoRequestPath('/oidc/.well-known/openid-configuration') // true
+ * @example isLogtoRequestPath('/oidc/auth') // true
+ * @example isLogtoRequestPath('/api/interaction/submit') // true
+ * @example isLogtoRequestPath('/consent') // true
+ */
+export const isLogtoRequestPath = (requestPath) => ['/oidc/', '/api/'].some((path) => requestPath?.startsWith(path)) || requestPath === '/consent';
+const isFileAssetPath = (url) => url.split('/').at(-1)?.includes('.');
+const getMimeType = (requestPath) => {
+    const fallBackToIndex = !isFileAssetPath(requestPath);
+    if (fallBackToIndex) {
+        return indexContentType;
+    }
+    return mime.getType(requestPath) ?? 'application/octet-stream';
+};

package/lib/connector/utils.d.ts

@@ -3,9 +3,9 @@ import { ConnectorType } from '@logto/connector-kit';
 import type { BaseRoutes, Router } from '@withtyped/server';
 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' | 'image') => Promise<string>;
-export declare const parseMetadata: (metadata: AllConnector['metadata'], packagePath: string) => Promise<AllConnector['metadata']>;
-export declare const buildRawConnector: <T extends Router<any, any, BaseRoutes, string>, U extends AllConnector = AllConnector>(connectorFactory: ConnectorFactory<T, U>, getConnectorConfig?: GetConnectorConfig, getCloudServiceClient?: GetCloudServiceClient<T> | undefined) => Promise<{
+export declare const readUrl: (url: string, baseUrl: string, type: "text" | "image") => Promise<string>;
+export declare const parseMetadata: (metadata: AllConnector["metadata"], packagePath: string) => Promise<AllConnector["metadata"]>;
+export declare const buildRawConnector: <T extends Router<any, any, BaseRoutes, string>, U extends AllConnector = AllConnector>(connectorFactory: ConnectorFactory<T, U>, getConnectorConfig?: GetConnectorConfig, getCloudServiceClient?: GetCloudServiceClient<T>) => Promise<{
     rawConnector: U;
     rawMetadata: ConnectorMetadata;
 }>;

package/lib/index.js

@@ -5,6 +5,7 @@ import { hideBin } from 'yargs/helpers';
 import connector from './commands/connector/index.js';
 import database from './commands/database/index.js';
 import install from './commands/install/index.js';
+import proxy from './commands/proxy/index.js';
 import translate from './commands/translate/index.js';
 import { packageJson } from './package-json.js';
 import { cliConfig, ConfigKey, consoleLog } from './utils.js';
@@ -44,6 +45,7 @@ void yargs(hideBin(process.argv))
     .command(database)
     .command(connector)
     .command(translate)
+    .command(proxy)
     .demandCommand(1)
     .showHelpOnFail(false, `Specify ${chalk.green('--help')} for available options`)
     .strict()

package/lib/package-json.d.ts

@@ -53,7 +53,9 @@ export declare const packageJson: {
         dotenv: string;
         got: string;
         hpagent: string;
+        "http-proxy-middleware": string;
         inquirer: string;
+        mime: string;
         nanoid: string;
         ora: string;
         "p-limit": string;

package/lib/package-json.js

@@ -1,6 +1,6 @@
 export const packageJson = {
     "name": "@logto/cli",
-    "version": "1.18.0",
+    "version": "1.19.0",
     "description": "Logto CLI.",
     "author": "Silverhand Inc. <contact@silverhand.io>",
     "homepage": "https://github.com/logto-io/logto#readme",
@@ -45,30 +45,32 @@ export const packageJson = {
         "@logto/connector-kit": "workspace:^4.0.0",
         "@logto/core-kit": "workspace:^2.5.0",
         "@logto/language-kit": "workspace:^1.1.0",
-        "@logto/phrases": "workspace:^1.12.0",
+        "@logto/phrases": "workspace:^1.13.0",
         "@logto/phrases-experience": "workspace:^1.7.0",
-        "@logto/schemas": "workspace:1.18.0",
+        "@logto/schemas": "workspace:1.19.0",
         "@logto/shared": "workspace:^3.1.1",
         "@silverhand/essentials": "^2.9.1",
         "@silverhand/slonik": "31.0.0-beta.2",
-        "chalk": "^5.0.0",
+        "chalk": "^5.3.0",
         "decamelize": "^6.0.0",
-        "dotenv": "^16.0.0",
+        "dotenv": "^16.4.5",
         "got": "^14.0.0",
         "hpagent": "^1.2.0",
+        "http-proxy-middleware": "^3.0.0",
         "inquirer": "^9.0.0",
+        "mime": "^4.0.4",
         "nanoid": "^5.0.1",
         "ora": "^8.0.1",
-        "p-limit": "^5.0.0",
+        "p-limit": "^6.0.0",
         "p-queue": "^8.0.0",
         "p-retry": "^6.0.0",
         "pg-protocol": "^1.6.0",
         "roarr": "^7.11.0",
         "semver": "^7.3.8",
         "tar": "^7.0.0",
-        "typescript": "^5.3.3",
+        "typescript": "^5.5.3",
         "yargs": "^17.6.0",
-        "zod": "^3.22.4"
+        "zod": "^3.23.8"
     },
     "devDependencies": {
         "@silverhand/eslint-config": "6.0.1",
@@ -79,13 +81,13 @@ export const packageJson = {
         "@types/sinon": "^17.0.0",
         "@types/tar": "^6.1.12",
         "@types/yargs": "^17.0.13",
-        "@vitest/coverage-v8": "^1.4.0",
+        "@vitest/coverage-v8": "^2.0.0",
         "@withtyped/server": "^0.13.6",
         "eslint": "^8.56.0",
         "lint-staged": "^15.0.0",
         "prettier": "^3.0.0",
         "sinon": "^18.0.0",
-        "vitest": "^1.4.0"
+        "vitest": "^2.0.0"
     },
     "eslintConfig": {
         "extends": "@silverhand",

package/lib/queries/logto-config.d.ts

@@ -3,4 +3,4 @@ import type { CommonQueryMethods } from '@silverhand/slonik';
 import type { z } from 'zod';
 export declare const doesConfigsTableExist: (pool: CommonQueryMethods) => Promise<boolean>;
 export declare const getRowsByKeys: (pool: CommonQueryMethods, tenantId: string, keys: LogtoConfigKey[]) => Promise<import("@silverhand/slonik").QueryResult<LogtoConfig>>;
-export declare const updateValueByKey: <T extends LogtoConfigKey>(pool: CommonQueryMethods, tenantId: string, key: T, value: z.TypeOf<import("@logto/schemas").LogtoConfigGuard[T]>) => Promise<import("@silverhand/slonik").QueryResult<import("@silverhand/slonik").QueryResultRow>>;
+export declare const updateValueByKey: <T extends LogtoConfigKey>(pool: CommonQueryMethods, tenantId: string, key: T, value: z.infer<(typeof logtoConfigGuards)[T]>) => Promise<import("@silverhand/slonik").QueryResult<import("@silverhand/slonik").QueryResultRow>>;

package/lib/queries/system.d.ts

@@ -6,4 +6,4 @@ export declare const doesSystemsTableExist: (pool: CommonQueryMethods) => Promis
 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("@silverhand/slonik").QueryResult<import("@silverhand/slonik").QueryResultRow>>;
+export declare const updateValueByKey: <T extends SystemKey>(pool: CommonQueryMethods, key: T, value: z.infer<(typeof systemGuards)[T]>) => Promise<import("@silverhand/slonik").QueryResult<import("@silverhand/slonik").QueryResultRow>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logto/cli",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "description": "Logto CLI.",
   "author": "Silverhand Inc. <contact@silverhand.io>",
   "homepage": "https://github.com/logto-io/logto#readme",
@@ -31,30 +31,32 @@
     "@logto/connector-kit": "^4.0.0",
     "@logto/core-kit": "^2.5.0",
     "@logto/language-kit": "^1.1.0",
-    "@logto/phrases": "^1.12.0",
+    "@logto/phrases": "^1.13.0",
     "@logto/phrases-experience": "^1.7.0",
-    "@logto/schemas": "1.18.0",
+    "@logto/schemas": "1.19.0",
     "@logto/shared": "^3.1.1",
     "@silverhand/essentials": "^2.9.1",
     "@silverhand/slonik": "31.0.0-beta.2",
-    "chalk": "^5.0.0",
+    "chalk": "^5.3.0",
     "decamelize": "^6.0.0",
-    "dotenv": "^16.0.0",
+    "dotenv": "^16.4.5",
     "got": "^14.0.0",
     "hpagent": "^1.2.0",
+    "http-proxy-middleware": "^3.0.0",
     "inquirer": "^9.0.0",
+    "mime": "^4.0.4",
     "nanoid": "^5.0.1",
     "ora": "^8.0.1",
-    "p-limit": "^5.0.0",
+    "p-limit": "^6.0.0",
     "p-queue": "^8.0.0",
     "p-retry": "^6.0.0",
     "pg-protocol": "^1.6.0",
     "roarr": "^7.11.0",
     "semver": "^7.3.8",
     "tar": "^7.0.0",
-    "typescript": "^5.3.3",
+    "typescript": "^5.5.3",
     "yargs": "^17.6.0",
-    "zod": "^3.22.4"
+    "zod": "^3.23.8"
   },
   "devDependencies": {
     "@silverhand/eslint-config": "6.0.1",
@@ -65,13 +67,13 @@
     "@types/sinon": "^17.0.0",
     "@types/tar": "^6.1.12",
     "@types/yargs": "^17.0.13",
-    "@vitest/coverage-v8": "^1.4.0",
+    "@vitest/coverage-v8": "^2.0.0",
     "@withtyped/server": "^0.13.6",
     "eslint": "^8.56.0",
     "lint-staged": "^15.0.0",
     "prettier": "^3.0.0",
     "sinon": "^18.0.0",
-    "vitest": "^1.4.0"
+    "vitest": "^2.0.0"
   },
   "eslintConfig": {
     "extends": "@silverhand",