@tianacloud/dsh-remote 0.0.0-stage → 0.2.2

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.
@@ -0,0 +1,450 @@
1
+ const ROOT = '/__dsh_remote__/';
2
+ const DATABASE = 'dsh-remote-assets-v1';
3
+ const LIMIT = 64 << 20;
4
+ const MAX_ITEM = 16 << 20;
5
+ const TTL = 30 * 24 * 60 * 60 * 1000;
6
+ const decoder = new TextDecoder('utf-8', { fatal: true });
7
+
8
+ function requestResult(request) {
9
+ return new Promise((resolve, reject) => {
10
+ request.onsuccess = () => resolve(request.result);
11
+ request.onerror = () => reject(request.error);
12
+ });
13
+ }
14
+
15
+ function completion(transaction) {
16
+ return new Promise((resolve, reject) => {
17
+ transaction.oncomplete = resolve;
18
+ transaction.onabort = transaction.onerror = () => reject(transaction.error);
19
+ });
20
+ }
21
+
22
+ async function openDatabase() {
23
+ const request = indexedDB.open(DATABASE, 2);
24
+ request.onupgradeneeded = ({ oldVersion }) => {
25
+ const store = oldVersion === 0 ? request.result.createObjectStore('assets', { keyPath: 'id' })
26
+ : request.transaction.objectStore('assets');
27
+ if (oldVersion === 0) request.result.createObjectStore('generations');
28
+ store.createIndex('byUse', ['lastUsedAt', 'byteLength']);
29
+ };
30
+ return new Promise((resolve, reject) => {
31
+ request.onblocked = () => reject(new Error('IndexedDB 升级受阻'));
32
+ request.onsuccess = () => resolve(request.result);
33
+ request.onerror = () => reject(request.error);
34
+ });
35
+ }
36
+
37
+ async function digest(bytes) {
38
+ const value = new Uint8Array(await crypto.subtle.digest('SHA-256', bytes));
39
+ return Array.from(value, (byte) => byte.toString(16).padStart(2, '0')).join('');
40
+ }
41
+
42
+ async function verified(bytes, asset) {
43
+ return bytes instanceof Uint8Array && bytes.length === asset.byteLength && await digest(bytes) === asset.sha256;
44
+ }
45
+
46
+ export async function readFrontendBody(response, limit) {
47
+ if (!response.ok || !response.body) throw new Error('前端资源读取失败(HTTP ' + response.status + ')');
48
+ let { body } = response;
49
+ const encoding = response.headers.get('content-encoding') || 'identity';
50
+ if (encoding === 'gzip' && typeof DecompressionStream === 'function') {
51
+ body = body.pipeThrough(new DecompressionStream('gzip'));
52
+ } else if (encoding !== 'identity') {
53
+ throw new Error('不受支持的前端压缩格式');
54
+ }
55
+ const reader = body.getReader();
56
+ const parts = [];
57
+ let size = 0;
58
+ try {
59
+ for (;;) {
60
+ const { value, done } = await reader.read();
61
+ if (done) break;
62
+ size += value.length;
63
+ if (size > limit) throw new Error('前端资源超过已授权大小');
64
+ parts.push(value);
65
+ }
66
+ } catch (err) {
67
+ await reader.cancel().catch(() => {});
68
+ throw err;
69
+ } finally {
70
+ reader.releaseLock();
71
+ }
72
+ const bytes = new Uint8Array(size);
73
+ let offset = 0;
74
+ for (const part of parts) {
75
+ bytes.set(part, offset);
76
+ offset += part.length;
77
+ }
78
+ return bytes;
79
+ }
80
+
81
+ function frontendHeaders() {
82
+ return { 'x-dsh-encoding': typeof DecompressionStream === 'function' ? 'gzip' : 'identity' };
83
+ }
84
+
85
+ export async function requestFrontend(fetchAsset, signal) {
86
+ const response = await fetchAsset(ROOT + 'bootstrap.json', { headers: frontendHeaders(), signal });
87
+ return JSON.parse(decoder.decode(await readFrontendBody(response, 4 << 20)));
88
+ }
89
+
90
+ function scopeKey({ webId, tenantId, ownerUserId, hostId }) {
91
+ return JSON.stringify([webId, tenantId, ownerUserId, hostId]);
92
+ }
93
+
94
+ function isSameWebScope(serializedScope, webId) {
95
+ try {
96
+ const parsed = JSON.parse(serializedScope);
97
+ return Array.isArray(parsed) && parsed[0] === webId;
98
+ } catch {
99
+ return false;
100
+ }
101
+ }
102
+
103
+ export async function clearFrontendCache(identity) {
104
+ try {
105
+ const db = await openDatabase();
106
+ try {
107
+ const tx = db.transaction(['assets', 'generations'], 'readwrite');
108
+ const done = completion(tx);
109
+ const key = scopeKey(identity);
110
+ const store = tx.objectStore('assets');
111
+ const rows = await requestResult(store.getAllKeys());
112
+ for (const id of rows) {
113
+ if (id[0] === key) store.delete(id);
114
+ }
115
+ tx.objectStore('generations').delete(key);
116
+ await done;
117
+ } finally {
118
+ db.close();
119
+ }
120
+ } catch {
121
+ // The browser can opt out of persistent storage.
122
+ }
123
+ }
124
+
125
+ export async function clearWebFrontendCache(webId) {
126
+ if (!webId) return;
127
+ try {
128
+ const db = await openDatabase();
129
+ try {
130
+ const tx = db.transaction(['assets', 'generations'], 'readwrite');
131
+ const done = completion(tx);
132
+ const store = tx.objectStore('assets');
133
+ const rows = await requestResult(store.getAllKeys());
134
+ for (const id of rows) {
135
+ if (Array.isArray(id) && isSameWebScope(id[0], webId)) store.delete(id);
136
+ }
137
+ const generations = tx.objectStore('generations');
138
+ const genKeys = await requestResult(generations.getAllKeys());
139
+ for (const key of genKeys) {
140
+ if (typeof key === 'string' && isSameWebScope(key, webId)) generations.delete(key);
141
+ }
142
+ await done;
143
+ } finally {
144
+ db.close();
145
+ }
146
+ } catch {
147
+ // The browser can opt out of persistent storage.
148
+ }
149
+ }
150
+
151
+ export async function createFrontendLoader(manifest, identity, fetchAsset, signal) {
152
+ if (!Number.isSafeInteger(manifest.transformVersion) || !Number.isSafeInteger(manifest.generation) ||
153
+ !Array.isArray(manifest.styles) || !Array.isArray(manifest.resources) ||
154
+ manifest.resources.length > 4096 || !manifest.boot) {
155
+ throw new Error('前端清单版本不受支持,请同步更新主机和应用');
156
+ }
157
+ const assets = new Map();
158
+ let total = 0;
159
+ for (const asset of manifest.resources) {
160
+ if (!/^(core|plugin|chunk|asset):[^\r\n]+$/u.test(asset.key) || assets.has(asset.key) ||
161
+ !/^[a-f0-9]{64}$/u.test(asset.sha256) || asset.rev !== asset.sha256 ||
162
+ !Number.isSafeInteger(asset.byteLength) || asset.byteLength < 0 || asset.byteLength > MAX_ITEM ||
163
+ typeof asset.mimeType !== 'string' || !/^[a-z0-9.+-]+\/[a-z0-9.+-]+$/ui.test(asset.mimeType)) {
164
+ throw new Error('无效的前端资源清单');
165
+ }
166
+ total += asset.byteLength;
167
+ assets.set(asset.key, asset);
168
+ }
169
+ if (total > LIMIT) throw new Error('前端清单超过预算');
170
+ for (const asset of assets.values()) {
171
+ for (const link of asset.links ?? []) {
172
+ if (!/^__DSH_(?:CORE|STYLE)_LINK_[0-9]+__$/u.test(link.marker) || !assets.has(link.key)) {
173
+ throw new Error('无效的前端依赖');
174
+ }
175
+ }
176
+ }
177
+
178
+ const scope = scopeKey(identity);
179
+ const version = manifest.transformVersion;
180
+ const generation = [manifest.generation, manifest.serial];
181
+ const cacheId = (key) => [scope, version, key];
182
+ const db = await openDatabase().catch(() => null);
183
+ if (db) {
184
+ try {
185
+ const tx = db.transaction(['assets', 'generations'], 'readwrite');
186
+ const done = completion(tx);
187
+ const epochs = tx.objectStore('generations');
188
+ const previous = await requestResult(epochs.get(scope));
189
+ if (!previous || previous[0] < generation[0] || (previous[0] === generation[0] && previous[1] <= generation[1])) {
190
+ epochs.put(generation, scope);
191
+ const entries = tx.objectStore('assets');
192
+ const cursor = entries.openCursor();
193
+ cursor.onsuccess = () => {
194
+ const row = cursor.result;
195
+ if (!row) return;
196
+ const [owner, itemVersion, itemKey] = row.primaryKey;
197
+ if (row.value.lastUsedAt < Date.now() - TTL ||
198
+ (owner !== scope && isSameWebScope(owner, identity.webId)) ||
199
+ (owner === scope && (itemVersion !== version || !assets.has(itemKey)))) row.delete();
200
+ row.continue();
201
+ };
202
+ const genCursor = epochs.openCursor();
203
+ genCursor.onsuccess = () => {
204
+ const row = genCursor.result;
205
+ if (!row) return;
206
+ if (row.primaryKey !== scope && isSameWebScope(row.primaryKey, identity.webId)) row.delete();
207
+ row.continue();
208
+ };
209
+ }
210
+ await done;
211
+ } catch {
212
+ // Integrity checks are independent of persistence.
213
+ }
214
+ }
215
+
216
+ const pendingBytes = new Map();
217
+ const urls = new Map();
218
+ const ownedUrls = new Set();
219
+ const routeMap = new Map();
220
+ for (const asset of assets.values()) {
221
+ if (typeof asset.route === 'string') routeMap.set(asset.route, asset.key);
222
+ }
223
+
224
+ async function store(asset, bytes) {
225
+ if (!db || signal.aborted) return;
226
+ try {
227
+ const tx = db.transaction(['assets', 'generations'], 'readwrite');
228
+ const done = completion(tx);
229
+ const current = await requestResult(tx.objectStore('generations').get(scope));
230
+ if (current?.[0] === generation[0] && current[1] === generation[1] && !signal.aborted) {
231
+ const entries = tx.objectStore('assets');
232
+ entries.put({
233
+ id: cacheId(asset.key), rev: asset.rev, sha256: asset.sha256,
234
+ mimeType: asset.mimeType, byteLength: bytes.length, bytes, lastUsedAt: Date.now(),
235
+ });
236
+ // Sort only metadata, not asset data, after this write commits into the transaction.
237
+ const request = entries.index('byUse').openKeyCursor();
238
+ const metadata = [];
239
+ request.onsuccess = () => {
240
+ const cursor = request.result;
241
+ if (cursor) {
242
+ const [lastUsedAt, byteLength] = cursor.key;
243
+ metadata.push({ id: cursor.primaryKey, byteLength, lastUsedAt });
244
+ cursor.continue();
245
+ return;
246
+ }
247
+ let size = metadata.reduce((sum, item) => sum + item.byteLength, 0);
248
+ for (const item of metadata.sort((a, b) => a.lastUsedAt - b.lastUsedAt)) {
249
+ if (size <= LIMIT) break;
250
+ entries.delete(item.id);
251
+ size -= item.byteLength;
252
+ }
253
+ };
254
+ }
255
+ await done;
256
+ } catch {
257
+ // This page retains its verified bytes when writes or quota fail.
258
+ }
259
+ }
260
+
261
+ async function read(asset) {
262
+ signal.throwIfAborted();
263
+ let cached;
264
+ if (db) {
265
+ try {
266
+ cached = await requestResult(db.transaction('assets').objectStore('assets').get(cacheId(asset.key)));
267
+ } catch {
268
+ // Opening or reading IndexedDB can fail in private environments.
269
+ }
270
+ }
271
+ if (cached?.rev === asset.rev && await verified(cached.bytes, asset)) {
272
+ await store(asset, cached.bytes);
273
+ return cached.bytes;
274
+ }
275
+ if (db && cached?.rev === asset.rev) {
276
+ try {
277
+ const tx = db.transaction(['assets', 'generations'], 'readwrite');
278
+ const done = completion(tx);
279
+ const current = await requestResult(tx.objectStore('generations').get(scope));
280
+ if (current?.[0] === generation[0] && current[1] === generation[1]) {
281
+ tx.objectStore('assets').delete(cacheId(asset.key));
282
+ }
283
+ await done;
284
+ } catch {
285
+ // The trusted response can still replace an invalid local record.
286
+ }
287
+ }
288
+ const params = new URLSearchParams({ key: asset.key, rev: asset.rev });
289
+ const response = await fetchAsset(ROOT + 'asset?' + params, { headers: frontendHeaders(), signal });
290
+ if (response.headers.get('content-type') !== asset.mimeType) throw new Error('前端资源类型与清单不一致');
291
+ const bytes = await readFrontendBody(response, asset.byteLength);
292
+ if (!await verified(bytes, asset)) throw new Error('前端资源 SHA-256 校验失败');
293
+ signal.throwIfAborted();
294
+ await store(asset, bytes);
295
+ return bytes;
296
+ }
297
+
298
+ function bytesFor(key) {
299
+ const asset = assets.get(key);
300
+ if (!asset) throw new Error('资源不在授权清单');
301
+ if (!pendingBytes.has(key)) pendingBytes.set(key, read(asset));
302
+ return pendingBytes.get(key);
303
+ }
304
+
305
+ function blob(bytes, type) {
306
+ signal.throwIfAborted();
307
+ const url = URL.createObjectURL(new Blob([bytes], { type }));
308
+ ownedUrls.add(url);
309
+ return url;
310
+ }
311
+
312
+ function urlFor(key, ancestry = []) {
313
+ if (ancestry.includes(key)) throw new Error('前端静态模块存在循环依赖');
314
+ if (!urls.has(key)) {
315
+ urls.set(key, (async () => {
316
+ const asset = assets.get(key);
317
+ const bytes = await bytesFor(key);
318
+ if (!asset.links?.length) return blob(bytes, asset.mimeType);
319
+ let text = decoder.decode(bytes);
320
+ for (const { marker, key: dependency } of asset.links) {
321
+ const target = await urlFor(dependency, [...ancestry, key]);
322
+ text = text.replaceAll(marker, target);
323
+ }
324
+ return blob(text, asset.mimeType);
325
+ })());
326
+ }
327
+ return urls.get(key);
328
+ }
329
+
330
+ const registered = new Set();
331
+ let scriptQueue = Promise.resolve();
332
+ async function execute(key) {
333
+ if (registered.has(key)) return;
334
+ const asset = assets.get(key);
335
+ const classicUrl = blob(await bytesFor(key), 'text/javascript');
336
+ const target = globalThis.__ModuleLoader__;
337
+ const accept = target.load;
338
+ let registration;
339
+ target.load = (value) => {
340
+ if (!signal.aborted && !registration && value?.id === asset.registration &&
341
+ value.chunk === asset.chunk && typeof value.factory === 'function') registration = value;
342
+ };
343
+ try {
344
+ await new Promise((resolve, reject) => {
345
+ const script = document.createElement('script');
346
+ const finish = (err) => {
347
+ script.remove();
348
+ signal.removeEventListener('abort', abort);
349
+ if (err) reject(err);
350
+ else resolve();
351
+ };
352
+ const abort = () => finish(signal.reason);
353
+ script.addEventListener('load', () => finish(), { once: true });
354
+ script.addEventListener('error', () => finish(new Error('DSH 插件无法执行')), { once: true });
355
+ signal.addEventListener('abort', abort, { once: true });
356
+ script.src = classicUrl;
357
+ document.head.append(script);
358
+ });
359
+ signal.throwIfAborted();
360
+ if (!registration) throw new Error('DSH 插件注册与清单不一致: ' + asset.owner);
361
+ accept.call(target, registration);
362
+ registered.add(key);
363
+ } finally {
364
+ target.load = accept;
365
+ URL.revokeObjectURL(classicUrl);
366
+ ownedUrls.delete(classicUrl);
367
+ }
368
+ }
369
+
370
+ function queueScript(key) {
371
+ const task = scriptQueue.then(() => execute(key));
372
+ scriptQueue = task.catch(() => {});
373
+ return task;
374
+ }
375
+
376
+ const resolvedAssets = new Map();
377
+ const assetByUrl = new Map();
378
+ return {
379
+ manifest,
380
+ async prepare() {
381
+ const preload = [...assets.keys()].filter((key) => key.startsWith('asset:') || key.startsWith('plugin:'));
382
+ let next = 0;
383
+ await Promise.all([
384
+ urlFor(manifest.entry),
385
+ ...manifest.styles.map((key) => urlFor(key)),
386
+ ...Array.from({ length: 4 }, async () => {
387
+ while (next < preload.length) {
388
+ const key = preload[next++];
389
+ if (key.startsWith('asset:')) {
390
+ const url = await urlFor(key);
391
+ resolvedAssets.set(assets.get(key).route, url);
392
+ assetByUrl.set(url, key);
393
+ } else await bytesFor(key);
394
+ }
395
+ }),
396
+ ]);
397
+ },
398
+ async install() {
399
+ for (const key of assets.keys()) if (key.startsWith('plugin:')) await queueScript(key);
400
+ await Promise.all(manifest.styles.map(async (key) => {
401
+ const sheet = document.createElement('link');
402
+ const url = await urlFor(key);
403
+ sheet.rel = 'stylesheet';
404
+ await new Promise((resolve, reject) => {
405
+ sheet.onload = resolve;
406
+ sheet.onerror = () => reject(new Error('DSH 样式资源无法加载'));
407
+ sheet.href = url;
408
+ document.head.append(sheet);
409
+ });
410
+ }));
411
+ },
412
+ async importCore(key) {
413
+ if (!key.startsWith('core:') || assets.get(key)?.mimeType !== 'text/javascript') throw new Error('无效的核心模块');
414
+ return import(await urlFor(key));
415
+ },
416
+ loadBundle(reference) {
417
+ const route = String(reference).replace(/^\//u, '');
418
+ const key = routeMap.get(route);
419
+ if (!key || !/^(plugin|chunk):/u.test(key)) return Promise.reject(new Error('插件版本已变化,请刷新工作台'));
420
+ return queueScript(key);
421
+ },
422
+ resolveAsset(reference) {
423
+ const route = String(reference).replace(/^\//u, '');
424
+ const url = resolvedAssets.get(route);
425
+ if (!url) throw new Error('插件资源未获准或不存在');
426
+ return url;
427
+ },
428
+ fetchAssetUrl(url, method, requestSignal) {
429
+ const key = assetByUrl.get(url);
430
+ if (!key) return undefined;
431
+ return (async () => {
432
+ signal.throwIfAborted();
433
+ requestSignal?.throwIfAborted();
434
+ if (method !== 'GET' && method !== 'HEAD') return new Response(null, { status: 405 });
435
+ const item = assets.get(key);
436
+ const bytes = await bytesFor(key);
437
+ requestSignal?.throwIfAborted();
438
+ return new Response(method === 'HEAD' ? null : bytes, {
439
+ headers: { 'content-type': item.mimeType, 'content-length': String(bytes.length) },
440
+ });
441
+ })();
442
+ },
443
+ close() {
444
+ db?.close();
445
+ for (const url of ownedUrls) URL.revokeObjectURL(url);
446
+ ownedUrls.clear();
447
+ assetByUrl.clear();
448
+ },
449
+ };
450
+ }