zitejs 0.10.0-start.21 → 0.10.0-start.22
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cjs/auth/client.d.ts +2 -2
- package/dist/cjs/check/start/sourceRules.js +3 -0
- package/dist/cjs/cli.js +6 -0
- package/dist/cjs/dev/index.js +15 -0
- package/dist/cjs/dev/signin.d.ts +16 -0
- package/dist/cjs/dev/signin.js +76 -0
- package/dist/cjs/internal/appMode.d.ts +11 -0
- package/dist/cjs/internal/appMode.js +4 -1
- package/dist/cjs/internal/appToken.d.ts +17 -0
- package/dist/cjs/internal/appToken.js +26 -0
- package/dist/cjs/internal/platformFetch.d.ts +2 -0
- package/dist/cjs/internal/platformFetch.js +13 -0
- package/dist/cjs/internal/serviceUrls.d.ts +7 -0
- package/dist/cjs/internal/serviceUrls.js +16 -0
- package/dist/cjs/runtime/index.d.ts +1 -1
- package/dist/cjs/start/aiUsage.d.ts +23 -0
- package/dist/cjs/start/aiUsage.js +151 -0
- package/dist/cjs/start/devApp.d.ts +1 -0
- package/dist/cjs/start/devApp.js +6 -0
- package/dist/cjs/start/entries.js +4 -0
- package/dist/cjs/start/provider.d.ts +24 -0
- package/dist/cjs/start/provider.js +159 -0
- package/dist/cjs/start/types.d.ts +320 -0
- package/dist/cjs/start/types.js +2 -0
- package/dist/cjs/upload/index.js +73 -22
- package/dist/cjs/upload/index.test.js +35 -2
- package/dist/esm/auth/client.d.ts +2 -2
- package/dist/esm/check/start/sourceRules.js +3 -0
- package/dist/esm/cli.js +6 -0
- package/dist/esm/dev/index.js +15 -0
- package/dist/esm/dev/signin.d.ts +16 -0
- package/dist/esm/dev/signin.js +72 -0
- package/dist/esm/internal/appMode.d.ts +11 -0
- package/dist/esm/internal/appMode.js +2 -0
- package/dist/esm/internal/appToken.d.ts +17 -0
- package/dist/esm/internal/appToken.js +22 -0
- package/dist/esm/internal/platformFetch.d.ts +2 -0
- package/dist/esm/internal/platformFetch.js +8 -0
- package/dist/esm/internal/serviceUrls.d.ts +7 -0
- package/dist/esm/internal/serviceUrls.js +12 -0
- package/dist/esm/runtime/index.d.ts +1 -1
- package/dist/esm/signin/conformance.d.ts +100 -0
- package/dist/esm/signin/conformance.js +471 -0
- package/dist/esm/signin/cookies.d.ts +28 -0
- package/dist/esm/signin/cookies.js +59 -0
- package/dist/esm/signin/encoding.d.ts +9 -0
- package/dist/esm/signin/encoding.js +39 -0
- package/dist/esm/signin/endpoints.d.ts +12 -0
- package/dist/esm/signin/endpoints.js +29 -0
- package/dist/esm/signin/http.d.ts +25 -0
- package/dist/esm/signin/http.js +69 -0
- package/dist/esm/signin/index.d.ts +8 -0
- package/dist/esm/signin/index.js +9 -0
- package/dist/esm/signin/keys.d.ts +39 -0
- package/dist/esm/signin/keys.js +80 -0
- package/dist/esm/signin/paths.d.ts +2 -0
- package/dist/esm/signin/paths.js +2 -0
- package/dist/esm/signin/seal.d.ts +8 -0
- package/dist/esm/signin/seal.js +35 -0
- package/dist/esm/signin/signin.d.ts +60 -0
- package/dist/esm/signin/signin.js +340 -0
- package/dist/esm/signin/transport.d.ts +111 -0
- package/dist/esm/signin/transport.js +1 -0
- package/dist/esm/signin/verify.d.ts +77 -0
- package/dist/esm/signin/verify.js +155 -0
- package/dist/esm/start/airtable/index.d.ts +1 -1
- package/dist/esm/start/analytics.d.ts +5 -0
- package/dist/esm/start/analytics.js +77 -0
- package/dist/esm/start/data/index.d.ts +3 -3
- package/dist/esm/start/data/index.js +1 -1
- package/dist/esm/start/devApp.d.ts +1 -0
- package/dist/esm/start/devApp.js +3 -0
- package/dist/esm/start/devSignIn.d.ts +1 -0
- package/dist/esm/start/devSignIn.js +3 -0
- package/dist/esm/start/direct.d.ts +40 -0
- package/dist/esm/start/direct.js +313 -0
- package/dist/esm/start/entries.js +4 -0
- package/dist/esm/start/fetch.d.ts +1 -0
- package/dist/esm/start/fetch.js +4 -0
- package/dist/esm/start/instance.js +6 -2
- package/dist/esm/start/localSignIn.d.ts +18 -0
- package/dist/esm/start/localSignIn.js +73 -0
- package/dist/esm/start/outbound.d.ts +10 -1
- package/dist/esm/start/outbound.js +132 -22
- package/dist/esm/start/pageHead.d.ts +36 -0
- package/dist/esm/start/pageHead.js +178 -0
- package/dist/esm/start/provider.d.ts +24 -0
- package/dist/esm/start/provider.js +150 -0
- package/dist/esm/start/router.d.ts +6 -2
- package/dist/esm/start/router.js +41 -2
- package/dist/esm/start/server.d.ts +13 -6
- package/dist/esm/start/server.js +173 -42
- package/dist/esm/start/telemetry.d.ts +10 -0
- package/dist/esm/start/telemetry.js +74 -0
- package/dist/esm/start/types.d.ts +117 -2
- package/dist/esm/start/uploads.d.ts +2 -0
- package/dist/esm/start/uploads.js +52 -0
- package/dist/esm/start/version.d.ts +1 -1
- package/dist/esm/start/version.js +1 -1
- package/dist/esm/start/vite.d.ts +12 -1
- package/dist/esm/start/vite.js +116 -4
- package/dist/esm/start/workspaceSchema.d.ts +1 -0
- package/dist/esm/start/workspaceSchema.js +3 -0
- package/dist/esm/upload/index.js +74 -23
- package/dist/esm/upload/index.test.js +35 -2
- package/package.json +21 -11
- package/dist/cjs/auth-server/index.d.ts +0 -369
- package/dist/cjs/auth-server/index.js +0 -119
- package/dist/esm/auth-server/index.d.ts +0 -369
- package/dist/esm/auth-server/index.js +0 -116
- package/dist/esm/start/problems.d.ts +0 -19
- package/dist/esm/start/problems.js +0 -8
|
@@ -0,0 +1,340 @@
|
|
|
1
|
+
// The sign-in client (T5 design §3, §5): an OIDC relying party for one app and mode. On Zite the dispatcher runs it
|
|
2
|
+
// for every app before dispatch; off Zite the app mounts it. The transport is the only difference.
|
|
3
|
+
import { clearCookie, cookieName, cookiePairs, isModuleCookie, readCookies, setCookie, withoutCookies } from "./cookies.js";
|
|
4
|
+
import { fromBase64Url, isRecord, jsonOf, randomToken, s256, toBase64Url, utf8 } from "./encoding.js";
|
|
5
|
+
import { ziteEndpoints } from "./endpoints.js";
|
|
6
|
+
import { staticIdentityKeys } from "./keys.js";
|
|
7
|
+
import { createIdentityVerifier, DEFAULT_MAX_LIFETIME_S, } from "./verify.js";
|
|
8
|
+
export { isSignInPath } from "./paths.js";
|
|
9
|
+
/** The preview identity's query parameter and header, as old builds carry them. */
|
|
10
|
+
export const PREVIEW_IDENTITY_PARAM = "zite_preview";
|
|
11
|
+
export const PREVIEW_IDENTITY_HEADER = "x-zite-preview";
|
|
12
|
+
const FLOW_TTL_S = 600;
|
|
13
|
+
// The refresh token's own life, as the identity server issues it.
|
|
14
|
+
const SESSION_TTL_S = 30 * 24 * 3600;
|
|
15
|
+
const MAX_RETURN_TO = 2048;
|
|
16
|
+
const NAME_MAX = 200;
|
|
17
|
+
const NO_STORE = { "cache-control": "no-store" };
|
|
18
|
+
const respond = (status, body, setCookies, headers = {}) => {
|
|
19
|
+
const out = new Headers({ ...NO_STORE, ...headers });
|
|
20
|
+
for (const cookie of setCookies)
|
|
21
|
+
out.append("set-cookie", cookie);
|
|
22
|
+
return new Response(body, { status, headers: out });
|
|
23
|
+
};
|
|
24
|
+
const json = (status, body, setCookies = []) => respond(status, JSON.stringify(body), setCookies, { "content-type": "application/json" });
|
|
25
|
+
const redirect = (location, setCookies, headers = {}) => respond(302, null, setCookies, { location, ...headers });
|
|
26
|
+
const plain = (status, text, setCookies = []) => respond(status, text, setCookies, { "content-type": "text/plain; charset=utf-8" });
|
|
27
|
+
/** A same-origin destination from `raw`, absolute so no path can read as another host; the root otherwise. */
|
|
28
|
+
const returnToOf = (raw, origin) => {
|
|
29
|
+
if (!raw || raw.length > MAX_RETURN_TO)
|
|
30
|
+
return `${origin}/`;
|
|
31
|
+
try {
|
|
32
|
+
const target = new URL(raw, origin);
|
|
33
|
+
return target.origin === origin ? target.href : `${origin}/`;
|
|
34
|
+
}
|
|
35
|
+
catch {
|
|
36
|
+
return `${origin}/`;
|
|
37
|
+
}
|
|
38
|
+
};
|
|
39
|
+
const isSameOrigin = (request, origin) => request.headers.get("sec-fetch-site") === "same-origin" || request.headers.get("origin") === origin;
|
|
40
|
+
const ERROR_CODE = /^[A-Za-z0-9_.-]{1,64}$/;
|
|
41
|
+
const flowOf = (value, nowS) => {
|
|
42
|
+
const flow = value ? jsonOf(fromBase64Url(value)) : undefined;
|
|
43
|
+
if (!isRecord(flow))
|
|
44
|
+
return undefined;
|
|
45
|
+
const { state, verifier, nonce, returnTo, redirectUri, iat } = flow;
|
|
46
|
+
const strings = [state, verifier, nonce, returnTo, redirectUri];
|
|
47
|
+
if (!strings.every((field) => typeof field === "string" && field) || typeof iat !== "number")
|
|
48
|
+
return undefined;
|
|
49
|
+
if (iat > nowS + 5 || nowS - iat > FLOW_TTL_S)
|
|
50
|
+
return undefined;
|
|
51
|
+
return flow;
|
|
52
|
+
};
|
|
53
|
+
const iso = (seconds) => new Date(seconds * 1000).toISOString();
|
|
54
|
+
/** better-auth's `get-session` answer, which old builds' `useSession` reads. */
|
|
55
|
+
const sessionBody = (claims) => ({
|
|
56
|
+
session: {
|
|
57
|
+
id: `${claims.sub}_session`,
|
|
58
|
+
userId: claims.sub,
|
|
59
|
+
expiresAt: iso(claims.exp),
|
|
60
|
+
createdAt: iso(claims.iat),
|
|
61
|
+
updatedAt: iso(claims.iat),
|
|
62
|
+
},
|
|
63
|
+
user: {
|
|
64
|
+
id: claims.sub,
|
|
65
|
+
email: claims.email,
|
|
66
|
+
name: claims.name,
|
|
67
|
+
...(claims.firstName !== undefined && { firstName: claims.firstName }),
|
|
68
|
+
...(claims.lastName !== undefined && { lastName: claims.lastName }),
|
|
69
|
+
emailVerified: true,
|
|
70
|
+
image: null,
|
|
71
|
+
createdAt: iso(claims.iat),
|
|
72
|
+
updatedAt: iso(claims.iat),
|
|
73
|
+
},
|
|
74
|
+
});
|
|
75
|
+
const profileChangesOf = (body) => {
|
|
76
|
+
if (!isRecord(body))
|
|
77
|
+
return "The body must be a JSON object";
|
|
78
|
+
const changes = {};
|
|
79
|
+
for (const [field, value] of Object.entries(body)) {
|
|
80
|
+
if (field !== "firstName" && field !== "lastName")
|
|
81
|
+
return `${field} can't be changed here`;
|
|
82
|
+
if (typeof value !== "string" || value.length > NAME_MAX)
|
|
83
|
+
return `${field} must be a string of at most ${NAME_MAX} characters`;
|
|
84
|
+
changes[field] = value;
|
|
85
|
+
}
|
|
86
|
+
return Object.keys(changes).length > 0 ? changes : "Nothing to change";
|
|
87
|
+
};
|
|
88
|
+
export const createSignIn = (config) => {
|
|
89
|
+
const endpoints = { ...ziteEndpoints(config.issuer), ...config.endpoints };
|
|
90
|
+
if (!config.app || config.app.includes(":") || config.clientId !== `${config.app}:${config.mode}`) {
|
|
91
|
+
throw new Error(`The sign-in client must be <app>:<mode>, not ${config.clientId}`);
|
|
92
|
+
}
|
|
93
|
+
if (config.cookies.framed && config.mode !== "preview" && config.mode !== "demo") {
|
|
94
|
+
throw new Error("Only previews and demos are framed; a live host's cookies are never Partitioned");
|
|
95
|
+
}
|
|
96
|
+
const { transport } = config;
|
|
97
|
+
// `test` on a global or sticky pattern remembers where it stopped, and would skip every other cookie.
|
|
98
|
+
if (transport.longLived.kind === "session-cookie" && (transport.longLived.names.global || transport.longLived.names.sticky)) {
|
|
99
|
+
throw new Error("The session cookies' pattern can't be global or sticky");
|
|
100
|
+
}
|
|
101
|
+
const now = config.now ?? Date.now;
|
|
102
|
+
const nowS = () => Math.floor(now() / 1000);
|
|
103
|
+
const context = config.cookies;
|
|
104
|
+
// Never framed: off Zite only, and a refresh token stays first-party.
|
|
105
|
+
const sessionContext = { secure: context.secure, framed: false };
|
|
106
|
+
const keySource = "current" in config.keys && typeof config.keys.current === "function"
|
|
107
|
+
? config.keys
|
|
108
|
+
: staticIdentityKeys(config.keys);
|
|
109
|
+
const verifier = createIdentityVerifier(keySource, { onRefusal: config.onRefusal });
|
|
110
|
+
const scope = transport.longLived.kind === "refresh-token" ? "openid offline_access" : "openid";
|
|
111
|
+
const longLivedNames = transport.longLived.kind === "session-cookie" ? transport.longLived.names : undefined;
|
|
112
|
+
const isPreview = config.mode === "preview";
|
|
113
|
+
const verify = (token, expect = {}) => verifier(token, {
|
|
114
|
+
issuer: config.issuer,
|
|
115
|
+
clientId: config.clientId,
|
|
116
|
+
ver: config.ver,
|
|
117
|
+
previewBuild: config.previewBuild,
|
|
118
|
+
nonce: expect.nonce,
|
|
119
|
+
maxLifetimeS: config.identityLifetimeS ?? DEFAULT_MAX_LIFETIME_S,
|
|
120
|
+
now: now(),
|
|
121
|
+
});
|
|
122
|
+
const identityCookie = (token, claims) => setCookie("identity", token, context, Math.max(claims.exp - nowS(), 1));
|
|
123
|
+
const sessionCookies = async (refreshToken, idToken) => {
|
|
124
|
+
if (transport.longLived.kind !== "refresh-token" || !refreshToken)
|
|
125
|
+
return [];
|
|
126
|
+
const sealed = await transport.longLived.sealer.seal(JSON.stringify({ v: 1, c: config.clientId, rt: refreshToken, it: idToken }));
|
|
127
|
+
return [setCookie("session", sealed, sessionContext, SESSION_TTL_S)];
|
|
128
|
+
};
|
|
129
|
+
/** The long-lived credential the request carries, and clears for one this module can't read. */
|
|
130
|
+
const credentialOf = async (sent, header) => {
|
|
131
|
+
if (transport.longLived.kind === "session-cookie") {
|
|
132
|
+
const value = cookiePairs(header, transport.longLived.names);
|
|
133
|
+
return { credential: value ? { value } : undefined, clears: [] };
|
|
134
|
+
}
|
|
135
|
+
const sealed = sent.get(cookieName("session", context.secure));
|
|
136
|
+
if (!sealed)
|
|
137
|
+
return { clears: [] };
|
|
138
|
+
const opened = jsonOf(utf8((await transport.longLived.sealer.open(sealed)) ?? ""));
|
|
139
|
+
if (!isRecord(opened) || opened.v !== 1 || opened.c !== config.clientId || typeof opened.rt !== "string") {
|
|
140
|
+
return { clears: [clearCookie("session", sessionContext)] };
|
|
141
|
+
}
|
|
142
|
+
return { credential: { value: opened.rt, ...(typeof opened.it === "string" && { idToken: opened.it }) }, clears: [] };
|
|
143
|
+
};
|
|
144
|
+
const resolveWith = async (request) => {
|
|
145
|
+
const header = request.headers.get("cookie");
|
|
146
|
+
const sent = readCookies(header);
|
|
147
|
+
const cookie = withoutCookies(header, (name) => isModuleCookie(name) || (longLivedNames?.test(name) ?? false));
|
|
148
|
+
const fromCookie = sent.get(cookieName("identity", context.secure));
|
|
149
|
+
const fromFrame = isPreview
|
|
150
|
+
? (request.headers.get(PREVIEW_IDENTITY_HEADER) ?? new URL(request.url).searchParams.get(PREVIEW_IDENTITY_PARAM) ?? undefined)
|
|
151
|
+
: undefined;
|
|
152
|
+
const token = fromCookie ?? fromFrame;
|
|
153
|
+
const clearIdentity = fromCookie !== undefined ? [clearCookie("identity", context)] : [];
|
|
154
|
+
let reason = "expired";
|
|
155
|
+
if (token) {
|
|
156
|
+
const verdict = await verify(token);
|
|
157
|
+
if (verdict.status === "valid") {
|
|
158
|
+
return { user: verdict.claims, state: "valid", setCookies: [], cookie, ...(isPreview && { previewToken: token }) };
|
|
159
|
+
}
|
|
160
|
+
if (verdict.status === "refused")
|
|
161
|
+
return { user: null, state: "refused", reason: verdict.reason, setCookies: clearIdentity, cookie };
|
|
162
|
+
if (verdict.status === "stale")
|
|
163
|
+
reason = "ver";
|
|
164
|
+
}
|
|
165
|
+
const { credential, clears } = await credentialOf(sent, header);
|
|
166
|
+
if (!credential)
|
|
167
|
+
return { user: null, state: "anonymous", setCookies: [...clearIdentity, ...clears], cookie };
|
|
168
|
+
const outcome = await transport.renew({ longLived: credential.value, reason, ver: config.ver === "any" ? null : config.ver });
|
|
169
|
+
if (outcome.kind === "unavailable")
|
|
170
|
+
return { user: null, state: "anonymous", setCookies: [], cookie, credential };
|
|
171
|
+
if (outcome.kind === "signed-out") {
|
|
172
|
+
const clearSession = transport.longLived.kind === "refresh-token" ? [clearCookie("session", sessionContext)] : [];
|
|
173
|
+
return {
|
|
174
|
+
user: null,
|
|
175
|
+
state: "anonymous",
|
|
176
|
+
...(outcome.code && { reason: outcome.code }),
|
|
177
|
+
setCookies: [...clearIdentity, ...clearSession, ...(outcome.setCookies ?? [])],
|
|
178
|
+
cookie,
|
|
179
|
+
};
|
|
180
|
+
}
|
|
181
|
+
const renewed = await verify(outcome.idToken);
|
|
182
|
+
// A token that just lapsed or names an older version is still the server's answer; anything else is refused.
|
|
183
|
+
if (renewed.status === "refused") {
|
|
184
|
+
return { user: null, state: "refused", reason: renewed.reason, setCookies: [...clearIdentity, ...(outcome.setCookies ?? [])], cookie };
|
|
185
|
+
}
|
|
186
|
+
return {
|
|
187
|
+
user: renewed.claims,
|
|
188
|
+
state: "renewed",
|
|
189
|
+
setCookies: [
|
|
190
|
+
identityCookie(outcome.idToken, renewed.claims),
|
|
191
|
+
...(await sessionCookies(outcome.refreshToken ?? credential.value, outcome.idToken)),
|
|
192
|
+
...(outcome.setCookies ?? []),
|
|
193
|
+
],
|
|
194
|
+
cookie,
|
|
195
|
+
credential: { value: outcome.refreshToken ?? credential.value, idToken: outcome.idToken },
|
|
196
|
+
...(isPreview && { previewToken: outcome.idToken }),
|
|
197
|
+
};
|
|
198
|
+
};
|
|
199
|
+
const resolve = async (request) => {
|
|
200
|
+
const { credential: _credential, ...resolution } = await resolveWith(request);
|
|
201
|
+
return resolution;
|
|
202
|
+
};
|
|
203
|
+
const login = async (url) => {
|
|
204
|
+
const verifierValue = randomToken(32);
|
|
205
|
+
const flow = {
|
|
206
|
+
state: randomToken(16),
|
|
207
|
+
verifier: verifierValue,
|
|
208
|
+
nonce: randomToken(16),
|
|
209
|
+
returnTo: returnToOf(url.searchParams.get("redirectUrl"), url.origin),
|
|
210
|
+
redirectUri: config.redirectUri ?? `${url.origin}/auth/callback`,
|
|
211
|
+
iat: nowS(),
|
|
212
|
+
};
|
|
213
|
+
const authorize = new URL(endpoints.authorize);
|
|
214
|
+
authorize.search = new URLSearchParams({
|
|
215
|
+
response_type: "code",
|
|
216
|
+
client_id: config.clientId,
|
|
217
|
+
redirect_uri: flow.redirectUri,
|
|
218
|
+
scope,
|
|
219
|
+
state: flow.state,
|
|
220
|
+
nonce: flow.nonce,
|
|
221
|
+
code_challenge: await s256(verifierValue),
|
|
222
|
+
code_challenge_method: "S256",
|
|
223
|
+
}).toString();
|
|
224
|
+
return redirect(authorize.href, [setCookie("flow", toBase64Url(utf8(JSON.stringify(flow))), context, FLOW_TTL_S)], {
|
|
225
|
+
"referrer-policy": "no-referrer",
|
|
226
|
+
});
|
|
227
|
+
};
|
|
228
|
+
const callback = async (request, url) => {
|
|
229
|
+
const clearFlow = clearCookie("flow", context);
|
|
230
|
+
const flow = flowOf(readCookies(request.headers.get("cookie")).get(cookieName("flow", context.secure)), nowS());
|
|
231
|
+
const error = url.searchParams.get("error");
|
|
232
|
+
if (error !== null) {
|
|
233
|
+
const code = ERROR_CODE.test(error) ? error : "AUTH_FAILED";
|
|
234
|
+
return redirect(`${endpoints.signInPage}?error=${encodeURIComponent(code)}`, [clearFlow]);
|
|
235
|
+
}
|
|
236
|
+
const refused = (why) => {
|
|
237
|
+
console.warn(`[zite] sign-in callback refused: ${why}`);
|
|
238
|
+
return plain(400, "This sign-in didn't complete. Go back to the app and sign in again.", [clearFlow]);
|
|
239
|
+
};
|
|
240
|
+
if (!flow || url.searchParams.get("state") !== flow.state)
|
|
241
|
+
return refused("no sign-in in progress, or another one's state");
|
|
242
|
+
// RFC 9207: the issuer names itself on every answer, so a code minted on another host (another issuer) never
|
|
243
|
+
// redeems here, and a callback stripped of it is no answer at all.
|
|
244
|
+
if (url.searchParams.get("iss") !== config.issuer)
|
|
245
|
+
return refused("no issuer, or another");
|
|
246
|
+
const code = url.searchParams.get("code");
|
|
247
|
+
if (!code)
|
|
248
|
+
return refused("no code");
|
|
249
|
+
const exchanged = await transport.exchange({ code, verifier: flow.verifier, redirectUri: flow.redirectUri });
|
|
250
|
+
if (exchanged.kind === "failed") {
|
|
251
|
+
console.warn(`[zite] the token endpoint refused the sign-in: ${exchanged.error}`);
|
|
252
|
+
return redirect(`${endpoints.signInPage}?error=AUTH_FAILED`, [clearFlow]);
|
|
253
|
+
}
|
|
254
|
+
const verdict = await verify(exchanged.idToken, { nonce: flow.nonce });
|
|
255
|
+
if (verdict.status === "refused" || verdict.status === "expired") {
|
|
256
|
+
return refused(verdict.status === "refused" ? verdict.reason : "expired");
|
|
257
|
+
}
|
|
258
|
+
return redirect(flow.returnTo, [
|
|
259
|
+
clearFlow,
|
|
260
|
+
identityCookie(exchanged.idToken, verdict.claims),
|
|
261
|
+
...(await sessionCookies(exchanged.refreshToken, exchanged.idToken)),
|
|
262
|
+
...(exchanged.setCookies ?? []),
|
|
263
|
+
], { "referrer-policy": "no-referrer" });
|
|
264
|
+
};
|
|
265
|
+
const logout = async (request, url) => {
|
|
266
|
+
if (!isSameOrigin(request, url.origin))
|
|
267
|
+
return json(403, { code: "CROSS_SITE", message: "Sign out from the app itself" });
|
|
268
|
+
const header = request.headers.get("cookie");
|
|
269
|
+
const sent = readCookies(header);
|
|
270
|
+
const { credential } = await credentialOf(sent, header);
|
|
271
|
+
let serverClears = [];
|
|
272
|
+
try {
|
|
273
|
+
const idToken = sent.get(cookieName("identity", context.secure)) ?? credential?.idToken ?? null;
|
|
274
|
+
serverClears = (await transport.endSession({ longLived: credential?.value ?? null, idToken })).setCookies ?? [];
|
|
275
|
+
}
|
|
276
|
+
catch (error) {
|
|
277
|
+
console.error("[zite] couldn't end the session at the identity server", error);
|
|
278
|
+
}
|
|
279
|
+
return json(200, { success: true }, [
|
|
280
|
+
clearCookie("identity", context),
|
|
281
|
+
clearCookie("flow", context),
|
|
282
|
+
...(transport.longLived.kind === "refresh-token" ? [clearCookie("session", sessionContext)] : []),
|
|
283
|
+
...serverClears,
|
|
284
|
+
]);
|
|
285
|
+
};
|
|
286
|
+
const getSession = async (request) => {
|
|
287
|
+
const { user, setCookies } = await resolve(request);
|
|
288
|
+
return json(200, user ? sessionBody(user) : null, setCookies);
|
|
289
|
+
};
|
|
290
|
+
const updateUser = async (request, url) => {
|
|
291
|
+
if (!isSameOrigin(request, url.origin))
|
|
292
|
+
return json(403, { code: "CROSS_SITE", message: "Update the profile from the app itself" });
|
|
293
|
+
if (config.mode === "demo")
|
|
294
|
+
return json(403, { code: "READ_ONLY", message: "A demo can't change its profile" });
|
|
295
|
+
const changes = profileChangesOf(await request.json().catch(() => undefined));
|
|
296
|
+
if (typeof changes === "string")
|
|
297
|
+
return json(400, { code: "FIELD_NOT_ALLOWED", message: changes });
|
|
298
|
+
const resolved = await resolveWith(request);
|
|
299
|
+
const header = request.headers.get("cookie");
|
|
300
|
+
const credential = resolved.credential ?? (await credentialOf(readCookies(header), header)).credential;
|
|
301
|
+
if (!resolved.user || !credential)
|
|
302
|
+
return json(401, { code: "UNAUTHORIZED", message: "Sign in first" }, resolved.setCookies);
|
|
303
|
+
const outcome = await transport.updateProfile({ longLived: credential.value, changes });
|
|
304
|
+
if (outcome.kind === "unsupported") {
|
|
305
|
+
return json(501, { code: "PROFILE_UPDATE_UNAVAILABLE", message: "Profile changes aren't available here" }, resolved.setCookies);
|
|
306
|
+
}
|
|
307
|
+
if (outcome.kind === "failed")
|
|
308
|
+
return json(outcome.status, { code: outcome.code }, resolved.setCookies);
|
|
309
|
+
const reissued = outcome.idToken ? await verify(outcome.idToken) : undefined;
|
|
310
|
+
const fresh = reissued && reissued.status !== "refused" && outcome.idToken ? identityCookie(outcome.idToken, reissued.claims) : undefined;
|
|
311
|
+
const identityName = `${cookieName("identity", context.secure)}=`;
|
|
312
|
+
return json(200, { status: true }, [
|
|
313
|
+
...resolved.setCookies.filter((cookie) => !fresh || !cookie.startsWith(identityName)),
|
|
314
|
+
...(fresh ? [fresh] : []),
|
|
315
|
+
...(outcome.setCookies ?? []),
|
|
316
|
+
]);
|
|
317
|
+
};
|
|
318
|
+
const routes = {
|
|
319
|
+
// Demos sign in through the dispatcher's own flow, never an authorization code.
|
|
320
|
+
"/auth/login": { method: "GET", modes: ["live", "preview", "dev"], run: (_request, url) => login(url) },
|
|
321
|
+
"/auth/callback": { method: "GET", modes: ["live", "preview", "dev"], run: callback },
|
|
322
|
+
"/auth/logout": { method: "POST", run: logout },
|
|
323
|
+
"/api/auth/sign-out": { method: "POST", run: logout },
|
|
324
|
+
"/api/auth/get-session": { method: "GET", run: getSession },
|
|
325
|
+
"/api/auth/update-user": { method: "POST", run: updateUser },
|
|
326
|
+
};
|
|
327
|
+
return {
|
|
328
|
+
verify,
|
|
329
|
+
resolve,
|
|
330
|
+
async handle(request) {
|
|
331
|
+
const url = new URL(request.url);
|
|
332
|
+
const route = Object.hasOwn(routes, url.pathname) ? routes[url.pathname] : undefined;
|
|
333
|
+
if (!route || (route.modes && !route.modes.includes(config.mode)))
|
|
334
|
+
return undefined;
|
|
335
|
+
if (request.method !== route.method)
|
|
336
|
+
return respond(405, null, [], { allow: route.method });
|
|
337
|
+
return route.run(request, url);
|
|
338
|
+
},
|
|
339
|
+
};
|
|
340
|
+
};
|
|
@@ -0,0 +1,111 @@
|
|
|
1
|
+
import type { Sealer } from "./seal.js";
|
|
2
|
+
/**
|
|
3
|
+
* How the module reaches the identity server: the only difference between Zite and anywhere else (T5 design §3.1).
|
|
4
|
+
* On Zite the dispatcher implements it over its binding to the identity Worker (`platformTransport`, in restly); off
|
|
5
|
+
* Zite `httpTransport` speaks standard OIDC to the identity server's public endpoints.
|
|
6
|
+
*/
|
|
7
|
+
export type Transport = {
|
|
8
|
+
/** What the long-lived credential is, and where it lives. */
|
|
9
|
+
longLived: LongLived;
|
|
10
|
+
/** The authorization code grant, with the PKCE verifier. */
|
|
11
|
+
exchange(input: {
|
|
12
|
+
code: string;
|
|
13
|
+
verifier: string;
|
|
14
|
+
redirectUri: string;
|
|
15
|
+
}): Promise<ExchangeOutcome>;
|
|
16
|
+
/**
|
|
17
|
+
* A fresh identity from the long-lived credential. `reason` says why: the identity lapsed (or there was none), or
|
|
18
|
+
* it was issued under an older org settings version, which must re-run the sign-in policy without its caches.
|
|
19
|
+
*/
|
|
20
|
+
renew(input: {
|
|
21
|
+
longLived: string;
|
|
22
|
+
reason: RenewReason;
|
|
23
|
+
ver: number | null;
|
|
24
|
+
}): Promise<RenewOutcome>;
|
|
25
|
+
/** Ends the credential's session. Best effort: the module clears its own cookies whatever this answers. */
|
|
26
|
+
endSession(input: {
|
|
27
|
+
longLived: string | null;
|
|
28
|
+
idToken: string | null;
|
|
29
|
+
}): Promise<{
|
|
30
|
+
setCookies?: string[];
|
|
31
|
+
}>;
|
|
32
|
+
/** Writes the two name fields, the only profile write an app may make. */
|
|
33
|
+
updateProfile(input: {
|
|
34
|
+
longLived: string;
|
|
35
|
+
changes: ProfileChanges;
|
|
36
|
+
}): Promise<ProfileOutcome>;
|
|
37
|
+
};
|
|
38
|
+
export type LongLived =
|
|
39
|
+
/** The identity server's own session cookies, which the browser holds; the module only reads and strips them. */
|
|
40
|
+
{
|
|
41
|
+
kind: "session-cookie";
|
|
42
|
+
names: RegExp;
|
|
43
|
+
}
|
|
44
|
+
/** A refresh token the module holds itself, sealed into its `zite_session` cookie. */
|
|
45
|
+
| {
|
|
46
|
+
kind: "refresh-token";
|
|
47
|
+
sealer: Sealer;
|
|
48
|
+
};
|
|
49
|
+
export type RenewReason = "expired" | "ver";
|
|
50
|
+
export type ProfileChanges = {
|
|
51
|
+
firstName?: string;
|
|
52
|
+
lastName?: string;
|
|
53
|
+
};
|
|
54
|
+
export type ExchangeOutcome = {
|
|
55
|
+
kind: "issued";
|
|
56
|
+
idToken: string;
|
|
57
|
+
refreshToken?: string;
|
|
58
|
+
setCookies?: string[];
|
|
59
|
+
} | {
|
|
60
|
+
kind: "failed";
|
|
61
|
+
error: string;
|
|
62
|
+
};
|
|
63
|
+
export type RenewOutcome = {
|
|
64
|
+
kind: "renewed";
|
|
65
|
+
idToken: string;
|
|
66
|
+
refreshToken?: string;
|
|
67
|
+
setCookies?: string[];
|
|
68
|
+
}
|
|
69
|
+
/** The credential is gone or the policy refused it: the module clears it, and `setCookies` (the server's clears). */
|
|
70
|
+
| {
|
|
71
|
+
kind: "signed-out";
|
|
72
|
+
code?: string;
|
|
73
|
+
setCookies?: string[];
|
|
74
|
+
}
|
|
75
|
+
/** The identity server couldn't answer: anonymous for this request, the credential kept. */
|
|
76
|
+
| {
|
|
77
|
+
kind: "unavailable";
|
|
78
|
+
};
|
|
79
|
+
export type ProfileOutcome = {
|
|
80
|
+
kind: "updated";
|
|
81
|
+
idToken?: string;
|
|
82
|
+
setCookies?: string[];
|
|
83
|
+
} | {
|
|
84
|
+
kind: "failed";
|
|
85
|
+
status: number;
|
|
86
|
+
code: string;
|
|
87
|
+
}
|
|
88
|
+
/** No profile route here (off Zite today). */
|
|
89
|
+
| {
|
|
90
|
+
kind: "unsupported";
|
|
91
|
+
};
|
|
92
|
+
/**
|
|
93
|
+
* What restly's dispatcher passes on each call to the identity Worker, besides the `x-zite-*` headers it sets from
|
|
94
|
+
* routing. Implemented in restly (`apps/zite-host/src/signin.ts`); zitejs only names the shape.
|
|
95
|
+
*/
|
|
96
|
+
export type PlatformTransportContext = {
|
|
97
|
+
app: string;
|
|
98
|
+
mode: "live" | "preview" | "demo";
|
|
99
|
+
build: number;
|
|
100
|
+
org: number;
|
|
101
|
+
ver: number | null;
|
|
102
|
+
/** The app's origin: the issuer is `${origin}/auth`. */
|
|
103
|
+
origin: string;
|
|
104
|
+
visitorIp?: string;
|
|
105
|
+
};
|
|
106
|
+
/** The identity Worker's service binding, as the dispatcher holds it. */
|
|
107
|
+
export type IdentityBinding = {
|
|
108
|
+
fetch(request: Request): Promise<Response>;
|
|
109
|
+
};
|
|
110
|
+
/** restly's `platformTransport(binding, context)`: every method one `binding.fetch` with `x-zite-caller: dispatcher`. */
|
|
111
|
+
export type PlatformTransportFactory = (binding: IdentityBinding, context: PlatformTransportContext) => Transport;
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
export {};
|
|
@@ -0,0 +1,77 @@
|
|
|
1
|
+
import { type IdentityKeySource } from "./keys.js";
|
|
2
|
+
export type IdentityMode = "live" | "preview" | "demo" | "dev";
|
|
3
|
+
/** The `typ` every identity token carries in its header, and nothing else does. */
|
|
4
|
+
export declare const IDENTITY_TOKEN_TYPE = "zite-id+jwt";
|
|
5
|
+
/** An identity token's claims, as the identity server signs them. */
|
|
6
|
+
export type IdentityClaims = {
|
|
7
|
+
/** `https://<host>/auth`: the origin the identity was issued on. */
|
|
8
|
+
iss: string;
|
|
9
|
+
/** The `zite_user` id. */
|
|
10
|
+
sub: string;
|
|
11
|
+
/** `<app>:<mode>`. */
|
|
12
|
+
aud: string;
|
|
13
|
+
/** Absent in practice (the OIDC plugin reserves it); equal to `aud` when present. */
|
|
14
|
+
azp?: string;
|
|
15
|
+
iat: number;
|
|
16
|
+
exp: number;
|
|
17
|
+
sid?: string;
|
|
18
|
+
nonce?: string;
|
|
19
|
+
email: string;
|
|
20
|
+
name: string;
|
|
21
|
+
firstName?: string;
|
|
22
|
+
lastName?: string;
|
|
23
|
+
/** Role ids. */
|
|
24
|
+
roles: string[];
|
|
25
|
+
isInternal: boolean;
|
|
26
|
+
mode: IdentityMode;
|
|
27
|
+
/** The org settings version it was issued under. */
|
|
28
|
+
ver: number | null;
|
|
29
|
+
/** On previews: the build, and the editor impersonating `sub`. */
|
|
30
|
+
preview?: {
|
|
31
|
+
build: number;
|
|
32
|
+
editor: string;
|
|
33
|
+
};
|
|
34
|
+
};
|
|
35
|
+
/** Why a token was refused. Each is a forgery, a token from somewhere else, or a bug; never a lapse of time. */
|
|
36
|
+
export type Refusal = "malformed" | "alg" | "typ" | "kid" | "key kind" | "signature" | "iss" | "aud" | "azp" | "iat" | "lifetime" | "sub" | "mode" | "claims" | "preview" | "nonce";
|
|
37
|
+
/**
|
|
38
|
+
* `expired` and `stale` (issued under another org settings version) are genuine and renewable; `refused` is not and
|
|
39
|
+
* clears the cookie.
|
|
40
|
+
*/
|
|
41
|
+
export type Verdict = {
|
|
42
|
+
status: "valid" | "expired" | "stale";
|
|
43
|
+
claims: IdentityClaims;
|
|
44
|
+
} | {
|
|
45
|
+
status: "refused";
|
|
46
|
+
reason: Refusal;
|
|
47
|
+
kid?: string;
|
|
48
|
+
};
|
|
49
|
+
export type VerifyExpectations = {
|
|
50
|
+
/** Computed from where the request was served, never read from the token. */
|
|
51
|
+
issuer: string;
|
|
52
|
+
/** `<app>:<mode>`, from routing. */
|
|
53
|
+
clientId: string;
|
|
54
|
+
/** The version the identity must carry, or `any` where it can't be known (off Zite). */
|
|
55
|
+
ver: number | null | "any";
|
|
56
|
+
/** A snapshot host pinned to one build. */
|
|
57
|
+
previewBuild?: number;
|
|
58
|
+
/** The nonce the sign-in sent, on the callback only. */
|
|
59
|
+
nonce?: string;
|
|
60
|
+
/** The longest `exp - iat` accepted. Identities are issued for 60 s; this keeps a mis-set option from minting days. */
|
|
61
|
+
maxLifetimeS?: number;
|
|
62
|
+
/** Milliseconds since the epoch. */
|
|
63
|
+
now?: number;
|
|
64
|
+
};
|
|
65
|
+
export declare const DEFAULT_MAX_LIFETIME_S = 300;
|
|
66
|
+
export type RefusalReport = {
|
|
67
|
+
reason: Refusal;
|
|
68
|
+
kid?: string;
|
|
69
|
+
};
|
|
70
|
+
/**
|
|
71
|
+
* Verifies identity tokens against `keys`, in §6.1's order. A `kid` the keys don't know triggers one refetch. Each
|
|
72
|
+
* refusal is reported to `onRefusal`, by default logged once per reason and key id.
|
|
73
|
+
*/
|
|
74
|
+
export declare const createIdentityVerifier: (keys: IdentityKeySource, options?: {
|
|
75
|
+
onRefusal?: (report: RefusalReport) => void;
|
|
76
|
+
}) => (token: string, expect: VerifyExpectations) => Promise<Verdict>;
|
|
77
|
+
export type IdentityVerifier = ReturnType<typeof createIdentityVerifier>;
|