Skip to content

Commit f6c4a1c

Browse files
committed
fix(nextjs): Improve support for cacheComponents
This PR also prevents keylessDriftDetection from firing as an action when the RSC variant is used.
1 parent f47b5a3 commit f6c4a1c

7 files changed

Lines changed: 133 additions & 63 deletions

File tree

‎.changeset/quiet-rockets-invite.md‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
---
2+
'@clerk/nextjs': patch
3+
---
4+
5+
Improve support for apps that opt-in to using Next.js new `cacheComponents` feature.

‎packages/nextjs/src/app-router/client/ClerkProvider.tsx‎

Lines changed: 15 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,6 @@ import { canUseKeyless } from '../../utils/feature-flags';
1515
import { mergeNextClerkPropsWithEnv } from '../../utils/mergeNextClerkPropsWithEnv';
1616
import { RouterTelemetry } from '../../utils/router-telemetry';
1717
import { isNextWithUnstableServerActions } from '../../utils/sdk-versions';
18-
import { detectKeylessEnvDriftAction } from '../keyless-actions';
1918
import { invalidateCacheAction } from '../server-actions';
2019
import { useAwaitablePush } from './useAwaitablePush';
2120
import { useAwaitableReplace } from './useAwaitableReplace';
@@ -28,6 +27,11 @@ const LazyCreateKeylessApplication = dynamic(() =>
2827
import('./keyless-creator-reader.js').then(m => m.KeylessCreatorOrReader),
2928
);
3029

