@api.global/typedserver
Version:
A TypeScript-based project for easy serving of static files with support for live reloading, compression, and typed requests.
297 lines • 24.2 kB
JavaScript
import * as plugins from './typedserver_web.plugins.js';
import * as interfaces from '../dist_ts_interfaces/index.js';
import { logger } from './typedserver_web.logger.js';
logger.log('info', `TypedServer-Devtools initialized!`);
import { TypedserverStatusPill } from './typedserver_web.statuspill.js';
export class ReloadChecker {
reloadJustified = false;
backendConnectionLost = false;
statusPill = new TypedserverStatusPill();
store = new plugins.webstore.WebStore({
dbName: 'apiglobal__typedserver',
storeName: 'apiglobal__typedserver',
});
storeKey = 'lastServerChange';
typedsocket;
typedrouter = new plugins.typedrequest.TypedRouter();
swStatusUnsubscribe = null;
trafficLoggingEnabled = false;
constructor() {
// Listen to browser online/offline events
window.addEventListener('online', () => {
this.statusPill.updateStatus({
source: 'network',
type: 'online',
message: 'Back online',
persist: false,
timestamp: Date.now(),
});
});
window.addEventListener('offline', () => {
this.statusPill.updateStatus({
source: 'network',
type: 'offline',
message: 'No internet connection',
persist: true,
timestamp: Date.now(),
});
});
}
async reload() {
// this looks a bit hacky, but apparently is the safest way to really reload stuff
window.location.reload();
}
/**
* Subscribe to service worker status updates
*/
subscribeToServiceWorker() {
// Check if service worker client is available
if (globalThis.globalSw?.actionManager) {
this.swStatusUnsubscribe = globalThis.globalSw.actionManager.subscribeToStatusUpdates((status) => {
this.statusPill.updateStatus({
source: status.source,
type: status.type,
message: status.message,
details: status.details,
persist: status.persist || false,
timestamp: status.timestamp,
});
});
logger.log('info', 'Subscribed to service worker status updates');
// Get initial SW status
this.fetchServiceWorkerStatus();
}
else {
logger.log('note', 'Service worker client not available yet, will retry...');
// Retry after a delay
setTimeout(() => this.subscribeToServiceWorker(), 2000);
}
}
/**
* Fetch and display initial service worker status
*/
async fetchServiceWorkerStatus() {
if (!globalThis.globalSw?.actionManager)
return;
try {
const status = await globalThis.globalSw.actionManager.getServiceWorkerStatus();
if (status) {
this.statusPill.updateStatus({
source: 'serviceworker',
type: status.isActive ? 'connected' : 'disconnected',
message: status.isActive ? 'Service worker active' : 'Service worker inactive',
details: {
cacheHitRate: status.cacheHitRate,
resourceCount: status.resourceCount,
connectionType: status.connectionType,
},
persist: false,
timestamp: Date.now(),
});
}
}
catch (error) {
logger.log('warn', `Failed to get SW status: ${error}`);
}
}
/**
* starts the reload checker
*/
async performHttpRequest() {
logger.log('info', 'performing http check...');
(await this.store.get(this.storeKey))
? null
: await this.store.set(this.storeKey, globalThis.typedserver.lastReload);
let response;
try {
const controller = new AbortController();
plugins.smartdelay.delayFor(5000).then(() => {
controller.abort();
});
response = await fetch('/typedserver/reloadcheck', {
method: 'POST',
signal: controller.signal,
});
}
catch (err) { }
if (response?.status !== 200) {
this.backendConnectionLost = true;
logger.log('warn', `got a status ${response?.status}.`);
this.statusPill.updateStatus({
source: 'backend',
type: 'disconnected',
message: `Backend connection lost (${response?.status || 'timeout'})`,
persist: true,
timestamp: Date.now(),
});
}
if (response?.status === 200 && this.backendConnectionLost) {
this.backendConnectionLost = false;
this.statusPill.updateStatus({
source: 'backend',
type: 'connected',
message: 'Backend connection restored',
persist: false,
timestamp: Date.now(),
});
}
return response;
}
async checkReload(lastServerChange) {
let reloadJustified = false;
let storedLastServerChange = await this.store.get(this.storeKey);
if (storedLastServerChange && storedLastServerChange !== lastServerChange) {
reloadJustified = true;
}
else {
}
if (reloadJustified) {
this.store.set(this.storeKey, lastServerChange);
const hasSw = !!globalThis.globalSw;
this.statusPill.updateStatus({
source: 'serviceworker',
type: 'update',
message: hasSw ? 'Updating app...' : 'Upgrading...',
persist: true,
timestamp: Date.now(),
});
if (globalThis.globalSw?.purgeCache) {
await globalThis.globalSw.purgeCache();
}
else if ('caches' in window) {
// Fallback: clear caches via Cache API when service worker client isn't initialized
try {
const cacheKeys = await caches.keys();
await Promise.all(cacheKeys.map(key => caches.delete(key)));
logger.log('ok', 'Cleared caches via Cache API fallback');
}
catch (err) {
logger.log('warn', `Failed to clear caches via Cache API: ${err}`);
}
}
else {
console.log('globalThis.globalSw not found and Cache API not available...');
}
this.statusPill.updateStatus({
source: 'serviceworker',
type: 'cache',
message: 'Cache cleared, reloading...',
persist: true,
timestamp: Date.now(),
});
await plugins.smartdelay.delayFor(200);
this.reload();
return;
}
else {
// All good, hide after brief show
return;
}
}
async connectTypedsocket() {
if (!this.typedsocket) {
this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('pushLatestServerChangeTime', async (dataArg) => {
this.checkReload(dataArg.time);
return {};
}));
this.typedsocket = await plugins.typedsocket.TypedSocket.createClient(this.typedrouter, plugins.typedsocket.TypedSocket.useWindowLocationOriginUrl());
await this.typedsocket.setTag('typedserver_frontend', {});
this.typedsocket.statusSubject.subscribe(async (statusArg) => {
console.log(`typedsocket status: ${statusArg}`);
if (statusArg === 'disconnected' || statusArg === 'reconnecting') {
this.backendConnectionLost = true;
this.statusPill.updateStatus({
source: 'backend',
type: statusArg === 'disconnected' ? 'disconnected' : 'reconnecting',
message: `TypedSocket ${statusArg}`,
persist: true,
timestamp: Date.now(),
});
}
else if (statusArg === 'connected' && this.backendConnectionLost) {
this.backendConnectionLost = false;
this.statusPill.updateStatus({
source: 'backend',
type: 'connected',
message: 'TypedSocket connected',
persist: false,
timestamp: Date.now(),
});
// lets check if a reload is necessary
const getLatestServerChangeTime = this.typedsocket.createTypedRequest('getLatestServerChangeTime');
const response = await getLatestServerChangeTime.fire({});
this.checkReload(response.time);
}
});
logger.log('success', `ReloadChecker connected through typedsocket!`);
// Enable traffic logging for sw-dash
this.enableTrafficLogging();
}
}
started = false;
async start() {
this.started = true;
logger.log('info', `starting ReloadChecker...`);
// Subscribe to service worker status updates
this.subscribeToServiceWorker();
while (this.started) {
const response = await this.performHttpRequest();
if (response?.status === 200) {
logger.log('info', `ReloadChecker reached backend!`);
await this.checkReload(parseInt(await response.text()));
await this.connectTypedsocket();
}
await plugins.smartdelay.delayFor(120000);
}
}
async stop() {
this.started = false;
if (this.swStatusUnsubscribe) {
this.swStatusUnsubscribe();
this.swStatusUnsubscribe = null;
}
// Clear global hooks when stopping
if (this.trafficLoggingEnabled) {
plugins.typedrequest.TypedRouter.clearGlobalHooks();
this.trafficLoggingEnabled = false;
}
}
/**
* Enable TypedRequest traffic logging to the service worker
* Sets up global hooks on TypedRouter to capture all request/response traffic
*/
enableTrafficLogging() {
if (this.trafficLoggingEnabled) {
logger.log('note', 'Traffic logging already enabled');
return;
}
// Check if service worker client is available
if (!globalThis.globalSw?.actionManager) {
logger.log('note', 'Service worker client not available, will retry traffic logging setup...');
setTimeout(() => this.enableTrafficLogging(), 2000);
return;
}
const actionManager = globalThis.globalSw.actionManager;
// Helper function to log entries
const logEntry = (entry) => {
// Skip logging serviceworker_* methods to avoid infinite loops
// These are internal SW communication methods, not app traffic
if (entry.method.startsWith('serviceworker_')) {
return;
}
actionManager.logTypedRequest(entry);
};
// Set up global hooks on TypedRouter
plugins.typedrequest.TypedRouter.setGlobalHooks({
onOutgoingRequest: logEntry,
onIncomingResponse: logEntry,
onIncomingRequest: logEntry,
onOutgoingResponse: logEntry,
});
this.trafficLoggingEnabled = true;
logger.log('success', 'TypedRequest traffic logging enabled');
}
}
const reloadCheckInstance = new ReloadChecker();
reloadCheckInstance.start();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts_web_inject/index.ts"],"names":[],"mappings":"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"}