30+
/**
31+
* LazyKeylessDriftDetector should only be loaded if the conditions below are met.
32+
*/
33+
const LazyKeylessDriftDetector = dynamic(() => import('./keyless-drift-detector.js').then(m => m.KeylessDriftDetector));
34+
3135
const NextClientClerkProvider = (props: NextClerkProviderProps) => {
3236
if (isNextWithUnstableServerActions) {
3337
const deprecationWarning = `Clerk:\nYour current Next.js version (${nextPackage.version}) will be deprecated in the next major release of "@clerk/nextjs". Please upgrade to [email protected] or later.`;
@@ -44,13 +48,6 @@ const NextClientClerkProvider = (props: NextClerkProviderProps) => {
4448
const replace = useAwaitableReplace();
4549
const [isPending, startTransition] = useTransition();
4650

47-
// Call drift detection on mount (client-side)
48-
useSafeLayoutEffect(() => {
49-
if (canUseKeyless) {
50-
void detectKeylessEnvDriftAction();
51-
}
52-
}, []);
53-
5451
// Avoid rendering nested ClerkProviders by checking for the existence of the ClerkNextOptions context provider
5552
const isNested = Boolean(useClerkNextOptions());
5653
if (isNested) {
@@ -137,12 +134,19 @@ const NextClientClerkProvider = (props: NextClerkProviderProps) => {
137134
);
138135
};
139136

140-
export const ClientClerkProvider = (props: NextClerkProviderProps & { disableKeyless?: boolean }) => {
141-
const { children, disableKeyless = false, ...rest } = props;
137+
export const ClientClerkProvider = (
138+
props: NextClerkProviderProps & { disableKeyless?: boolean; disableKeylessDriftDetection?: boolean },
139+
) => {
140+
const { children, disableKeyless = false, disableKeylessDriftDetection = false, ...rest } = props;
142141
const safePublishableKey = mergeNextClerkPropsWithEnv(rest).publishableKey;
143142

144143
if (safePublishableKey || !canUseKeyless || disableKeyless) {
145-
return <NextClientClerkProvider {...rest}>{children}</NextClientClerkProvider>;
144+
return (
145+
<NextClientClerkProvider {...rest}>
146+
{!disableKeylessDriftDetection && <LazyKeylessDriftDetector />}
147+
{children}
148+
</NextClientClerkProvider>
149+
);
146150
}
147151

148152
return (
Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
import { useSelectedLayoutSegments } from 'next/navigation';
2+
import { useEffect } from 'react';
3+
4+
import { canUseKeyless } from '../../utils/feature-flags';
5+
6+
export function KeylessDriftDetector() {
7+
const segments = useSelectedLayoutSegments();
8+
const isNotFoundRoute = segments[0]?.startsWith('/_not-found') || false;
9+
10+
useEffect(() => {
11+
if (canUseKeyless && !isNotFoundRoute) {
12+
void import('../keyless-actions.js').then(m => m.detectKeylessEnvDriftAction());
13+
}
14+
}, [isNotFoundRoute]);
15+
16+
return null;
17+
}

‎packages/nextjs/src/app-router/server/ClerkProvider.tsx‎

Lines changed: 35 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -7,8 +7,10 @@ import { PromisifiedAuthProvider } from '../../client-boundary/PromisifiedAuthPr
77
import { getDynamicAuthData } from '../../server/buildClerkProps';
88
import type { NextClerkProviderProps } from '../../types';
99
import { mergeNextClerkPropsWithEnv } from '../../utils/mergeNextClerkPropsWithEnv';
10+
import { onlyTry } from '../../utils/only-try';
1011
import { isNext13 } from '../../utils/sdk-versions';
1112
import { ClientClerkProvider } from '../client/ClerkProvider';
13+
import { SuspenseWhenCached } from '../suspense-when-cached';
1214
import { getKeylessStatus, KeylessProvider } from './keyless-provider';
1315
import { buildRequestLike, getScriptNonceFromHeader } from './utils';
1416

@@ -65,39 +67,48 @@ export async function ClerkProvider(
6567
...rest,
6668
});
6769

68-
const { shouldRunAsKeyless, runningWithClaimedKeys } = await getKeylessStatus(propsWithEnvs);
70+
const { shouldRunAsKeyless, runningWithClaimedKeys, runningWithDriftedKeys } = await getKeylessStatus(propsWithEnvs);
6971

70-
let output: ReactNode;
71-
72-
try {
73-
const detectKeylessEnvDrift = await import('../../server/keyless-telemetry.js').then(
74-
mod => mod.detectKeylessEnvDrift,
75-
);
76-
await detectKeylessEnvDrift();
77-
} catch {
78-
// ignore
72+
if (runningWithDriftedKeys) {
73+
onlyTry(async () => {
74+
const detectKeylessEnvDrift = await import('../../server/keyless-telemetry.js').then(
75+
mod => mod.detectKeylessEnvDrift,
76+
);
77+
await detectKeylessEnvDrift();
78+
});
7979
}
8080

81+
let output: ReactNode;
82+
8183
if (shouldRunAsKeyless) {
8284
output = (
83-
<KeylessProvider
84-
rest={propsWithEnvs}
85-
generateNonce={generateNonce}
86-
generateStatePromise={generateStatePromise}
87-
runningWithClaimedKeys={runningWithClaimedKeys}
88-
>
89-
{children}
90-
</KeylessProvider>
85+
<SuspenseWhenCached>
86+
<KeylessProvider
87+
rest={propsWithEnvs}
88+
generateNonce={generateNonce}
89+
generateStatePromise={generateStatePromise}
90+
runningWithClaimedKeys={runningWithClaimedKeys}
91+
>
92+
{children}
93+
</KeylessProvider>
94+
</SuspenseWhenCached>
9195
);
9296
} else {
9397
output = (
94-
<ClientClerkProvider
95-
{...propsWithEnvs}
96-
nonce={await generateNonce()}
97-
initialState={await generateStatePromise()}
98+
// This suspense boundary is required because `cacheComponents` does not like the fact that we await `generateNonce` even though it does not accesss runtime APIs.
99+
<SuspenseWhenCached
100+
// When dynamic is true, we don't want to ever wrap with Suspense, instead we should let the developer handle it.
101+
noopWhen={dynamic}
98102
>
99-
{children}
100-
</ClientClerkProvider>
103+
<ClientClerkProvider
104+
{...propsWithEnvs}
105+
nonce={await generateNonce()}
106+
initialState={await generateStatePromise()}
107+
disableKeylessDriftDetection
108+
>
109+
{children}
110+
</ClientClerkProvider>
111+
</SuspenseWhenCached>
101112
);
102113
}
103114

‎packages/nextjs/src/app-router/server/keyless-provider.tsx‎

Lines changed: 13 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,19 +16,29 @@ import { deleteKeylessAction } from '../keyless-actions';
1616
export async function getKeylessStatus(
1717
params: Without<NextClerkProviderProps, '__unstable_invokeMiddlewareOnAuthStateChange'>,
1818
) {
19-
let [shouldRunAsKeyless, runningWithClaimedKeys, locallyStoredPublishableKey] = [false, false, ''];
19+
let [shouldRunAsKeyless, runningWithClaimedKeys, runningWithDriftedKeys, locallyStoredPublishableKey] = [
20+
false,
21+
false,
22+
false,
23+
'',
24+
];
2025
if (canUseKeyless) {
2126
locallyStoredPublishableKey = await import('../../server/keyless-node.js')
2227
.then(mod => mod.safeParseClerkFile()?.publishableKey || '')
2328
.catch(() => '');
2429

2530
runningWithClaimedKeys = Boolean(params.publishableKey) && params.publishableKey === locallyStoredPublishableKey;
31+
runningWithDriftedKeys =
32+
Boolean(params.publishableKey) &&
33+
Boolean(locallyStoredPublishableKey) &&
34+
params.publishableKey !== locallyStoredPublishableKey;
2635
shouldRunAsKeyless = !params.publishableKey || runningWithClaimedKeys;
2736
}
2837

2938
return {
3039
shouldRunAsKeyless,
3140
runningWithClaimedKeys,
41+
runningWithDriftedKeys,
3242
};
3343
}
3444

@@ -59,6 +69,7 @@ export const KeylessProvider = async (props: KeylessProviderProps) => {
5969
nonce={await generateNonce()}
6070
initialState={await generateStatePromise()}
6171
disableKeyless
72+
disableKeylessDriftDetection
6273
>
6374
{children}
6475
</ClientClerkProvider>
@@ -77,6 +88,7 @@ export const KeylessProvider = async (props: KeylessProviderProps) => {
7788
})}
7889
nonce={await generateNonce()}
7990
initialState={await generateStatePromise()}
91+
disableKeylessDriftDetection
8092
>
8193
{children}
8294
</ClientClerkProvider>
Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
import { type PropsWithChildren, Suspense } from 'react';
2+
import React from 'react';
3+
4+
// eslint-disable-next-line turbo/no-undeclared-env-vars
5+
const isNextCacheComponents = process.env.__NEXT_CACHE_COMPONENTS;
6+
7+
/**
8+
* Wraps the children in a Suspense component if the current environment is a Next.js cache component.
9+
* @param children - The children to render.
10+
* @param noopWhen - A condition to opt out of wrapping with Suspense.
11+
*/
12+
export const SuspenseWhenCached = ({
13+
children,
14+
noopWhen = false,
15+
}: PropsWithChildren<{
16+
/**
17+
* A condition to opt out of wrapping with Suspense.
18+
*/
19+
noopWhen?: boolean;
20+
}>) => {
21+
if (!isNextCacheComponents) {
22+
return children;
23+
}
24+
25+
if (noopWhen) {
26+
return children;
27+
}
28+
29+
return <Suspense>{children}</Suspense>;
30+
};

‎packages/nextjs/src/server/keyless-telemetry.ts‎

Lines changed: 18 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -6,8 +6,7 @@ import { nodeFsOrThrow, nodePathOrThrow } from './fs/utils';
66

77
const EVENT_KEYLESS_ENV_DRIFT_DETECTED = 'KEYLESS_ENV_DRIFT_DETECTED';
88
const EVENT_SAMPLING_RATE = 1; // 100% sampling rate
9-
const TELEMETRY_FLAG_FILE = '.clerk/.tmp/telemetry.json';
10-
9+
const TELEMETRY_FLAG_FILE_TEMPLATE = '.clerk/.tmp/telemetry.{pk}.log';
1110
type EventKeylessEnvDriftPayload = {
1211
publicKeyMatch: boolean;
1312
secretKeyMatch: boolean;
@@ -25,9 +24,9 @@ type EventKeylessEnvDriftPayload = {
2524
*
2625
* @returns The absolute path to the telemetry flag file in the project's .clerk/.tmp directory
2726
*/
28-
function getTelemetryFlagFilePath(): string {
27+
function getTelemetryFlagFilePath(pk: string): string {
2928
const path = nodePathOrThrow();
30-
return path.join(process.cwd(), TELEMETRY_FLAG_FILE);
29+
return path.join(process.cwd(), TELEMETRY_FLAG_FILE_TEMPLATE.replace('{pk}', pk));
3130
}
3231

3332
/**
@@ -41,26 +40,22 @@ function getTelemetryFlagFilePath(): string {
4140
* the event should be fired), false if the file already exists (meaning the event was
4241
* already fired) or if there was an error creating the file
4342
*/
44-
function tryMarkTelemetryEventAsFired(): boolean {
43+
function tryMarkTelemetryEventAsFired(pk: string): boolean {
44+
if (!canUseKeyless) {
45+
return false;
46+
}
4547
try {
46-
if (canUseKeyless) {
47-
const { mkdirSync, writeFileSync } = nodeFsOrThrow();
48-
const path = nodePathOrThrow();
49-
const flagFilePath = getTelemetryFlagFilePath();
50-
const flagDirectory = path.dirname(flagFilePath);
48+
const { mkdirSync, writeFileSync } = nodeFsOrThrow();
49+
const path = nodePathOrThrow();
50+
const flagFilePath = getTelemetryFlagFilePath(pk);
51+
const flagDirectory = path.dirname(flagFilePath);
5152

52-
// Ensure the directory exists before attempting to write the file
53-
mkdirSync(flagDirectory, { recursive: true });
53+
// Ensure the directory exists before attempting to write the file
54+
mkdirSync(flagDirectory, { recursive: true });
5455

55-
const flagData = {
56-
firedAt: new Date().toISOString(),
57-
event: EVENT_KEYLESS_ENV_DRIFT_DETECTED,
58-
};
59-
writeFileSync(flagFilePath, JSON.stringify(flagData, null, 2), { flag: 'wx' });
60-
return true;
61-
} else {
62-
return false;
63-
}
56+
const fileContent = `Content not important. File name is the identifier for the telemetry event.`;
57+
writeFileSync(flagFilePath, fileContent, { flag: 'wx' });
58+
return true;
6459
} catch (error: unknown) {
6560
if ((error as { code?: string })?.code === 'EEXIST') {
6661
return false;
@@ -96,10 +91,6 @@ export async function detectKeylessEnvDrift(): Promise<void> {
9691
if (!canUseKeyless) {
9792
return;
9893
}
99-
// Only run on server side
100-
if (typeof window !== 'undefined') {
101-
return;
102-
}
10394

10495
try {
10596
// Dynamically import server-side dependencies to avoid client-side issues
@@ -165,7 +156,7 @@ export async function detectKeylessEnvDrift(): Promise<void> {
165156
secretKeyMatch,
166157
envVarsMissing,
167158
keylessFileHasKeys,
168-
keylessPublishableKey: keylessFile.publishableKey ?? '',
159+
keylessPublishableKey: keylessFile.publishableKey,
169160
envPublishableKey: envPublishableKey ?? '',
170161
};
171162

@@ -178,7 +169,7 @@ export async function detectKeylessEnvDrift(): Promise<void> {
178169
},
179170
});
180171

181-
const shouldFireEvent = tryMarkTelemetryEventAsFired();
172+
const shouldFireEvent = tryMarkTelemetryEventAsFired(keylessFile.publishableKey);
182173

183174
if (shouldFireEvent) {
184175
// Fire drift detected event only if we successfully created the flag

0 commit comments

Comments
 (0)